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

package/dist/env/index.js

@@ -43,17 +43,17 @@ import"../shared/@ai-setting/roy-agent-core-nd3amf4x.js";
 import"../shared/@ai-setting/roy-agent-core-e25xkv53.js";
 import {
   TaskComponent
-} from "../shared/@ai-setting/roy-agent-core-1pfxbpp2.js";
+} from "../shared/@ai-setting/roy-agent-core-wqzkxab9.js";
 import"../shared/@ai-setting/roy-agent-core-8gxth0eh.js";
 import"../shared/@ai-setting/roy-agent-core-dkevkmas.js";
-import"../shared/@ai-setting/roy-agent-core-w4f871e2.js";
+import"../shared/@ai-setting/roy-agent-core-cgq7btak.js";
 import"../shared/@ai-setting/roy-agent-core-nx3c3ce2.js";
 import {
   XDG_PATHS,
   getXDGPath,
   getXDGPaths
 } from "../shared/@ai-setting/roy-agent-core-qxnbvgwe.js";
-import"../shared/@ai-setting/roy-agent-core-e1704378.js";
+import"../shared/@ai-setting/roy-agent-core-3s9va046.js";
 import"../shared/@ai-setting/roy-agent-core-t94ktchq.js";
 import"../shared/@ai-setting/roy-agent-core-92z6t4he.js";
 import {

package/dist/env/prompt/index.js

@@ -3,7 +3,7 @@ import {
   PromptConfigSchema,
   PromptPathSchema,
   PromptRenderer
-} from "../../shared/@ai-setting/roy-agent-core-q16bh5e9.js";
+} from "../../shared/@ai-setting/roy-agent-core-8am1xdvb.js";
 import"../../shared/@ai-setting/roy-agent-core-qxnbvgwe.js";
 import"../../shared/@ai-setting/roy-agent-core-qxhq8ven.js";
 import"../../shared/@ai-setting/roy-agent-core-rgckng3p.js";

package/dist/env/task/index.js

@@ -5,7 +5,7 @@ import {
   TaskPriorityEnum,
   TaskStatusEnum,
   TaskTypeEnum
-} from "../../shared/@ai-setting/roy-agent-core-1pfxbpp2.js";
+} from "../../shared/@ai-setting/roy-agent-core-wqzkxab9.js";
 import {
   TaskEntityEventTypes
 } from "../../shared/@ai-setting/roy-agent-core-8gxth0eh.js";
@@ -13,10 +13,10 @@ import"../../shared/@ai-setting/roy-agent-core-dkevkmas.js";
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath
-} from "../../shared/@ai-setting/roy-agent-core-w4f871e2.js";
+} from "../../shared/@ai-setting/roy-agent-core-cgq7btak.js";
 import"../../shared/@ai-setting/roy-agent-core-nx3c3ce2.js";
 import"../../shared/@ai-setting/roy-agent-core-qxnbvgwe.js";
-import"../../shared/@ai-setting/roy-agent-core-e1704378.js";
+import"../../shared/@ai-setting/roy-agent-core-3s9va046.js";
 import"../../shared/@ai-setting/roy-agent-core-t94ktchq.js";
 import"../../shared/@ai-setting/roy-agent-core-92z6t4he.js";
 import"../../shared/@ai-setting/roy-agent-core-qxhq8ven.js";

package/dist/env/task/storage/index.js

@@ -2,7 +2,7 @@ import {
   SQLiteTaskStore,
   getDefaultDataDir,
   getDefaultTaskDbPath
-} from "../../../shared/@ai-setting/roy-agent-core-w4f871e2.js";
+} from "../../../shared/@ai-setting/roy-agent-core-cgq7btak.js";
 import"../../../shared/@ai-setting/roy-agent-core-shme7set.js";
 import"../../../shared/@ai-setting/roy-agent-core-7z9b1fm8.js";
 import"../../../shared/@ai-setting/roy-agent-core-c6592r3c.js";

package/dist/env/task/tools/index.js

@@ -1,11 +1,14 @@
 import {
+  batchArchiveTaskTool,
+  batchDeleteTaskTool,
   completeTaskTool,
   createTaskTool,
   deleteTaskTool,
   getTaskTool,
   listTasksTool,
+  searchTasksTool,
   updateTaskTool
-} from "../../../shared/@ai-setting/roy-agent-core-e1704378.js";
+} from "../../../shared/@ai-setting/roy-agent-core-3s9va046.js";
 import"../../../shared/@ai-setting/roy-agent-core-y5d04fm3.js";
 import"../../../shared/@ai-setting/roy-agent-core-k05v31rc.js";
 import"../../../shared/@ai-setting/roy-agent-core-shme7set.js";
