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

package/dist/core/src/env/task/delegate/task-events.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview Task Event Types
+ *
+ * 定义任务相关的 EnvEvent 类型
+ */
+/**
+ * 任务事件类型枚举
+ */
+export declare const TaskEventTypes: {
+    /** 任务开始执行 */
+    readonly TASK_STARTED: "task.started";
+    /** 任务进度更新 */
+    readonly TASK_PROGRESS: "task.progress";
+    /** 任务完成 */
+    readonly TASK_COMPLETED: "task.completed";
+    /** 任务失败 */
+    readonly TASK_FAILED: "task.failed";
+    /** 任务超时 */
+    readonly TASK_TIMEOUT: "task.timeout";
+    /** 任务被停止 */
+    readonly TASK_STOPPED: "task.stopped";
+};
+export type TaskEventType = (typeof TaskEventTypes)[keyof typeof TaskEventTypes];
+/**
+ * 任务开始事件负载
+ */
+export interface TaskStartedPayload {
+    taskId: string;
+    subSessionId: string;
+    parentSessionId: string;
+    description: string;
+    subagentType: string;
+    associatedTaskId?: number;
+}
+/**
+ * 任务进度事件负载
+ */
+export interface TaskProgressPayload {
+    taskId: string;
+    subSessionId: string;
+    parentSessionId: string;
+    status: string;
+    progress?: number;
+    progressMessage?: string;
+    description?: string;
+    subagentType?: string;
+}
+/**
+ * 任务完成事件负载
+ */
+export interface TaskCompletedPayload {
+    taskId: string;
+    subSessionId: string;
+    parentSessionId: string;
+    status: "completed" | "failed" | "timeout" | "stopped";
+    result?: string;
+    error?: string;
+    executionTimeMs: number;
+    associatedTaskId?: number;
+    description?: string;
+    subagentType?: string;
+}
+/**
+ * 任务事件基类
+ */
+export interface BaseTaskEventPayload {
+    taskId: string;
+    subSessionId: string;
+    parentSessionId: string;
+    description: string;
+    subagentType: string;
+    associatedTaskId?: number;
+}
+import type { BackgroundTask } from "./delegate-tool";
+/**
+ * 从 BackgroundTask 创建事件负载
+ */
+export declare function createTaskStartedPayload(task: BackgroundTask, parentSessionId: string): TaskStartedPayload;
+export declare function createTaskProgressPayload(task: BackgroundTask, parentSessionId: string): TaskProgressPayload;
+export declare function createTaskCompletedPayload(task: BackgroundTask, parentSessionId: string, executionTimeMs: number): TaskCompletedPayload;
+//# sourceMappingURL=task-events.d.ts.map

package/dist/core/src/env/task/delegate/task-events.js

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview Task Event Types
+ *
+ * 定义任务相关的 EnvEvent 类型
+ */
+// ============================================================================
+// Task Event Types
+// ============================================================================
+/**
+ * 任务事件类型枚举
+ */
+export const TaskEventTypes = {
+    /** 任务开始执行 */
+    TASK_STARTED: "task.started",
+    /** 任务进度更新 */
+    TASK_PROGRESS: "task.progress",
+    /** 任务完成 */
+    TASK_COMPLETED: "task.completed",
+    /** 任务失败 */
+    TASK_FAILED: "task.failed",
+    /** 任务超时 */
+    TASK_TIMEOUT: "task.timeout",
+    /** 任务被停止 */
+    TASK_STOPPED: "task.stopped",
+};
+/**
+ * 从 BackgroundTask 创建事件负载
+ */
+export function createTaskStartedPayload(task, parentSessionId) {
+    return {
+        taskId: task.id,
+        subSessionId: task.subSessionId,
+        parentSessionId,
+        description: task.description,
+        subagentType: task.subagentType,
+        associatedTaskId: task.taskId,
+    };
+}
+export function createTaskProgressPayload(task, parentSessionId) {
+    return {
+        taskId: task.id,
+        subSessionId: task.subSessionId,
+        parentSessionId,
+        status: task.status,
+        progress: task.progress,
+        progressMessage: task.progressMessage,
+        // 添加 description 和 subagentType 以便 EventMessageFormatter 使用
+        description: task.description,
+        subagentType: task.subagentType,
+    };
+}
+export function createTaskCompletedPayload(task, parentSessionId, executionTimeMs) {
+    return {
+        taskId: task.id,
+        subSessionId: task.subSessionId,
+        parentSessionId,
+        status: task.status,
+        result: task.result,
+        error: task.error,
+        executionTimeMs,
+        associatedTaskId: task.taskId,
+        // 添加 description 和 subagentType 以便 EventMessageFormatter 使用
+        description: task.description,
+        subagentType: task.subagentType,
+    };
+}
+//# sourceMappingURL=task-events.js.map

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

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

