@ai-setting/roy-agent-cli 1.3.14 → 1.3.16

package/dist/core/src/env/task/tools/operation/get-tool.js

@@ -0,0 +1,39 @@
+/**
+ * @fileoverview Operation Get Tool
+ */
+import { GetOperationToolSchema } from "./operation-types.js";
+export function getOperationTool(taskComponent) {
+    return {
+        name: "task_operation_get",
+        description: "Get a single operation record by ID.",
+        parameters: GetOperationToolSchema,
+        execute: async (args, ctx) => {
+            const params = GetOperationToolSchema.parse(args);
+            try {
+                const operation = await taskComponent.getOperation(params.operation_id);
+                if (!operation) {
+                    return {
+                        success: false,
+                        output: "",
+                        error: `Operation not found: ${params.operation_id}`,
+                        metadata: { execution_time_ms: 0 },
+                    };
+                }
+                return {
+                    success: true,
+                    output: JSON.stringify(operation, null, 2),
+                    metadata: { execution_time_ms: 0 },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    output: "",
+                    error: error instanceof Error ? error.message : String(error),
+                    metadata: { execution_time_ms: 0 },
+                };
+            }
+        },
+    };
+}
+//# sourceMappingURL=get-tool.js.map

package/dist/core/src/env/task/tools/operation/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Operation Tools Index
+ */
+export { createOperationTool } from "./create-tool";
+export { getOperationTool } from "./get-tool";
+export { listOperationsTool } from "./list-tool";
+export { updateOperationTool } from "./update-tool";
+export { deleteOperationTool } from "./delete-tool";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/src/env/task/tools/operation/index.js

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Operation Tools Index
+ */
+export { createOperationTool } from "./create-tool.js";
+export { getOperationTool } from "./get-tool.js";
+export { listOperationsTool } from "./list-tool.js";
+export { updateOperationTool } from "./update-tool.js";
+export { deleteOperationTool } from "./delete-tool.js";
+//# sourceMappingURL=index.js.map

package/dist/core/src/env/task/tools/operation/list-tool.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Operation List Tool
+ */
+import type { Tool } from "../../../tool/types";
+import type { TaskComponent } from "../../task-component";
+export declare function listOperationsTool(taskComponent: TaskComponent): Tool;
+//# sourceMappingURL=list-tool.d.ts.map

package/dist/core/src/env/task/tools/operation/list-tool.js

@@ -0,0 +1,36 @@
+/**
+ * @fileoverview Operation List Tool
+ */
+import { ListOperationsToolSchema } from "./operation-types.js";
+export function listOperationsTool(taskComponent) {
+    return {
+        name: "task_operation_list",
+        description: "List operation records for a task with optional filters.",
+        parameters: ListOperationsToolSchema,
+        execute: async (args, ctx) => {
+            const params = ListOperationsToolSchema.parse(args);
+            try {
+                const operations = await taskComponent.listOperations({
+                    taskId: params.task_id,
+                    actionType: params.action_type,
+                    limit: params.limit,
+                    offset: params.offset,
+                });
+                return {
+                    success: true,
+                    output: JSON.stringify({ operations, count: operations.length }),
+                    metadata: { execution_time_ms: 0 },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    output: "",
+                    error: error instanceof Error ? error.message : String(error),
+                    metadata: { execution_time_ms: 0 },
+                };
+            }
+        },
+    };
+}
+//# sourceMappingURL=list-tool.js.map

package/dist/core/src/env/task/tools/operation/operation-tools.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Operation Tools Tests
+ */
+export {};
+//# sourceMappingURL=operation-tools.test.d.ts.map

package/dist/core/src/env/task/tools/operation/operation-tools.test.js

