@ai-setting/roy-agent-core 1.5.58 → 1.5.60

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

@@ -184,6 +184,7 @@ class SQLiteTaskStore {
       )
     `);
     this.db.run("CREATE INDEX IF NOT EXISTS idx_task_tag_relation_tag_id ON task_tag_relation(tag_id)");
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_task_parent_task_id ON task(parent_task_id)");
     if (this.dbPath !== ":memory:") {
       try {
         const { runMigration: runMigration001 } = (init_001_add_project_path_context(), __toCommonJS(exports_001_add_project_path_context));
@@ -308,24 +309,36 @@ class SQLiteTaskStore {
   }
   async listTasks(options) {
     await this.initialize();
-    let sql = "SELECT * FROM task WHERE 1=1";
-    const params = [];
+    if (options?.depth !== undefined && options.depth >= 0 && options.parent_task_id === undefined) {
+      return this.listTasksByDepth(options);
+    }
+    const whereClauses = ["1=1"];
+    const whereParams = [];
     if (options?.status) {
-      sql += " AND status = ?";
-      params.push(options.status);
+      whereClauses.push("status = ?");
+      whereParams.push(options.status);
     }
     if (options?.priority) {
-      sql += " AND priority = ?";
-      params.push(options.priority);
+      whereClauses.push("priority = ?");
+      whereParams.push(options.priority);
     }
     if (options?.type) {
-      sql += " AND type = ?";
-      params.push(options.type);
+      whereClauses.push("type = ?");
+      whereParams.push(options.type);
     }
     if (options?.parent_task_id !== undefined) {
-      sql += " AND parent_task_id = ?";
-      params.push(options.parent_task_id);
-    }
+      whereClauses.push("parent_task_id = ?");
+      whereParams.push(options.parent_task_id);
+    }
+    if (!options?.include_archived && options?.status !== "archived") {
+      whereClauses.push("status != 'archived'");
+    }
+    const whereSql = whereClauses.join(" AND ");
+    const countSql = `SELECT COUNT(*) as total FROM task WHERE ${whereSql}`;
+    const countRow = this.db.prepare(countSql).get(...whereParams);
+    const total = countRow?.total ?? 0;
+    let sql = `SELECT * FROM task WHERE ${whereSql}`;
+    const params = [...whereParams];
     sql += " ORDER BY updated_at DESC";
     if (options?.limit) {
       sql += " LIMIT ?";
@@ -337,11 +350,96 @@ class SQLiteTaskStore {
     }
     const stmt = this.db.prepare(sql);
     const rows = stmt.all(...params);
-    return rows.map((row) => {
+    const tasks = rows.map((row) => {
       const task = this.rowToTask(row);
       this.tasksCache.set(task.id, task);
       return task;
     });
+    return { tasks, total };
+  }
+  async listTasksByDepth(options) {
+    const depth = options.depth ?? 0;
+    const filterClauses = ["1=1"];
+    const filterParams = [];
+    if (options.status) {
+      filterClauses.push("status = ?");
+      filterParams.push(options.status);
+    }
+    if (options.priority) {
+      filterClauses.push("priority = ?");
+      filterParams.push(options.priority);
+    }
+    if (options.type) {
+      filterClauses.push("type = ?");
+      filterParams.push(options.type);
+    }
+    if (!options?.include_archived && options?.status !== "archived") {
+      filterClauses.push("status != 'archived'");
+    }
+    const filterSql = filterClauses.join(" AND ");
+    const collected = [];
+    if (depth === 0) {
+      const rootSql = `SELECT * FROM task WHERE parent_task_id IS NULL AND ${filterSql} ORDER BY updated_at DESC`;
+      const rows = this.db.prepare(rootSql).all(...filterParams);
+      for (const row of rows) {
+        const t = this.rowToTask(row);
+        this.tasksCache.set(t.id, t);
+        collected.push(t);
+      }
+    } else {
+      const rootRows = this.db.prepare(`SELECT * FROM task WHERE parent_task_id IS NULL AND ${filterSql} ORDER BY updated_at DESC`).all(...filterParams);
+      let currentLevel = rootRows.map((row) => {
+        const t = this.rowToTask(row);
+        this.tasksCache.set(t.id, t);
+        return t;
+      });
+      collected.push(...currentLevel);
+      for (let level = 1;level <= depth; level++) {
+        if (currentLevel.length === 0)
+          break;
+        const ids = currentLevel.map((t) => t.id);
+        const placeholders = ids.map(() => "?").join(",");
+        const childSql = `SELECT * FROM task WHERE parent_task_id IN (${placeholders}) AND ${filterSql} ORDER BY updated_at DESC`;
+        const childRows = this.db.prepare(childSql).all(...ids, ...filterParams);
+        const nextLevel = childRows.map((row) => {
+          const t = this.rowToTask(row);
+          this.tasksCache.set(t.id, t);
+          return t;
+        });
+        collected.push(...nextLevel);
+        currentLevel = nextLevel;
+      }
+    }
+    const total = collected.length;
+    const offset = options.offset ?? 0;
+    const limit = options.limit ?? total;
+    const sliced = collected.slice(offset, offset + limit);
+    return { tasks: sliced, total };
+  }
+  async getTaskTree(taskId, depth = -1) {
+    await this.initialize();
+    const result = [];
+    let currentLevel = [taskId];
+    let currentDepth = 0;
+    while (currentLevel.length > 0) {
+      if (depth !== -1 && currentDepth >= depth)
+        break;
+      const placeholders = currentLevel.map(() => "?").join(",");
+      const rows = this.db.prepare(`SELECT * FROM task WHERE parent_task_id IN (${placeholders}) ORDER BY updated_at DESC`).all(...currentLevel);
+      const nextLevel = [];
+      for (const row of rows) {
+        const t = this.rowToTask(row);
+        this.tasksCache.set(t.id, t);
+        result.push(t);
+        nextLevel.push(t.id);
+      }
+      currentLevel = nextLevel;
+      currentDepth++;
+    }
+    return result;
+  }
+  async getChildTasks(taskId, options = {}) {
+    return this.listTasks({ ...options, parent_task_id: taskId });
   }
   async createOperation(options) {
     await this.initialize();
@@ -599,9 +697,13 @@ class SQLiteTaskStore {
   async searchTasksByKeywords(keywords, options = {}) {
     await this.initialize();
     if (!keywords || keywords.length === 0) {
-      return [];
+      return { tasks: [], total: 0 };
+    }
+    const { limit = 20, offset = 0, excludeTaskId, status, priority, type, depth } = options;
+    let allowedTaskIds = null;
+    if (depth !== undefined && depth >= 0) {
+      allowedTaskIds = await this.collectTaskIdsByDepth(depth);
     }
-    const { limit = 20, excludeTaskId } = options;
     const tasks = new Map;
     let taskSql = "SELECT * FROM task WHERE 1=1";
     const taskParams = [];
@@ -609,17 +711,37 @@ class SQLiteTaskStore {
       taskSql += " AND id != ?";
       taskParams.push(excludeTaskId);
     }
+    if (status) {
+      taskSql += " AND status = ?";
+      taskParams.push(status);
+    }
+    if (priority) {
+      taskSql += " AND priority = ?";
+      taskParams.push(priority);
+    }
+    if (type) {
+      taskSql += " AND type = ?";
+      taskParams.push(type);
+    }
+    if (!options?.include_archived && options?.status !== "archived") {
+      taskSql += " AND status != 'archived'";
+    }
+    const scanLimit = Math.max(limit * 5, 200);
     taskSql += " ORDER BY updated_at DESC LIMIT ?";
-    taskParams.push(limit * 2);
+    taskParams.push(scanLimit);
     const taskRows = this.db.prepare(taskSql).all(...taskParams);
     for (const row of taskRows) {
       const task = this.rowToTask(row);
+      const matchedKeywords = new Set;
       let matchCount = 0;
       if (task.title) {
         const lowerTitle = task.title.toLowerCase();
         for (const keyword of keywords) {
           if (lowerTitle.includes(keyword.toLowerCase())) {
-            matchCount++;
+            {
+              matchCount++;
+              matchedKeywords.add(keyword);
+            }
           }
         }
       }
@@ -627,7 +749,10 @@ class SQLiteTaskStore {
         for (const keyword of keywords) {
           const lowerKeyword = keyword.toLowerCase();
           if (task.tags.some((tag) => tag.toLowerCase().includes(lowerKeyword))) {
-            matchCount += 2;
+            {
+              matchCount += 2;
+              matchedKeywords.add(keyword);
+            }
           }
         }
       }
@@ -635,7 +760,10 @@ class SQLiteTaskStore {
         const lowerDesc = task.description.toLowerCase();
         for (const keyword of keywords) {
           if (lowerDesc.includes(keyword.toLowerCase())) {
-            matchCount++;
+            {
+              matchCount++;
+              matchedKeywords.add(keyword);
+            }
           }
         }
       }
@@ -643,11 +771,14 @@ class SQLiteTaskStore {
         const lowerGoals = task.goals_and_expected_deliverables.toLowerCase();
         for (const keyword of keywords) {
           if (lowerGoals.includes(keyword.toLowerCase())) {
-            matchCount++;
+            {
+              matchCount++;
+              matchedKeywords.add(keyword);
+            }
           }
         }
       }
-      if (matchCount > 0) {
+      if (matchedKeywords.size === keywords.length) {
         tasks.set(task.id, { task, matchCount });
       }
     }
@@ -659,31 +790,99 @@ class SQLiteTaskStore {
           AND (action_title LIKE ? OR action_description LIKE ?)
         LIMIT 10
       `;