package/dist/core/src/env/task/delegate/task-events.test.js

@@ -0,0 +1,149 @@
+/**
+ * @fileoverview Task Events Tests
+ */
+import { describe, test, expect } from "vitest";
+import { TaskEventTypes, createTaskStartedPayload, createTaskProgressPayload, createTaskCompletedPayload, } from "./task-events.js";
+describe("Task Events", () => {
+    describe("TaskEventTypes", () => {
+        test("should have all required event types", () => {
+            expect(TaskEventTypes.TASK_STARTED).toBe("task.started");
+            expect(TaskEventTypes.TASK_PROGRESS).toBe("task.progress");
+            expect(TaskEventTypes.TASK_COMPLETED).toBe("task.completed");
+            expect(TaskEventTypes.TASK_FAILED).toBe("task.failed");
+            expect(TaskEventTypes.TASK_TIMEOUT).toBe("task.timeout");
+            expect(TaskEventTypes.TASK_STOPPED).toBe("task.stopped");
+        });
+        test("event types should be unique strings", () => {
+            const types = Object.values(TaskEventTypes);
+            const uniqueTypes = new Set(types);
+            expect(uniqueTypes.size).toBe(types.length);
+        });
+    });
+    describe("createTaskStartedPayload", () => {
+        test("should create correct payload", () => {
+            const task = {
+                id: "task_123",
+                subSessionId: "sub_session_456",
+                parentSessionId: "parent_789",
+                description: "Test task",
+                subagentType: "general",
+                status: "pending",
+                createdAt: Date.now(),
+                taskId: 100,
+            };
+            const payload = createTaskStartedPayload(task, "parent_789");
+            expect(payload.taskId).toBe("task_123");
+            expect(payload.subSessionId).toBe("sub_session_456");
+            expect(payload.parentSessionId).toBe("parent_789");
+            expect(payload.description).toBe("Test task");
+            expect(payload.subagentType).toBe("general");
+            expect(payload.associatedTaskId).toBe(100);
+        });
+        test("should handle missing taskId", () => {
+            const task = {
+                id: "task_123",
+                subSessionId: "sub_session_456",
+                parentSessionId: "parent_789",
+                description: "Test task",
+                subagentType: "general",
+                status: "pending",
+                createdAt: Date.now(),
+            };
+            const payload = createTaskStartedPayload(task, "parent_789");
+            expect(payload.associatedTaskId).toBeUndefined();
+        });
+    });
+    describe("createTaskProgressPayload", () => {
+        test("should create correct payload", () => {
+            const task = {
+                id: "task_123",
+                subSessionId: "sub_session_456",
+                parentSessionId: "parent_789",
+                description: "Test task",
+                subagentType: "general",
+                status: "running",
+                createdAt: Date.now(),
+                progress: 50,
+                progressMessage: "Processing...",
+            };
+            const payload = createTaskProgressPayload(task, "parent_789");
+            expect(payload.taskId).toBe("task_123");
+            expect(payload.status).toBe("running");
+            expect(payload.progress).toBe(50);
+            expect(payload.progressMessage).toBe("Processing...");
+        });
+    });
+    describe("createTaskCompletedPayload", () => {
+        test("should create completed payload", () => {
+            const task = {
+                id: "task_123",
+                subSessionId: "sub_session_456",
+                parentSessionId: "parent_789",
+                description: "Test task",
+                subagentType: "general",
+                status: "completed",
+                createdAt: Date.now(),
+                startedAt: Date.now() - 10000,
+                completedAt: Date.now(),
+                result: "Task completed successfully",
+                taskId: 100,
+            };
+            const payload = createTaskCompletedPayload(task, "parent_789", 10000);
+            expect(payload.taskId).toBe("task_123");
+            expect(payload.status).toBe("completed");
+            expect(payload.result).toBe("Task completed successfully");
+            expect(payload.executionTimeMs).toBe(10000);
+            expect(payload.associatedTaskId).toBe(100);
+        });
+        test("should create failed payload", () => {
+            const task = {
+                id: "task_123",
+                subSessionId: "sub_session_456",
+                parentSessionId: "parent_789",
+                description: "Test task",
+                subagentType: "general",
+                status: "failed",
+                createdAt: Date.now(),
+                startedAt: Date.now() - 5000,
+                completedAt: Date.now(),
+                error: "Something went wrong",
+                taskId: 100,
+            };
+            const payload = createTaskCompletedPayload(task, "parent_789", 5000);
+            expect(payload.status).toBe("failed");
+            expect(payload.error).toBe("Something went wrong");
+        });
+        test("should create timeout payload", () => {
+            const task = {
+                id: "task_123",
+                subSessionId: "sub_session_456",
+                parentSessionId: "parent_789",
+                description: "Test task",
+                subagentType: "general",
+                status: "timeout",
+                createdAt: Date.now(),
+                startedAt: Date.now() - 900000,
+                completedAt: Date.now(),
+                error: "Task execution timeout after 900000ms",
+            };
+            const payload = createTaskCompletedPayload(task, "parent_789", 900000);
+            expect(payload.status).toBe("timeout");
+        });
+        test("should create stopped payload", () => {
+            const task = {
+                id: "task_123",
+                subSessionId: "sub_session_456",
+                parentSessionId: "parent_789",
+                description: "Test task",
+                subagentType: "general",
+                status: "stopped",
+                createdAt: Date.now(),
+                startedAt: Date.now() - 3000,
+                completedAt: Date.now(),
+            };
+            const payload = createTaskCompletedPayload(task, "parent_789", 3000);
+            expect(payload.status).toBe("stopped");
+        });
+    });
+});
+//# sourceMappingURL=task-events.test.js.map