@@ -0,0 +1,159 @@
+/**
+ * @fileoverview Operation Tools Tests
+ */
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { TaskComponent } from "../../task-component.js";
+import { ConfigComponent } from "../../../../config/config-component.js";
+import { tmpdir } from "os";
+import { join } from "path";
+import { createTaskTool } from "../create-tool.js";
+import { createOperationTool, getOperationTool, listOperationsTool, updateOperationTool, deleteOperationTool } from "./index.js";
+describe("Operation Tools", () => {
+    let taskComponent;
+    let taskId;
+    beforeEach(async () => {
+        const configComponent = new ConfigComponent();
+        taskComponent = new TaskComponent();
+        await taskComponent.init({
+            options: {
+                configComponent,
+                config: {
+                    storage: {
+                        type: "sqlite",
+                        dbPath: join(tmpdir(), `operation-tools-test-${Date.now()}.db`),
+                    },
+                },
+            },
+        });
+        // Create a task for testing operations
+        const createTool = createTaskTool(taskComponent);
+        const result = await createTool.execute({ title: "Test Task" }, { session_id: "sess_123" });
+        taskId = result.metadata?.task_id;
+    });
+    afterEach(async () => {
+        await taskComponent.stop();
+    });
+    describe("task_operation_create", () => {
+        it("should create an operation record", async () => {
+            const tool = createOperationTool(taskComponent);
+            const result = await tool.execute({
+                task_id: taskId,
+                action_type: "progress",
+                action_title: "Made progress",
+                action_description: "Completed feature X",
+            }, { session_id: "sess_456" });
+            expect(result.success).toBe(true);
+            expect(result.output).toContain("Operation created");
+            expect(result.metadata?.operation_id).toBeGreaterThan(0);
+            expect(result.metadata?.session_id).toBe("sess_456");
+        });
+        it("should track sessionId from context", async () => {
+            const tool = createOperationTool(taskComponent);
+            const result = await tool.execute({
+                task_id: taskId,
+                action_type: "milestone",
+                action_title: "Reached milestone",
+            }, { session_id: "sess_789" });
+            expect(result.success).toBe(true);
+            expect(result.metadata?.session_id).toBe("sess_789");
+        });
+    });
+    describe("task_operation_get", () => {
+        it("should get operation by id", async () => {
+            // Create an operation first
+            const createTool = createOperationTool(taskComponent);
+            const createResult = await createTool.execute({ task_id: taskId, action_type: "progress", action_title: "Test" }, { session_id: "sess_123" });
+            const opId = createResult.metadata?.operation_id;
+            // Get it
+            const tool = getOperationTool(taskComponent);
+            const result = await tool.execute({ operation_id: opId }, { session_id: "sess_123" });
+            expect(result.success).toBe(true);
+            const op = JSON.parse(result.output);
+            expect(op.actionType).toBe("progress");
+            expect(op.sessionId).toBe("sess_123");
+        });
+        it("should return error for non-existent operation", async () => {
+            const tool = getOperationTool(taskComponent);
+            const result = await tool.execute({ operation_id: 99999 }, { session_id: "sess_123" });
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("not found");
+        });
+    });
+    describe("task_operation_list", () => {
+        it("should list operations for a task", async () => {
+            // Create multiple operations
+            const createTool = createOperationTool(taskComponent);
+            await createTool.execute({ task_id: taskId, action_type: "create", action_title: "Created" }, { session_id: "sess_1" });
+            await createTool.execute({ task_id: taskId, action_type: "progress", action_title: "Progress 1" }, { session_id: "sess_2" });
+            await createTool.execute({ task_id: taskId, action_type: "progress", action_title: "Progress 2" }, { session_id: "sess_3" });
+            // List them
+            const tool = listOperationsTool(taskComponent);
+            const result = await tool.execute({ task_id: taskId }, { session_id: "sess_123" });
+            expect(result.success).toBe(true);
+            const data = JSON.parse(result.output);
+            expect(data.count).toBeGreaterThanOrEqual(3);
+        });
+        it("should filter by action_type", async () => {
+            const createTool = createOperationTool(taskComponent);
+            await createTool.execute({ task_id: taskId, action_type: "progress", action_title: "P1" }, { session_id: "sess_1" });
+            await createTool.execute({ task_id: taskId, action_type: "milestone", action_title: "M1" }, { session_id: "sess_2" });
+            await createTool.execute({ task_id: taskId, action_type: "progress", action_title: "P2" }, { session_id: "sess_3" });
+            const tool = listOperationsTool(taskComponent);
+            const result = await tool.execute({ task_id: taskId, action_type: "progress" }, { session_id: "sess_123" });
+            expect(result.success).toBe(true);
+            const data = JSON.parse(result.output);
+            expect(data.operations.every((op) => op.actionType === "progress")).toBe(true);
+        });
+    });
+    describe("task_operation_update", () => {
+        it("should update operation", async () => {
+            // Create an operation
+            const createTool = createOperationTool(taskComponent);
+            const createResult = await createTool.execute({ task_id: taskId, action_type: "progress", action_title: "Original" }, { session_id: "sess_123" });
+            const opId = createResult.metadata?.operation_id;
+            // Update it
+            const tool = updateOperationTool(taskComponent);
+            const result = await tool.execute({ operation_id: opId, action_title: "Updated", action_description: "New description" }, { session_id: "sess_123" });
+            expect(result.success).toBe(true);
+            // Verify
+            const getTool = getOperationTool(taskComponent);
+            const getResult = await getTool.execute({ operation_id: opId }, { session_id: "sess_123" });
+            const op = JSON.parse(getResult.output);
+            expect(op.actionTitle).toBe("Updated");
+            expect(op.actionDescription).toBe("New description");
+        });
+    });
+    describe("task_operation_delete", () => {
+        it("should delete operation", async () => {
+            // Create an operation
+            const createTool = createOperationTool(taskComponent);
+            const createResult = await createTool.execute({ task_id: taskId, action_type: "progress", action_title: "Delete me" }, { session_id: "sess_123" });
+            const opId = createResult.metadata?.operation_id;
+            // Delete it
+            const tool = deleteOperationTool(taskComponent);
+            const result = await tool.execute({ operation_id: opId }, { session_id: "sess_123" });
+            expect(result.success).toBe(true);
+            // Verify it's gone
+            const getTool = getOperationTool(taskComponent);
+            const getResult = await getTool.execute({ operation_id: opId }, { session_id: "sess_123" });
+            expect(getResult.success).toBe(false);
+        });
+    });
+    describe("cross-session tracking", () => {
+        it("should track operations from multiple sessions", async () => {
+            const createTool = createOperationTool(taskComponent);
+            await createTool.execute({ task_id: taskId, action_type: "create", action_title: "Session 1" }, { session_id: "sess_alpha" });
+            await createTool.execute({ task_id: taskId, action_type: "progress", action_title: "Session 2" }, { session_id: "sess_beta" });
+            await createTool.execute({ task_id: taskId, action_type: "milestone", action_title: "Session 3" }, { session_id: "sess_gamma" });
+            // List and check sessions
+            const tool = listOperationsTool(taskComponent);
+            const result = await tool.execute({ task_id: taskId }, { session_id: "sess_123" });
+            const data = JSON.parse(result.output);
+            const sessions = new Set(data.operations.map((op) => op.sessionId));
+            expect(sessions.has("sess_alpha")).toBe(true);
+            expect(sessions.has("sess_beta")).toBe(true);
+            expect(sessions.has("sess_gamma")).toBe(true);
+        });
+    });
+});
+//# sourceMappingURL=operation-tools.test.js.map