+      const opMatchedKeywords = new Set;
       for (const keyword of keywords) {
         const pattern = `%${keyword}%`;
         const ops = this.db.prepare(opSql).all(opRow.task_id, pattern, pattern);
         if (ops.length > 0) {
-          const taskRow = this.db.prepare("SELECT * FROM task WHERE id = ?").get(opRow.task_id);
-          if (taskRow) {
-            const task = this.rowToTask(taskRow);
-            if (excludeTaskId && task.id === excludeTaskId)
-              continue;
-            const existing = tasks.get(task.id);
-            if (existing) {
-              existing.matchCount += 2;
-            } else {
-              tasks.set(task.id, { task, matchCount: 2 });
-            }
+          opMatchedKeywords.add(keyword);
+        }
+      }
+      if (opMatchedKeywords.size === 0)
+        continue;
+      const taskRow = this.db.prepare("SELECT * FROM task WHERE id = ?").get(opRow.task_id);
+      if (!taskRow)
+        continue;
+      const task = this.rowToTask(taskRow);
+      if (excludeTaskId && task.id === excludeTaskId)
+        continue;
+      if (status && task.status !== status)
+        continue;
+      if (priority && task.priority !== priority)
+        continue;
+      if (type && task.type !== type)
+        continue;
+      if (!options?.include_archived && task.status === "archived")
+        continue;
+      const existing = tasks.get(task.id);
+      if (existing) {
+        existing.matchCount += 2;
+      } else {
+        const combinedKeywords = new Set(opMatchedKeywords);
+        if (task.title) {
+          const lowerTitle = task.title.toLowerCase();
+          for (const kw of keywords) {
+            if (lowerTitle.includes(kw.toLowerCase()))
+              combinedKeywords.add(kw);
+          }
+        }
+        if (task.description) {
+          const lowerDesc = task.description.toLowerCase();
+          for (const kw of keywords) {
+            if (lowerDesc.includes(kw.toLowerCase()))
+              combinedKeywords.add(kw);
+          }
+        }
+        if (task.goals_and_expected_deliverables) {
+          const lowerGoals = task.goals_and_expected_deliverables.toLowerCase();
+          for (const kw of keywords) {
+            if (lowerGoals.includes(kw.toLowerCase()))
+              combinedKeywords.add(kw);
+          }
+        }
+        if (task.tags && Array.isArray(task.tags)) {
+          for (const kw of keywords) {
+            if (task.tags.some((tag) => tag.toLowerCase().includes(kw.toLowerCase())))
+              combinedKeywords.add(kw);
           }
         }
+        if (combinedKeywords.size === keywords.length) {
+          tasks.set(task.id, { task, matchCount: 2 });
+        }
       }
     }