package/dist/core/src/env/task/hooks/contexts.d.ts

@@ -0,0 +1,165 @@
+/**
+ * @fileoverview Task Hook Contexts - Hook 上下文类型定义
+ */
+import type { CreateTaskOptions, UpdateTaskOptions, Task, TaskOperation, CreateOperationOptions } from "../types";
+import type { TagService } from "../tag-service";
+import type { DelegateToolResult } from "../delegate/delegate-tool";
+/**
+ * Task Create Hook Context
+ *
+ * 触发时机：createTask() 方法调用后，实际创建前
+ *
+ * Plugin 可直接修改 options 来干预创建行为
+ */
+export interface TaskCreateContext {
+    /** 创建选项（Plugin 可直接修改） */
+    options: CreateTaskOptions;
+    /** Session ID */
+    sessionId: string;
+    /** Tag 服务引用 */
+    tagService: TagService;
+}
+/**
+ * Task Create Result Hook Context
+ *
+ * 触发时机：Task 创建成功后
+ *
+ * Plugin 可在此 Hook 中：
+ * - 同步 Tag 到数据库
+ * - 创建关联资源
+ * - 发送通知
+ */
+export interface TaskCreateResultContext {
+    /** 创建后的 Task（已包含生成 ID） */
+    task: Task;
+    /** Session ID */
+    sessionId: string;
+    /** Tag 服务引用 */
+    tagService: TagService;
+}
+/**
+ * Task Update Hook Context
+ *
+ * 触发时机：updateTask() 方法调用后，实际更新前
+ *
+ * Plugin 可直接修改 options 来干预更新行为
+ */
+export interface TaskUpdateContext {
+    /** Task ID */
+    id: number;
+    /** 更新选项（Plugin 可直接修改） */
+    options: UpdateTaskOptions;
+    /** Tag 服务引用 */
+    tagService: TagService;
+}
+/**
+ * Task Update Result Hook Context
+ *
+ * 触发时机：Task 更新成功后
+ */
+export interface TaskUpdateResultContext {
+    /** 更新后的 Task */
+    task: Task;
+    /** 变更的字段 */
+    changes: Partial<UpdateTaskOptions>;
+    /** Tag 服务引用 */
+    tagService: TagService;
+}
+/**
+ * Task Delete Hook Context
+ *
+ * 触发时机：deleteTask() 方法调用后，实际删除前
+ */
+export interface TaskDeleteContext {
+    /** Task ID */
+    id: number;
+}
+/**
+ * Task Delete Result Hook Context
+ *
+ * 触发时机：Task 删除成功后
+ *
+ * 注意：删除成功后无法获取 Task 的详细信息
+ */
+export interface TaskDeleteResultContext {
+    /** 被删除的 Task ID */
+    id: number;
+    /** 是否成功删除 */
+    deleted: boolean;
+}
+/**
+ * Delegate Before Hook Context
+ *
+ * 触发时机：delegate_task 工具执行前
+ *
+ * Plugin 可直接修改 prompt 来注入上下文
+ */
+export interface TaskDelegateContext {
+    /** 关联的 Task ID */
+    taskId?: number;
+    /** 执行提示词（Plugin 可直接修改以注入上下文） */
+    prompt: string;
+    /** SubAgent 类型 */
+    subagentType: string;
+    /** 是否后台执行 */
+    background: boolean;
+    /** 超时时间 */
+    timeout?: number;
+    /** 清理策略 */
+    cleanup?: "delete" | "keep";
+    /** 执行原因 */
+    reason?: string;
+    /** Tag 服务引用 */
+    tagService: TagService;
+}
+/**
+ * Delegate After Hook Context
+ *
+ * 触发时机：delegate_task 工具执行后
+ */
+export interface TaskDelegateResultContext {
+    /** 关联的 Task ID */
+    taskId?: number;
+    /** 执行结果 */
+    result: DelegateToolResult;
+    /** Tag 服务引用 */
+    tagService: TagService;
+}
+/**
+ * Operation Create Hook Context
+ *
+ * 触发时机：createOperation() 方法调用后，实际创建前
+ *
+ * Plugin 可直接修改 options 来干预操作记录创建
+ */
+export interface TaskOperationCreateContext {
+    /** 创建选项（Plugin 可直接修改） */
+    options: CreateOperationOptions;
+}
+/**
+ * Operation Create Result Hook Context
+ *
+ * 触发时机：操作记录创建成功后
+ */
+export interface TaskOperationCreateResultContext {
+    /** 创建后的操作记录 */
+    operation: TaskOperation;
+}
+/**
+ * TaskHookContextMap - Hook 点与 Context 类型的映射
+ *
+ * 用于 Hook 执行时类型安全的 Context 获取
+ */
+export interface TaskHookContextMap {
+    "task:before.create": TaskCreateContext;
+    "task:after.create": TaskCreateResultContext;
+    "task:before.update": TaskUpdateContext;
+    "task:after.update": TaskUpdateResultContext;
+    "task:before.delete": TaskDeleteContext;
+    "task:after.delete": TaskDeleteResultContext;
+    "task:delegate:before": TaskDelegateContext;
+    "task:delegate:after": TaskDelegateResultContext;
+    "task:operation:before.create": TaskOperationCreateContext;
+    "task:operation:after.create": TaskOperationCreateResultContext;
+}
+//# sourceMappingURL=contexts.d.ts.map