@@ -14,9 +17,12 @@ import"../../../shared/@ai-setting/roy-agent-core-c6592r3c.js";
 import"../../../shared/@ai-setting/roy-agent-core-fs0mn2jk.js";
 export {
   updateTaskTool,
+  searchTasksTool,
   listTasksTool,
   getTaskTool,
   deleteTaskTool,
   createTaskTool,
-  completeTaskTool
+  completeTaskTool,
+  batchDeleteTaskTool,
+  batchArchiveTaskTool
 };

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   PromptStore,
   getBuiltInPrompt,
   getBuiltInPromptNames
-} from "./shared/@ai-setting/roy-agent-core-q16bh5e9.js";
+} from "./shared/@ai-setting/roy-agent-core-8am1xdvb.js";
 import {
   LLMComponent,
   LLMConfigSchema,
@@ -127,13 +127,13 @@ import {
 } from "./shared/@ai-setting/roy-agent-core-e25xkv53.js";
 import {
   TaskComponent
-} from "./shared/@ai-setting/roy-agent-core-1pfxbpp2.js";
+} from "./shared/@ai-setting/roy-agent-core-wqzkxab9.js";
 import"./shared/@ai-setting/roy-agent-core-8gxth0eh.js";
 import"./shared/@ai-setting/roy-agent-core-dkevkmas.js";
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath
-} from "./shared/@ai-setting/roy-agent-core-w4f871e2.js";
+} from "./shared/@ai-setting/roy-agent-core-cgq7btak.js";
 import {
   AgentRegistry
 } from "./shared/@ai-setting/roy-agent-core-nx3c3ce2.js";
@@ -142,7 +142,7 @@ import {
   getXDGPath,
   getXDGPaths
 } from "./shared/@ai-setting/roy-agent-core-qxnbvgwe.js";