package/dist/core/src/env/task/tools/operation/operation-types.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview Operation Tool Parameter Schemas
+ */
+import { z } from "zod";
+/**
+ * Action type enum
+ */
+declare const ActionTypeEnum: z.ZodEnum<["create", "progress", "milestone", "problem", "solution", "decision", "review", "completed"]>;
+export { ActionTypeEnum };
+/**
+ * task_operation_create tool parameters
+ */
+export declare const CreateOperationToolSchema: z.ZodObject<{
+    task_id: z.ZodNumber;
+    action_type: z.ZodEnum<["create", "progress", "milestone", "problem", "solution", "decision", "review", "completed"]>;
+    action_title: z.ZodString;
+    action_description: z.ZodOptional<z.ZodString>;
+    md_path: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    task_id?: number;
+    action_type?: "completed" | "progress" | "create" | "review" | "milestone" | "problem" | "solution" | "decision";
+    action_title?: string;
+    action_description?: string;
+    md_path?: string;
+}, {
+    task_id?: number;
+    action_type?: "completed" | "progress" | "create" | "review" | "milestone" | "problem" | "solution" | "decision";
+    action_title?: string;
+    action_description?: string;
+    md_path?: string;
+}>;
+export type CreateOperationToolParams = z.infer<typeof CreateOperationToolSchema>;
+/**
+ * task_operation_get tool parameters
+ */
+export declare const GetOperationToolSchema: z.ZodObject<{
+    operation_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    operation_id?: number;
+}, {
+    operation_id?: number;
+}>;
+export type GetOperationToolParams = z.infer<typeof GetOperationToolSchema>;
+/**
+ * task_operation_list tool parameters
+ */
+export declare const ListOperationsToolSchema: z.ZodObject<{
+    task_id: z.ZodNumber;
+    action_type: z.ZodOptional<z.ZodEnum<["create", "progress", "milestone", "problem", "solution", "decision", "review", "completed"]>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    offset?: number;
+    limit?: number;
+    task_id?: number;
+    action_type?: "completed" | "progress" | "create" | "review" | "milestone" | "problem" | "solution" | "decision";
+}, {
+    offset?: number;
+    limit?: number;
+    task_id?: number;
+    action_type?: "completed" | "progress" | "create" | "review" | "milestone" | "problem" | "solution" | "decision";
+}>;
+export type ListOperationsToolParams = z.infer<typeof ListOperationsToolSchema>;
+/**
+ * task_operation_update tool parameters
+ */
+export declare const UpdateOperationToolSchema: z.ZodObject<{
+    operation_id: z.ZodNumber;
+    action_title: z.ZodOptional<z.ZodString>;
+    action_description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    action_title?: string;
+    action_description?: string;
+    operation_id?: number;
+}, {
+    action_title?: string;
+    action_description?: string;
+    operation_id?: number;
+}>;
+export type UpdateOperationToolParams = z.infer<typeof UpdateOperationToolSchema>;
+/**
+ * task_operation_delete tool parameters
+ */
+export declare const DeleteOperationToolSchema: z.ZodObject<{
+    operation_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    operation_id?: number;
+}, {
+    operation_id?: number;
+}>;
+export type DeleteOperationToolParams = z.infer<typeof DeleteOperationToolSchema>;
+//# sourceMappingURL=operation-types.d.ts.map