package/dist/core/src/env/task/hooks/contexts.js

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Task Hook Contexts - Hook 上下文类型定义
+ */
+export {};
+//# sourceMappingURL=contexts.js.map

package/dist/core/src/env/task/hooks/contexts.test.d.ts

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

package/dist/core/src/env/task/hooks/contexts.test.js

@@ -0,0 +1,73 @@
+/**
+ * @fileoverview Task Hook Contexts Tests
+ */
+import { describe, test, expect } from "vitest";
+describe("Task Hook Contexts", () => {
+    test("TaskCreateContext should have required fields", () => {
+        const ctx = {
+            options: {
+                title: "Test Task",
+                sessionId: "test-session",
+            },
+            sessionId: "test-session",
+            tagService: {},
+        };
+        expect(ctx.options.title).toBe("Test Task");
+        expect(ctx.sessionId).toBe("test-session");
+        expect(ctx.tagService).toBeDefined();
+    });
+    test("TaskUpdateContext should have required fields", () => {
+        const ctx = {
+            id: 1,
+            options: { title: "Updated Task" },
+            tagService: {},
+        };
+        expect(ctx.id).toBe(1);
+        expect(ctx.options.title).toBe("Updated Task");
+    });
+    test("TaskDeleteContext should have required fields", () => {
+        const ctx = { id: 1 };
+        expect(ctx.id).toBe(1);
+    });
+    test("TaskDelegateContext should have required fields", () => {
+        const ctx = {
+            taskId: 1,
+            prompt: "Do something",
+            subagentType: "general",
+            background: false,
+            tagService: {},
+        };
+        expect(ctx.taskId).toBe(1);
+        expect(ctx.prompt).toBe("Do something");
+        expect(ctx.subagentType).toBe("general");
+        expect(ctx.background).toBe(false);
+    });
+    test("TaskOperationCreateContext should have required fields", () => {
+        const ctx = {
+            options: {
+                taskId: 1,
+                sessionId: "test-session",
+                actionType: "create",
+                actionTitle: "Test",
+            },
+        };
+        expect(ctx.options.taskId).toBe(1);
+        expect(ctx.options.actionType).toBe("create");
+    });
+    test("TaskHookContextMap should map all hook points", () => {
+        const map = {
+            "task:before.create": {},
+            "task:after.create": {},
+            "task:before.update": {},
+            "task:after.update": {},
+            "task:before.delete": {},
+            "task:after.delete": {},
+            "task:delegate:before": {},
+            "task:delegate:after": {},
+            "task:operation:before.create": {},
+            "task:operation:after.create": {},
+        };
+        expect(Object.keys(map)).toHaveLength(10);
+    });
+});
+//# sourceMappingURL=contexts.test.js.map