-    const results = Array.from(tasks.values()).sort((a, b) => b.matchCount - a.matchCount).slice(0, limit).map((item) => item.task);
-    return results;
+    let sorted = Array.from(tasks.values()).sort((a, b) => b.matchCount - a.matchCount);
+    if (allowedTaskIds !== null) {
+      sorted = sorted.filter((item) => allowedTaskIds.has(item.task.id));
+    }
+    const total = sorted.length;
+    const sliced = sorted.slice(offset, offset + limit);
+    const resultTasks = sliced.map((item) => item.task);
+    return { tasks: resultTasks, total };
+  }
+  async collectTaskIdsByDepth(depth) {
+    const ids = new Set;
+    const rootRows = this.db.prepare("SELECT id FROM task WHERE parent_task_id IS NULL").all();
+    let currentLevel = rootRows.map((r) => r.id);
+    for (const id of currentLevel)
+      ids.add(id);
+    if (depth === 0)
+      return ids;
+    for (let level = 1;level <= depth; level++) {
+      if (currentLevel.length === 0)
+        break;
+      const placeholders = currentLevel.map(() => "?").join(",");
+      const rows = this.db.prepare(`SELECT id FROM task WHERE parent_task_id IN (${placeholders})`).all(...currentLevel);
+      currentLevel = rows.map((r) => r.id);
+      for (const id of currentLevel)
+        ids.add(id);
+    }
+    return ids;
   }
   async findSimilarTasksByKeywords(keywords, options = {}) {
     const mergedOptions = { ...options, limit: options.limit ?? 5 };
-    return this.searchTasksByKeywords(keywords, mergedOptions);
+    const result = await this.searchTasksByKeywords(keywords, mergedOptions);
+    return result.tasks;
   }
   async findSimilarTasks(taskId, limit = 5) {
     await this.initialize();

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

@@ -642,7 +642,7 @@ No need to poll — just wait for the notification and use \`task_get\` with the
         phase: "before",
         hookPoint: TaskHookPoints.DELEGATE_BEFORE
       };
-      await globalHookManager.execute(TaskHookPoints.DELEGATE_BEFORE, hookCtx, { sessionId: parentSessionId });
+      await globalHookManager.execute(TaskHookPoints.DELEGATE_BEFORE, delegateCtx, { sessionId: parentSessionId });
       promptWithTaskInfo = delegateCtx.prompt;
       return await handleBackgroundTask(backgroundTaskManager, parentSessionId, description, promptWithTaskInfo, delegateCtx.subagentType, delegateCtx.timeout);
     }

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

@@ -1,6 +1,6 @@
 import {
   withTimeout
-} from "./roy-agent-core-65yjzwv5.js";
+} from "./roy-agent-core-nd3amf4x.js";
 import {
   AskUserError,
   init_workflow_hil
@@ -575,14 +575,14 @@ class AgentComponent extends BaseComponent {
       agentContext: parentEnvContext?.agentContext ?? {},
       traceId: effectiveContext.metadata?.traceId,
       sessionId: effectiveContext.sessionId,
-      userId: effectiveContext.metadata?.userId ?? "",
+      userId: parentEnvContext?.userId ?? (effectiveContext.metadata?.userId ?? ""),
       messageId: effectiveContext.metadata?.messageId,
-      pluginEnabled: effectiveContext.pluginEnabled,
+      pluginEnabled: { ...parentEnvContext?.pluginEnabled ?? {}, ...effectiveContext.pluginEnabled ?? {} },
       plugins: effectiveContext.plugins,
-      envEvent: effectiveContext.envEvent,
-      replyChannel: effectiveContext.envEvent?.metadata?.replyChannel,
-      sourceId: effectiveContext.envEvent?.metadata?.sourceId,
-      sourceType: effectiveContext.envEvent?.metadata?.sourceType,
+      envEvent: effectiveContext.envEvent ?? parentEnvContext?.envEvent,
+      replyChannel: parentEnvContext?.replyChannel ?? effectiveContext.envEvent?.metadata?.replyChannel,
+      sourceId: parentEnvContext?.sourceId ?? effectiveContext.envEvent?.metadata?.sourceId,
+      sourceType: parentEnvContext?.sourceType ?? effectiveContext.envEvent?.metadata?.sourceType,
       metadata: { ...effectiveContext.metadata }
     };
     return await runWithEnvContextAsync(envContext, async () => {
@@ -647,9 +647,19 @@ class AgentComponent extends BaseComponent {
               break;
             }
             finalText = llmOutput.content;
+            const assistantParts = [
+              { type: "text", text: llmOutput.content }
+            ];
+            if (llmOutput.reasoning) {
+              assistantParts.push({
+                type: "reasoning",
+                text: llmOutput.reasoning,
+                reasoningType: "core"
+              });
+            }
             this.pushMessage(hookCtx, {
               role: "assistant",
-              content: llmOutput.content
+              content: assistantParts
             });
             break;
           }
@@ -1030,7 +1040,7 @@ ${additionInfo}`
           },
           abortSignal: ctx.context.abort
         });