package/dist/core/src/env/task/tools/operation/operation-types.js

@@ -0,0 +1,58 @@
+/**
+ * @fileoverview Operation Tool Parameter Schemas
+ */
+import { z } from "zod";
+/**
+ * Action type enum
+ */
+const ActionTypeEnum = z.enum([
+    "create",
+    "progress",
+    "milestone",
+    "problem",
+    "solution",
+    "decision",
+    "review",
+    "completed",
+]);
+export { ActionTypeEnum };
+/**
+ * task_operation_create tool parameters
+ */
+export const CreateOperationToolSchema = z.object({
+    task_id: z.number().describe("Task ID"),
+    action_type: ActionTypeEnum.describe("Type of action"),
+    action_title: z.string().describe("Title of the action"),
+    action_description: z.string().optional().describe("Detailed description"),
+    md_path: z.string().optional().describe("Path to detailed markdown documentation"),
+});
+/**
+ * task_operation_get tool parameters
+ */
+export const GetOperationToolSchema = z.object({
+    operation_id: z.number().describe("Operation ID"),
+});
+/**
+ * task_operation_list tool parameters
+ */
+export const ListOperationsToolSchema = z.object({
+    task_id: z.number().describe("Task ID"),
+    action_type: ActionTypeEnum.optional(),
+    limit: z.number().optional().default(20),
+    offset: z.number().optional().default(0),
+});
+/**
+ * task_operation_update tool parameters
+ */
+export const UpdateOperationToolSchema = z.object({
+    operation_id: z.number().describe("Operation ID"),
+    action_title: z.string().optional(),
+    action_description: z.string().optional(),
+});
+/**
+ * task_operation_delete tool parameters
+ */
+export const DeleteOperationToolSchema = z.object({
+    operation_id: z.number().describe("Operation ID"),
+});
+//# sourceMappingURL=operation-types.js.map