package/dist/core/src/env/task/hooks/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Task Hooks Module
+ *
+ * 提供 Task Component 的 Hook 机制
+ */
+export { TaskHookPoints, type TaskHookPoint } from "./task-hook-points";
+export type { TaskCreateContext, TaskCreateResultContext, TaskUpdateContext, TaskUpdateResultContext, TaskDeleteContext, TaskDeleteResultContext, TaskDelegateContext, TaskDelegateResultContext, TaskOperationCreateContext, TaskOperationCreateResultContext, TaskHookContextMap, } from "./contexts";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/src/env/task/hooks/index.js

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Task Hooks Module
+ *
+ * 提供 Task Component 的 Hook 机制
+ */
+// Hook 点常量
+export { TaskHookPoints } from "./task-hook-points.js";
+//# sourceMappingURL=index.js.map

package/dist/core/src/env/task/hooks/task-hook-points.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @fileoverview Task Hook Points - Hook 点常量定义
+ *
+ * 定义 Task Component 生命周期中的所有 Hook 点
+ */
+export declare const TaskHookPoints: {
+    /** 创建 Task 前 - 可干预 options */
+    readonly BEFORE_CREATE: "task:before.create";
+    /** 创建 Task 后 - 观察或触发副作用 */
+    readonly AFTER_CREATE: "task:after.create";
+    /** 更新 Task 前 - 可干预 options */
+    readonly BEFORE_UPDATE: "task:before.update";
+    /** 更新 Task 后 - 观察变更 */
+    readonly AFTER_UPDATE: "task:after.update";
+    /** 删除 Task 前 - 观察 */
+    readonly BEFORE_DELETE: "task:before.delete";
+    /** 删除 Task 后 - 清理关联资源 */
+    readonly AFTER_DELETE: "task:after.delete";
+    /** 委派任务前 - 可干预 prompt、参数 */
+    readonly DELEGATE_BEFORE: "task:delegate:before";
+    /** 委派任务后 - 观察结果 */
+    readonly DELEGATE_AFTER: "task:delegate:after";
+    /** 创建操作记录前 - 可干预 options */
+    readonly OPERATION_BEFORE_CREATE: "task:operation:before.create";
+    /** 创建操作记录后 - 观察或触发副作用 */
+    readonly OPERATION_AFTER_CREATE: "task:operation:after.create";
+};
+/**
+ * Task Hook 点类型
+ */
+export type TaskHookPoint = typeof TaskHookPoints[keyof typeof TaskHookPoints];
+//# sourceMappingURL=task-hook-points.d.ts.map