-import"./shared/@ai-setting/roy-agent-core-e1704378.js";
+import"./shared/@ai-setting/roy-agent-core-3s9va046.js";
 import"./shared/@ai-setting/roy-agent-core-t94ktchq.js";
 import {
   TaskHookPoints

package/dist/shared/@ai-setting/{roy-agent-core-e1704378.js → roy-agent-core-3s9va046.js}

@@ -18,6 +18,7 @@ var CreateTaskToolSchema = z.object({
   due_date: z.string().optional().describe("Due date (ISO format)"),
   tags: z.array(z.string()).optional().describe("Task tags (for search, stored in task.tags JSON field)"),
   project_path: z.string().describe("Project root path for task positioning. " + "Used to locate the project space for this task. " + "Use 'unknown' if unknown."),
+  parent_task_id: z.number().optional().describe("父任务 ID（可选，用于构建任务树）"),
   context: z.string().describe("JSON string with time-space positioning information for task continuity. " + "This field is crucial for Agent task handoff. " + "Core fields: worktree_path (git worktree path), branch (current branch), type (feature/bug/refactor/chore). " + 'Example for coding: {"worktree_path": "/path/worktree", "branch": "feature/xyz", "type": "feature"}. ' + 'Example for other: {"type": "general"}. ' + `If unknown, use '{}' or '{"type":"unknown"}'. ` + "IMPORTANT: Must be a valid JSON string!")
 });
 var GetTaskToolSchema = z.object({
@@ -25,17 +26,30 @@ var GetTaskToolSchema = z.object({
   include_operations: z.boolean().optional().default(false).describe("Include operation records")
 });
 var ListTasksToolSchema = z.object({
-  status: z.enum(["todo", "active", "completed", "paused", "cancelled"]).optional(),
+  status: z.enum(["todo", "active", "completed", "paused", "cancelled", "archived"]).optional(),
   priority: z.enum(["low", "medium", "high"]).optional(),
   type: z.enum(["normal", "cycle", "longterm"]).optional().describe("Filter by task type"),
   limit: z.number().optional().default(20),
-  offset: z.number().optional().default(0)
+  offset: z.number().optional().default(0),
+  depth: z.number().optional().describe("检索层级深度：0=只根任务（无父任务），1=根+一层子任务，2=根+二层子任务，-1 或忽略=全部"),
+  include_archived: z.boolean().optional().default(false).describe("是否包含已归档任务（status=archived 的任务默认被排除）")
+});
+var SearchTasksToolSchema = z.object({
+  keywords: z.array(z.string()).describe("关键词列表（AND 逻辑，匹配 title/description/goals/tags/operations）"),
+  limit: z.number().optional().default(20).describe("返回数量"),
+  offset: z.number().optional().default(0).describe("偏移量"),
+  status: z.enum(["todo", "active", "completed", "paused", "cancelled", "archived"]).optional().describe("按状态筛选"),
+  priority: z.enum(["low", "medium", "high"]).optional().describe("按优先级筛选"),
+  type: z.enum(["normal", "cycle", "longterm"]).optional().describe("按类型筛选"),
+  exclude_task_id: z.number().optional().describe("排除的 task ID"),
+  depth: z.number().optional().describe("检索层级深度：0=只根任务，1=根+一层子任务，2=根+二层子任务，-1 或忽略=全部"),
+  include_archived: z.boolean().optional().default(false).describe("是否包含已归档任务（status=archived 的任务默认被排除）")
 });
 var UpdateTaskToolSchema = z.object({
   task_id: z.number().describe("Task ID"),
   title: z.string().optional(),
   description: z.string().optional(),
-  status: z.enum(["todo", "active", "completed", "paused", "cancelled"]).optional(),
+  status: z.enum(["todo", "active", "completed", "paused", "cancelled", "archived"]).optional(),
   priority: z.enum(["low", "medium", "high"]).optional(),
   type: z.enum(["normal", "cycle", "longterm"]).optional().describe("Task type"),
   progress: z.number().min(0).max(100).optional(),
@@ -49,6 +63,13 @@ var UpdateTaskToolSchema = z.object({
 var DeleteTaskToolSchema = z.object({
   task_id: z.number().describe("Task ID")
 });
+var BatchArchiveToolSchema = z.object({
+  task_ids: z.array(z.number()).describe("要归档的任务 ID 列表"),
+  reason: z.string().optional().describe("归档原因（可选，会写入每个任务的 operation 记录）")
+});
+var BatchDeleteToolSchema = z.object({
+  task_ids: z.array(z.number()).describe("要删除的任务 ID 列表")
+});
 
 // src/env/task/tools/create-tool.ts
 init_env_context();
@@ -100,6 +121,7 @@ function createTaskTool(taskComponent) {
       const sessionId = ctx.session_id || "unknown";
       try {
         const task = await taskComponent.createTask({
+          parent_task_id: params.parent_task_id,
           title: params.title,
           description: params.description,
           priority: params.priority,
@@ -189,21 +211,31 @@ function getTaskTool(taskComponent) {
 function listTasksTool(taskComponent) {
   return {
     name: "task_list",
-    description: "List tasks with optional filters for status, priority, and type.",
+    description: "List tasks with optional filters for status, priority, type, parent_task_id, " + "and depth (hierarchy level). " + `depth: 0=只根任务（无父任务），1=根+一层子任务，2=根+二层子任务，-1 或忽略=全部。
+` + "Returns { tasks, total, limit, offset } where total is the count of all " + "matching tasks BEFORE pagination.",
     parameters: ListTasksToolSchema,
     execute: async (args, ctx) => {
       const params = ListTasksToolSchema.parse(args);
       try {
-        const tasks = await taskComponent.listTasks({
+        const result = await taskComponent.listTasks({
           status: params.status,
           priority: params.priority,
           type: params.type,
           limit: params.limit,
-          offset: params.offset
+          offset: params.offset,
+          depth: params.depth,
+          include_archived: params.include_archived
         });
         return {
           success: true,
-          output: JSON.stringify({ tasks, count: tasks.length }),
+          output: JSON.stringify({
+            tasks: result.tasks,
+            total: result.total,
+            count: result.tasks.length,
+            limit: params.limit,
+            offset: params.offset,
+            depth: params.depth
+          }),
           metadata: { execution_time_ms: 0 }
         };
       } catch (error) {
@@ -217,6 +249,164 @@ function listTasksTool(taskComponent) {
     }
   };
 }
+// src/env/task/tools/search-tool.ts
+function searchTasksTool(taskComponent) {
+  return {
+    name: "task_search",
+    description: "Search tasks by keywords across title, description, goals, tags, and " + "operation records. Use this when you need to find tasks related to a " + "topic, feature, bug, or area of work — even when the keyword is only " + `in description / goals / tags / past operation logs.
+
+` + `Returns { tasks, total, limit, offset } so you can paginate large result sets.
+
+` + "If `keywords` is empty, returns no results.",
+    parameters: SearchTasksToolSchema,
+    execute: async (args, ctx) => {
+      const params = SearchTasksToolSchema.parse(args);
+      try {
+        const result = await taskComponent.searchTasksByKeywords(params.keywords, {
+          limit: params.limit,
+          offset: params.offset,
+          excludeTaskId: params.exclude_task_id,
+          status: params.status,
+          priority: params.priority,
+          type: params.type,
+          depth: params.depth,
+          include_archived: params.include_archived
+        });
+        return {
+          success: true,
+          output: JSON.stringify({
+            tasks: result.tasks,
+            total: result.total,
+            limit: params.limit,
+            offset: params.offset
+          }),
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+// src/env/task/tools/batch-archive-tool.ts
+function batchArchiveTaskTool(taskComponent) {
+  return {
+    name: "task_batch_archive",
+    description: "Batch archive multiple tasks at once. Sets all specified tasks to " + `'archived' status and creates operation records for each.
+
+` + "Use this when you need to quickly archive a group of completed, " + `obsolete, or historical tasks (e.g., during task organization).
+
+` + "Returns summary of how many tasks were successfully archived " + "and any errors encountered.",
+    parameters: BatchArchiveToolSchema,
+    execute: async (args, ctx) => {
+      const params = BatchArchiveToolSchema.parse(args);
+      const taskIds = params.task_ids;
+      const sessionId = ctx.session_id || "batch-archive";
+      if (!taskIds || taskIds.length === 0) {
+        return {
+          success: true,
+          output: JSON.stringify({ archived_count: 0, errors: [] }),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+      const results = [];
+      let archivedCount = 0;
+      for (const taskId of taskIds) {
+        try {
+          const task = await taskComponent.updateTask(taskId, { status: "archived" });
+          if (task) {
+            await taskComponent.createOperation({
+              taskId,
+              sessionId,
+              actionType: "completed",
+              actionTitle: "Batch archived",
+              actionDescription: params.reason || "批量归档（任务整理）"
+            });
+            archivedCount++;
+            results.push({ id: taskId, success: true });
+          } else {
+            results.push({ id: taskId, success: false, error: "Task not found" });
+          }
+        } catch (error) {
+          results.push({
+            id: taskId,
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+      const hasErrors = results.some((r) => !r.success);
+      return {
+        success: !hasErrors,
+        output: JSON.stringify({
+          archived_count: archivedCount,
+          total: taskIds.length,
+          errors: results.filter((r) => !r.success).map((r) => ({ id: r.id, error: r.error })),
+          results
+        }, null, 2),
+        metadata: { execution_time_ms: 0 }
+      };
+    }
+  };
+}
+// src/env/task/tools/batch-delete-tool.ts
+function batchDeleteTaskTool(taskComponent) {
+  return {
+    name: "task_batch_delete",
+    description: "Batch delete multiple tasks at once. Deletes each task and all its " + `operation records.
+
+` + "Use this when you need to quickly remove a group of test, temporary, " + `or otherwise worthless tasks (e.g., during task organization).
+
+` + "Returns summary of how many tasks were successfully deleted " + "and any errors encountered.",
+    parameters: BatchDeleteToolSchema,
+    execute: async (args, ctx) => {
+      const params = BatchDeleteToolSchema.parse(args);
+      const taskIds = params.task_ids;
+      if (!taskIds || taskIds.length === 0) {
+        return {
+          success: true,
+          output: JSON.stringify({ deleted_count: 0, errors: [] }),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+      const results = [];
+      let deletedCount = 0;
+      for (const taskId of taskIds) {
+        try {
+          const deleted = await taskComponent.deleteTask(taskId);
+          if (deleted) {
+            deletedCount++;
+            results.push({ id: taskId, success: true });
+          } else {
+            results.push({ id: taskId, success: false, error: "Task not found" });
+          }
+        } catch (error) {
+          results.push({
+            id: taskId,
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+      const hasErrors = results.some((r) => !r.success);
+      return {
+        success: !hasErrors,
+        output: JSON.stringify({
+          deleted_count: deletedCount,
+          total: taskIds.length,
+          errors: results.filter((r) => !r.success).map((r) => ({ id: r.id, error: r.error })),
+          results
+        }, null, 2),
+        metadata: { execution_time_ms: 0 }
+      };
+    }
+  };
+}
 // src/env/task/tools/update-tool.ts
 init_env_context();
 init_logger();
@@ -374,4 +564,4 @@ function completeTaskTool(taskComponent) {
     }
   };
 }
-export { createTaskTool, getTaskTool, listTasksTool, updateTaskTool, deleteTaskTool, completeTaskTool };
+export { createTaskTool, getTaskTool, listTasksTool, searchTasksTool, batchArchiveTaskTool, batchDeleteTaskTool, updateTaskTool, deleteTaskTool, completeTaskTool };

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

@@ -105,16 +105,30 @@ var builtInPrompts = {
 
 ## 你的工具
 
-你有两个工具可用：
+你有一组任务查询工具和两个执行工具可用：
 
-| 工具 | 描述 |
-|------|------|
-| \`delegate_task\` | 委托复杂/多步骤任务给子智能体执行 |
-| \`bash\` | **仅**用于执行一行简单的 Roy Agent 命令或一次性操作 |
+| 工具 | 类别 | 描述 |
+|------|------|------|
+| \`task_search\` | **查询** | 关键词搜索任务（匹配 title/description/goals/tags/operations），带分页和 relevance 排序 |
+| \`task_get\` | **查询** | 获取单个任务详情（含 operations） |
+| \`task_list\` | **查询** | 按 status/priority/type/depth 列出任务，支持分页 |
+| \`task_operation_list\` | **查询** | 查看任务的操作记录 |
+| \`delegate_task\` | **执行** | 委托复杂/多步骤任务给子智能体执行 |
+| \`bash\` | **执行** | 仅用于执行一行简单的 shell 命令 |
 
-### 工具使用规则
+### 查询工具（可直接使用）
 
-**\`delegate_task\`** — 这是你的**主要工具**。用于一切复杂、多步骤、需要读文件、运行命令、代码分析、搜索、实现功能等场景。**当不确定用哪个时，选 \`delegate_task\`。**
+以下任务查询工具 **不需要委托**，可以直接调用：
+- \`task_search(keywords=["关键词"], limit=10)\` — 搜索相关任务
+- \`task_get(task_id=123)\` — 查看任务详情
+- \`task_list(status="active")\` — 列出任务
+- \`task_operation_list(task_id=123)\` — 查看操作记录
+
+> ✅ 用户询问任务状态、搜索已有任务、查看任务详情时，**直接使用查询工具**，无需委托。
+
+### 执行工具使用规则
+
+**\`delegate_task\`** — 这是你的**主要执行工具**。用于一切复杂、多步骤、需要读文件、运行命令、代码分析、搜索、实现功能等场景。**当不确定用哪个时，选 \`delegate_task\`。**
 
 **\`bash\`** — **仅限**以下**一次性简单操作**：
 - 调用一行 \`roy-agent\` 命令（如 \`bun packages/cli/dist/bin/roy-agent.js tasks list\`）

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-1pfxbpp2.js → roy-agent-core-wqzkxab9.js}

@@ -9,15 +9,18 @@ import {
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath
-} from "./roy-agent-core-w4f871e2.js";
+} from "./roy-agent-core-cgq7btak.js";
 import {
+  batchArchiveTaskTool,
+  batchDeleteTaskTool,
   completeTaskTool,
   createTaskTool,
   deleteTaskTool,
   getTaskTool,
   listTasksTool,
+  searchTasksTool,
   updateTaskTool
-} from "./roy-agent-core-e1704378.js";
+} from "./roy-agent-core-3s9va046.js";
 import {
   createOperationTool,
   deleteOperationTool,
@@ -320,6 +323,9 @@ class TaskComponent extends BaseComponent {
       createTaskTool(this),
       getTaskTool(this),
       listTasksTool(this),
+      searchTasksTool(this),
+      batchArchiveTaskTool(this),
+      batchDeleteTaskTool(this),
       updateTaskTool(this),
       deleteTaskTool(this),
       completeTaskTool(this)
@@ -421,6 +427,15 @@ class TaskComponent extends BaseComponent {
   async listTasks(options) {
     return this.store.listTasks(options);
   }
+  async searchTasksByKeywords(keywords, options) {
+    return this.store.searchTasksByKeywords(keywords, options || {});
+  }
+  async getTaskTree(taskId, depth = -1) {
+    return this.store.getTaskTree(taskId, depth);
+  }
+  async getChildTasks(taskId, options) {
+    return this.store.getChildTasks(taskId, options);
+  }
   async completeTask(id, sessionId) {
     const existing = await this.store.getTask(id);
     if (existing && existing.type === "cycle") {
@@ -514,7 +529,7 @@ __legacyDecorateClassTS([
 ], TaskComponent.prototype, "createOperation", null);
 // src/env/task/types.ts
 import { z } from "zod";
-var TaskStatusEnum = z.enum(["todo", "active", "completed", "paused", "cancelled"]);
+var TaskStatusEnum = z.enum(["todo", "active", "completed", "paused", "cancelled", "archived"]);
 var TaskPriorityEnum = z.enum(["low", "medium", "high"]);
 var TaskTypeEnum = z.enum(["normal", "cycle", "longterm"]);
 var ActionTypeEnum = z.enum([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.5.59",
+  "version": "1.5.60",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",