package/dist/core/src/env/task/tools/operation/update-tool.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Operation Update Tool
+ */
+import type { Tool } from "../../../tool/types";
+import type { TaskComponent } from "../../task-component";
+export declare function updateOperationTool(taskComponent: TaskComponent): Tool;
+//# sourceMappingURL=update-tool.d.ts.map

package/dist/core/src/env/task/tools/operation/update-tool.js

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview Operation Update Tool
+ */
+import { UpdateOperationToolSchema } from "./operation-types.js";
+export function updateOperationTool(taskComponent) {
+    return {
+        name: "task_operation_update",
+        description: "Update an operation record's title or description.",
+        parameters: UpdateOperationToolSchema,
+        execute: async (args, ctx) => {
+            const params = UpdateOperationToolSchema.parse(args);
+            try {
+                const operation = await taskComponent.updateOperation(params.operation_id, {
+                    actionTitle: params.action_title,
+                    actionDescription: params.action_description,
+                });
+                if (!operation) {
+                    return {
+                        success: false,
+                        output: "",
+                        error: `Operation not found: ${params.operation_id}`,
+                        metadata: { execution_time_ms: 0 },
+                    };
+                }
+                return {
+                    success: true,
+                    output: `Operation updated: #${operation.id}`,
+                    metadata: { execution_time_ms: 0, operation },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    output: "",
+                    error: error instanceof Error ? error.message : String(error),
+                    metadata: { execution_time_ms: 0 },
+                };
+            }
+        },
+    };
+}
+//# sourceMappingURL=update-tool.js.map

package/dist/core/src/env/task/tools/task-tools.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Task Tools Tests
+ */
+export {};
+//# sourceMappingURL=task-tools.test.d.ts.map

package/dist/core/src/env/task/tools/task-tools.test.js