package/dist/core/src/env/task/hooks/task-hook-points.js

@@ -0,0 +1,37 @@
+/**
+ * @fileoverview Task Hook Points - Hook 点常量定义
+ *
+ * 定义 Task Component 生命周期中的所有 Hook 点
+ */
+export const TaskHookPoints = {
+    // ========================================================================
+    // Task CRUD Hooks
+    // ========================================================================
+    /** 创建 Task 前 - 可干预 options */
+    BEFORE_CREATE: "task:before.create",
+    /** 创建 Task 后 - 观察或触发副作用 */
+    AFTER_CREATE: "task:after.create",
+    /** 更新 Task 前 - 可干预 options */
+    BEFORE_UPDATE: "task:before.update",
+    /** 更新 Task 后 - 观察变更 */
+    AFTER_UPDATE: "task:after.update",
+    /** 删除 Task 前 - 观察 */
+    BEFORE_DELETE: "task:before.delete",
+    /** 删除 Task 后 - 清理关联资源 */
+    AFTER_DELETE: "task:after.delete",
+    // ========================================================================
+    // Delegate Hooks
+    // ========================================================================
+    /** 委派任务前 - 可干预 prompt、参数 */
+    DELEGATE_BEFORE: "task:delegate:before",
+    /** 委派任务后 - 观察结果 */
+    DELEGATE_AFTER: "task:delegate:after",
+    // ========================================================================
+    // Operation Hooks
+    // ========================================================================
+    /** 创建操作记录前 - 可干预 options */
+    OPERATION_BEFORE_CREATE: "task:operation:before.create",
+    /** 创建操作记录后 - 观察或触发副作用 */
+    OPERATION_AFTER_CREATE: "task:operation:after.create",
+};
+//# sourceMappingURL=task-hook-points.js.map

package/dist/core/src/env/task/hooks/task-hook-points.test.d.ts

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

package/dist/core/src/env/task/hooks/task-hook-points.test.js

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Task Hook Points Tests
+ */
+import { describe, test, expect } from "vitest";
+import { TaskHookPoints } from "./task-hook-points.js";
+describe("TaskHookPoints", () => {
+    test("should export all task CRUD hook points", () => {
+        expect(TaskHookPoints.BEFORE_CREATE).toBe("task:before.create");
+        expect(TaskHookPoints.AFTER_CREATE).toBe("task:after.create");
+        expect(TaskHookPoints.BEFORE_UPDATE).toBe("task:before.update");
+        expect(TaskHookPoints.AFTER_UPDATE).toBe("task:after.update");
+        expect(TaskHookPoints.BEFORE_DELETE).toBe("task:before.delete");
+        expect(TaskHookPoints.AFTER_DELETE).toBe("task:after.delete");
+    });
+    test("should export delegate hook points", () => {
+        expect(TaskHookPoints.DELEGATE_BEFORE).toBe("task:delegate:before");
+        expect(TaskHookPoints.DELEGATE_AFTER).toBe("task:delegate:after");
+    });
+    test("should export operation hook points", () => {
+        expect(TaskHookPoints.OPERATION_BEFORE_CREATE).toBe("task:operation:before.create");
+        expect(TaskHookPoints.OPERATION_AFTER_CREATE).toBe("task:operation:after.create");
+    });
+    test("should have 10 hook points total", () => {
+        const hookPoints = Object.values(TaskHookPoints);
+        expect(hookPoints).toHaveLength(10);
+    });
+});
+//# sourceMappingURL=task-hook-points.test.js.map