-        const result = await withTimeout(llmPromise, 120000, "LLM invocation timeout after 120s");
+        const result = await withTimeout(llmPromise, 300000, "LLM invocation timeout after 300s");
         logger.debug("[invokeLLM] LLMComponent.invoke returned successfully");
         return {
           content: result.output?.content || "",

package/dist/shared/@ai-setting/{roy-agent-core-65yjzwv5.js → roy-agent-core-nd3amf4x.js}

@@ -384,6 +384,7 @@ async function invoke(config, options, ctx) {
     };
     const result = await streamText(streamTextOptions);
     let fullContent = "";
+    let rawFullContent = "";
     let reasoningContent = "";
     const toolCalls = [];
     let usageInfo;
@@ -405,6 +406,7 @@ async function invoke(config, options, ctx) {
             isThinkingTagOpen = thinkingResult.isThinkingTagOpen;
             currentThinkingContent = thinkingResult.currentThinkingContent;
             fullContent += thinkingResult.cleanedText;
+            rawFullContent += textDelta;
             for (const reasoningSnapshot of thinkingResult.reasoningEvents) {
               const delta = reasoningSnapshot.slice(reasoningContent.length);
               reasoningContent = reasoningSnapshot;
@@ -417,6 +419,7 @@ async function invoke(config, options, ctx) {
             }
           } else {
             fullContent += textDelta;
+            rawFullContent += textDelta;
             if (emitToEnv) {
               emitToEnv({ type: "text", content: fullContent, delta: textDelta });
             }
@@ -477,7 +480,7 @@ async function invoke(config, options, ctx) {
       return {
         toolCallId: firstToolCall.id,
         result: JSON.stringify({
-          content: fullContent,
+          content: rawFullContent,
           reasoning: reasoningContent || undefined,
           tool_calls: toolCalls.map((tc) => ({
             id: tc.id,
@@ -492,7 +495,7 @@ async function invoke(config, options, ctx) {
     return {
       toolCallId: "invoke-" + Date.now(),
       result: JSON.stringify({
-        content: fullContent,
+        content: rawFullContent,
         reasoning: reasoningContent || undefined,
         usage: usageInfo,
         model

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

@@ -402,6 +402,7 @@ var NotifyType;
   NotifyType2["TASK_COMPLETED"] = "task_completed";
   NotifyType2["TASK_UPDATED"] = "task_updated";
   NotifyType2["TASK_FAILED"] = "task_failed";
+  NotifyType2["OPERATION_CREATED"] = "operation_created";
 })(NotifyType ||= {});
 
 class LarkCliTaskNotifyHook {
@@ -411,6 +412,7 @@ class LarkCliTaskNotifyHook {
   pluginName;
   sourceId;
   config;
+  lastNotifyTimestamps = new Map;
   constructor(config = {}) {
     this.name = config.pluginName || "LarkCliTaskNotifyHook";
     this.priority = config.priority ?? 5;
@@ -420,7 +422,12 @@ class LarkCliTaskNotifyHook {
     this.config = {
       enabled: true,
       priority: 5,
-      notifyTypes: ["task_completed" /* TASK_COMPLETED */],
+      notifyTypes: [
+        "task_created" /* TASK_CREATED */,
+        "task_updated" /* TASK_UPDATED */,
+        "task_completed" /* TASK_COMPLETED */,
+        "operation_created" /* OPERATION_CREATED */
+      ],
       ...config
     };
   }
@@ -443,6 +450,9 @@ class LarkCliTaskNotifyHook {
       case TaskHookPoints.AFTER_UPDATE:
         await this.onAfterUpdate(ctx);
         break;
+      case TaskHookPoints.OPERATION_AFTER_CREATE:
+        await this.onAfterOperationCreate(ctx);
+        break;
     }
   }
   async onAfterCreate(ctx) {
@@ -456,12 +466,11 @@ class LarkCliTaskNotifyHook {
     });
   }
   async onAfterUpdate(ctx) {
-    const hookCtx = ctx.data;
-    const innerData = hookCtx.data;
-    if (!innerData) {
+    const data = ctx.data;
+    if (!data) {
       return;
     }
-    const { task, changes } = innerData;
+    const { task, changes } = data;
     if (!task) {
       return;
     }
@@ -489,6 +498,25 @@ class LarkCliTaskNotifyHook {
       _hookContext: ctx
     });
   }
+  async onAfterOperationCreate(ctx) {
+    const { operation } = ctx.data;
+    if (!operation) {
+      logger2.debug("onAfterOperationCreate: operation is missing, skip");
+      return;
+    }
+    if (!this.shouldNotify("operation_created" /* OPERATION_CREATED */)) {
+      return;
+    }
+    if (this.shouldThrottleOperation(operation)) {
+      return;
+    }
+    await this.sendNotify({
+      type: "operation_created" /* OPERATION_CREATED */,
+      title: this.getNotifyTitle("operation_created" /* OPERATION_CREATED */),
+      content: this.formatOperationCreated(operation),
+      _hookContext: ctx
+    });
+  }
   async sendNotify(options) {
     const { type, title, content, _hookContext } = options;
     const env = getEnvContextOrEmpty();
@@ -594,6 +622,8 @@ ${content}`;
         return "\uD83D\uDCCB 任务已更新";
       case "task_failed" /* TASK_FAILED */:
         return "❌ 任务执行失败";
+      case "operation_created" /* OPERATION_CREATED */:
+        return "\uD83D\uDCCC 操作记录";
       default:
         return "\uD83D\uDCEC 任务通知";
     }
@@ -633,6 +663,43 @@ ${content}`;
       lines.push(`- **变更**: ${changeKeys.join(", ")}`);
     }
     return lines.join(`
+`);
+  }
+  shouldThrottleOperation(operation) {
+    const throttleMs = this.config.operationThrottleMs ?? 5000;
+    if (throttleMs <= 0) {
+      return false;
+    }
+    const key = `op:${operation.taskId}`;
+    const now = Date.now();
+    const lastTime = this.lastNotifyTimestamps.get(key);
+    if (lastTime && now - lastTime < throttleMs) {
+      logger2.debug(`[throttle] Skipping OPERATION_CREATED notify for task #${operation.taskId}, last notified ${now - lastTime}ms ago`);
+      return true;
+    }
+    this.lastNotifyTimestamps.set(key, now);
+    return false;
+  }
+  formatOperationCreated(operation) {
+    const lines = [];
+    if (operation.taskId !== undefined && operation.taskId !== null) {
+      lines.push(`- **任务 ID**: #${operation.taskId}`);
+    }
+    if (operation.actionType) {
+      lines.push(`- **操作类型**: ${operation.actionType}`);
+    }
+    if (operation.actionTitle) {
+      lines.push(`- **标题**: ${operation.actionTitle}`);
+    }
+    if (operation.actionDescription) {
+      const desc = String(operation.actionDescription);
+      const truncated = desc.substring(0, 200) + (desc.length > 200 ? "..." : "");
+      lines.push(`- **描述**: ${truncated}`);
+    }
+    if (operation.sessionId) {
+      lines.push(`- **Session**: \`${operation.sessionId}\``);
+    }
+    return lines.join(`
 `);
   }
 }

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

@@ -1,7 +1,7 @@
 import {
   TaskTagPlugin,
   createLarkCliTaskNotifyHook
-} from "./roy-agent-core-6s3vec2y.js";
+} from "./roy-agent-core-qqhbxq56.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-qxhq8ven.js";
@@ -19,6 +19,9 @@ import {
   createEnvContext,
   runWithEnvContext
 } from "./roy-agent-core-y5d04fm3.js";
+import {
+  TracedAs
+} from "./roy-agent-core-k05v31rc.js";
 import {
   createLogger,
   init_logger
@@ -27,6 +30,7 @@ import {
   getTracerProvider
 } from "./roy-agent-core-7z9b1fm8.js";
 import {
+  __legacyDecorateClassTS,
   __require
 } from "./roy-agent-core-fs0mn2jk.js";
 
@@ -223,7 +227,11 @@ class LarkCliInstance {
       return [plugin.hookPoint];
     }
     if (plugin.name && typeof plugin.execute === "function") {
-      return ["task:after.create", "task:after.update"];
+      return [
+        "task:after.create",
+        "task:after.update",
+        "task:operation:after.create"
+      ];
     }
     return [];
   }
@@ -510,6 +518,15 @@ class LarkCliInstance {
     });
   }
 }
+__legacyDecorateClassTS([
+  TracedAs("lark-cli.loadPlugins", { recordParams: true, log: true })
+], LarkCliInstance.prototype, "loadPlugins", null);
+__legacyDecorateClassTS([
+  TracedAs("lark-cli.registerPluginHooks", { recordParams: true, log: true })
+], LarkCliInstance.prototype, "registerPluginHooks", null);
+__legacyDecorateClassTS([
+  TracedAs("lark-cli.handleEvent", { recordParams: true, log: true })
+], LarkCliInstance.prototype, "handleEvent", null);
 var larkCliHandler = {
   type: "lark-cli",
   validateConfig(config) {

package/dist/shared/@ai-setting/{roy-agent-core-5c2mfq1q.js → roy-agent-core-t3367jkk.js}

@@ -98,6 +98,8 @@ class BaseEnvironment extends BaseComponent {
           envEvent: context || { type: "workflow" },
           sourceId: "workflow",
           userId: context?.metadata?.userId || "",
+          replyChannel: existingCtx?.replyChannel,
+          pluginEnabled: existingCtx?.pluginEnabled,
           agentContext: existingCtx?.agentContext ?? {}
         };
         return await runWithEnvContextAsync(workflowEnvContext, async () => {