@@ -0,0 +1,142 @@
+/**
+ * @fileoverview Task Tools Tests
+ */
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { TaskComponent } from "../task-component.js";
+import { ConfigComponent } from "../../../config/config-component.js";
+import { tmpdir } from "os";
+import { join } from "path";
+import { createTaskTool, getTaskTool, listTasksTool, updateTaskTool, deleteTaskTool, completeTaskTool } from "./index.js";
+describe("Task Tools", () => {
+    let taskComponent;
+    beforeEach(async () => {
+        const configComponent = new ConfigComponent();
+        taskComponent = new TaskComponent();
+        await taskComponent.init({
+            options: {
+                configComponent,
+                config: {
+                    storage: {
+                        type: "sqlite",
+                        dbPath: join(tmpdir(), `task-tools-test-${Date.now()}.db`),
+                    },
+                },
+            },
+        });
+    });
+    afterEach(async () => {
+        await taskComponent.stop();
+    });
+    describe("task_create", () => {
+        it("should create a task", async () => {
+            const tool = createTaskTool(taskComponent);
+            const result = await tool.execute({ title: "Test Task", description: "Test description" }, { session_id: "sess_123" });
+            expect(result.success).toBe(true);
+            expect(result.output).toContain("Test Task");
+            expect(result.metadata?.task_id).toBeGreaterThan(0);
+        });
+        it("should create task with priority", async () => {
+            const tool = createTaskTool(taskComponent);
+            const result = await tool.execute({ title: "High Priority Task", priority: "high" }, { session_id: "sess_123" });
+            expect(result.success).toBe(true);
+        });
+    });
+    describe("task_get", () => {
+        it("should get task by id", async () => {
+            // First create a task
+            const createTool = createTaskTool(taskComponent);
+            const createResult = await createTool.execute({ title: "Get Test Task" }, { session_id: "sess_123" });
+            const taskId = createResult.metadata?.task_id;
+            // Then get it
+            const getTool = getTaskTool(taskComponent);
+            const result = await getTool.execute({ task_id: taskId }, { session_id: "sess_123" });
+            expect(result.success).toBe(true);
+            const task = JSON.parse(result.output);
+            expect(task.title).toBe("Get Test Task");
+        });
+        it("should return error for non-existent task", async () => {
+            const tool = getTaskTool(taskComponent);
+            const result = await tool.execute({ task_id: 99999 }, { session_id: "sess_123" });
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("not found");
+        });
+    });
+    describe("task_list", () => {
+        it("should list tasks", async () => {
+            // Create some tasks
+            const createTool = createTaskTool(taskComponent);
+            await createTool.execute({ title: "Task 1" }, { session_id: "sess_123" });
+            await createTool.execute({ title: "Task 2" }, { session_id: "sess_123" });
+            // List them
+            const tool = listTasksTool(taskComponent);
+            const result = await tool.execute({}, { session_id: "sess_123" });
+            expect(result.success).toBe(true);
+            const data = JSON.parse(result.output);
+            expect(data.count).toBeGreaterThanOrEqual(2);
+        });
+        it("should filter by status", async () => {
+            const createTool = createTaskTool(taskComponent);
+            const createResult = await createTool.execute({ title: "Active Task" }, { session_id: "sess_123" });
+            // Update to active
+            const updateTool = updateTaskTool(taskComponent);
+            await updateTool.execute({ task_id: createResult.metadata?.task_id, status: "active" }, { session_id: "sess_123" });
+            // List only active
+            const listTool = listTasksTool(taskComponent);
+            const result = await listTool.execute({ status: "active" }, { session_id: "sess_123" });
+            expect(result.success).toBe(true);
+            const data = JSON.parse(result.output);
+            expect(data.tasks.every((t) => t.status === "active")).toBe(true);
+        });
+    });
+    describe("task_update", () => {
+        it("should update task", async () => {
+            // Create a task
+            const createTool = createTaskTool(taskComponent);
+            const createResult = await createTool.execute({ title: "Original Title" }, { session_id: "sess_123" });
+            // Update it
+            const tool = updateTaskTool(taskComponent);
+            const result = await tool.execute({
+                task_id: createResult.metadata?.task_id,
+                title: "Updated Title",
+                status: "active",
+                progress: 50,
+                current_status: "正在实现功能"
+            }, { session_id: "sess_123" });
+            expect(result.success).toBe(true);
+            expect(result.output).toContain("Updated Title");
+        });
+    });
+    describe("task_delete", () => {
+        it("should delete task", async () => {
+            // Create a task
+            const createTool = createTaskTool(taskComponent);
+            const createResult = await createTool.execute({ title: "Delete Me" }, { session_id: "sess_123" });
+            // Delete it
+            const tool = deleteTaskTool(taskComponent);
+            const result = await tool.execute({ task_id: createResult.metadata?.task_id }, { session_id: "sess_123" });
+            expect(result.success).toBe(true);
+            expect(result.output).toContain("deleted");
+            // Verify it's gone
+            const getTool = getTaskTool(taskComponent);
+            const getResult = await getTool.execute({ task_id: createResult.metadata?.task_id }, { session_id: "sess_123" });
+            expect(getResult.success).toBe(false);
+        });
+    });
+    describe("task_complete", () => {
+        it("should complete task", async () => {
+            // Create a task
+            const createTool = createTaskTool(taskComponent);
+            const createResult = await createTool.execute({ title: "Complete Me" }, { session_id: "sess_123" });
+            // Complete it
+            const tool = completeTaskTool(taskComponent);
+            const result = await tool.execute({ task_id: createResult.metadata?.task_id }, { session_id: "sess_123" });
+            expect(result.success).toBe(true);
+            expect(result.output).toContain("completed");
+            // Verify status
+            const task = result.metadata?.task;
+            expect(task.status).toBe("completed");
+            expect(task.progress).toBe(100);
+        });
+    });
+});
+//# sourceMappingURL=task-tools.test.js.map