pulse-coder-engine 0.0.1-alpha.11 → 0.0.1-alpha.12

package/dist/index.cjs

@@ -43,12 +43,14 @@ __export(src_exports, {
   PluginManager: () => PluginManager,
   PulseAgent: () => Engine,
   ReadTool: () => ReadTool,
+  TaskListService: () => TaskListService,
   TavilyTool: () => TavilyTool,
   WriteTool: () => WriteTool,
   builtInMCPPlugin: () => builtInMCPPlugin,
   builtInPlanModePlugin: () => builtInPlanModePlugin,
   builtInPlugins: () => builtInPlugins,
   builtInSkillsPlugin: () => builtInSkillsPlugin,
+  builtInTaskTrackingPlugin: () => builtInTaskTrackingPlugin,
   getFinalToolsMap: () => getFinalToolsMap,
   loop: () => loop,
   maybeCompactContext: () => maybeCompactContext,
@@ -747,7 +749,7 @@ var GrepTool = {
   }),
   execute: async ({
     pattern,
-    path: path5 = ".",
+    path: path6 = ".",
     glob: glob2,
     type,
     outputMode = "files_with_matches",
@@ -782,11 +784,11 @@ var GrepTool = {
     if (type) {
       args.push("--type", type);
     }
-    if (path5 && path5 !== ".") {
-      if (!(0, import_fs5.existsSync)(path5)) {
-        throw new Error(`Path does not exist: ${path5}`);
+    if (path6 && path6 !== ".") {
+      if (!(0, import_fs5.existsSync)(path6)) {
+        throw new Error(`Path does not exist: ${path6}`);
       }
-      args.push(path5);
+      args.push(path6);
     }
     let command = args.map((arg) => {
       if (arg.includes(" ") || arg.includes("$") || arg.includes("*")) {
@@ -841,8 +843,8 @@ var LsTool = {
   inputSchema: import_zod5.default.object({
     path: import_zod5.default.string().optional().describe("The path to list files from (defaults to current directory)")
   }),
-  execute: async ({ path: path5 = "." }) => {
-    const files = (0, import_fs6.readdirSync)(path5);
+  execute: async ({ path: path6 = "." }) => {
+    const files = (0, import_fs6.readdirSync)(path6);
     return { files };
   }
 };
@@ -1614,16 +1616,44 @@ var BuiltInSkillRegistry = class {
     return Array.from(this.skills.values());
   }
   /**
-   * 根据名称获取技能
+   * 注册或更新一个技能（支持插件在运行期追加技能）
+   */
+  registerSkill(skill) {
+    const name = skill.name?.trim();
+    if (!name) {
+      throw new Error("Skill name is required");
+    }
+    const existingKey = Array.from(this.skills.keys()).find((key) => key.toLowerCase() === name.toLowerCase());
+    const replaced = existingKey !== void 0;
+    if (existingKey && existingKey !== name) {
+      this.skills.delete(existingKey);
+    }
+    this.skills.set(name, {
+      ...skill,
+      name
+    });
+    return {
+      skillName: name,
+      replaced,
+      total: this.skills.size
+    };
+  }
+  /**
+   * 根据名称获取技能（大小写不敏感）
    */
   get(name) {
-    return this.skills.get(name);
+    const exact = this.skills.get(name);
+    if (exact) {
+      return exact;
+    }
+    const target = name.toLowerCase();
+    return this.getAll().find((skill) => skill.name.toLowerCase() === target);
   }
   /**
    * 检查技能是否存在
    */
   has(name) {
-    return this.skills.has(name);
+    return !!this.get(name);
   }
   /**
    * 搜索技能（模糊匹配）
@@ -1638,7 +1668,7 @@ var BuiltInSkillRegistry = class {
 var skillToolSchema = import_zod10.z.object({
   name: import_zod10.z.string().describe("The name of the skill to execute")
 });
-function generateSkillTool(skills) {
+function generateSkillTool(registry) {
   const getSkillsPrompt = (availableSkills) => {
     return [
       "If query matches an available skill's description or instruction [use skill], use the skill tool to get detailed instructions.",
@@ -1659,10 +1689,10 @@ function generateSkillTool(skills) {
   };
   return {
     name: "skill",
-    description: getSkillsPrompt(skills),
+    description: getSkillsPrompt(registry.getAll()),
     inputSchema: skillToolSchema,
     execute: async ({ name }) => {
-      const skill = skills.find((skill2) => skill2.name === name);
+      const skill = registry.get(name);
       if (!skill) {
         throw new Error(`Skill ${name} not found`);
       }
@@ -1676,14 +1706,21 @@ var builtInSkillsPlugin = {
   async initialize(context) {
     const registry = new BuiltInSkillRegistry();
     await registry.initialize(process.cwd());
+    context.registerService("skillRegistry", registry);
+    context.registerTool("skill", generateSkillTool(registry));
+    context.registerHook("beforeRun", ({ tools }) => {
+      return {
+        tools: {
+          ...tools,
+          skill: generateSkillTool(registry)
+        }
+      };
+    });
     const skills = registry.getAll();
     if (skills.length === 0) {
       console.log("[Skills] No skills found");
       return;
     }
-    const skillTool = generateSkillTool(skills);
-    context.registerTool("skill", skillTool);
-    context.registerService("skillRegistry", registry);
     console.log(`[Skills] Registered ${skills.length} skill(s)`);
   }
 };
@@ -1794,6 +1831,26 @@ var KNOWN_TOOL_META = {
     category: "other",
     risk: "low",
     description: "Ask the user a targeted clarification question."
+  },
+  task_create: {
+    category: "other",
+    risk: "low",
+    description: "Create tracked task entries for planning and execution visibility."
+  },
+  task_get: {
+    category: "other",
+    risk: "low",
+    description: "Inspect a task entry by ID."
+  },
+  task_list: {
+    category: "other",
+    risk: "low",
+    description: "List task tracking entries and status summary."
+  },
+  task_update: {
+    category: "other",
+    risk: "low",
+    description: "Update task tracking fields and status."
   }
 };
 var BuiltInPlanModeService = class {
@@ -2073,17 +2130,404 @@ var builtInPlanModePlugin = {
   }
 };
 
-// src/built-in/sub-agent-plugin/index.ts
-var import_zod11 = require("zod");
+// src/built-in/task-tracking-plugin/index.ts
 var import_fs10 = require("fs");
 var import_path4 = __toESM(require("path"), 1);
+var import_os2 = require("os");
+var import_crypto2 = require("crypto");
+var import_zod11 = require("zod");
+var TASK_STATUSES = ["pending", "in_progress", "completed", "blocked"];
+var CREATE_TASK_ITEM_SCHEMA = import_zod11.z.object({
+  title: import_zod11.z.string().min(1).describe("Task title"),
+  details: import_zod11.z.string().optional().describe("Task details / acceptance notes"),
+  status: import_zod11.z.enum(TASK_STATUSES).optional().describe("Initial status; defaults to pending"),
+  dependencies: import_zod11.z.array(import_zod11.z.string()).optional().describe("Task IDs that must be completed first"),
+  blockedReason: import_zod11.z.string().optional().describe("Reason when status is blocked"),
+  metadata: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()).optional().describe("Additional machine-readable metadata")
+});
+var TASK_CREATE_INPUT_SCHEMA = import_zod11.z.object({
+  title: import_zod11.z.string().min(1).optional().describe("Task title (single-task mode)"),
+  details: import_zod11.z.string().optional().describe("Task details (single-task mode)"),
+  status: import_zod11.z.enum(TASK_STATUSES).optional().describe("Initial status (single-task mode)"),
+  dependencies: import_zod11.z.array(import_zod11.z.string()).optional().describe("Dependencies (single-task mode)"),
+  blockedReason: import_zod11.z.string().optional().describe("Blocked reason (single-task mode)"),
+  metadata: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()).optional().describe("Metadata (single-task mode)"),
+  tasks: import_zod11.z.array(CREATE_TASK_ITEM_SCHEMA).min(1).optional().describe("Batch create mode")
+}).refine((value) => !!value.tasks?.length || !!value.title, {
+  message: "Either provide `tasks` or `title` for single-task mode."
+});
+var TASK_GET_INPUT_SCHEMA = import_zod11.z.object({
+  id: import_zod11.z.string().min(1).describe("Task ID to retrieve")
+});
+var TASK_LIST_INPUT_SCHEMA = import_zod11.z.object({
+  statuses: import_zod11.z.array(import_zod11.z.enum(TASK_STATUSES)).optional().describe("Filter by statuses"),
+  includeCompleted: import_zod11.z.boolean().optional().describe("Set false to hide completed tasks"),
+  limit: import_zod11.z.number().int().positive().max(500).optional().describe("Maximum tasks to return")
+});
+var TASK_TRACKING_SKILL = {
+  name: "task-tracking-workflow",
+  description: "Track complex execution with task tools and proceed directly without confirmation unless the user explicitly asks for confirmation.",
+  location: "pulse-coder-engine/built-in/task-tracking-plugin",
+  content: `# Task Tracking Workflow
+
+## When to use
+- The request has multiple phases or deliverables.
+- Work may span multiple tool calls or sessions.
+- You need explicit progress visibility and blocker management.
+
+## Execution autonomy
+- Default behavior: execute directly and call tools without asking for confirmation.
+- Only ask for confirmation when the user explicitly requires confirmation.
+- If critical information is missing, ask only the minimum clarifying question needed to continue.
+
+## Required flow
+1. Start by reviewing existing tasks with \`task_list\`.
+2. If no suitable tasks exist, create focused tasks with \`task_create\` (prefer batch mode).
+3. Keep exactly one primary task in \`in_progress\` where possible.
+4. Update status with \`task_update\` after meaningful progress.
+5. Mark blockers with \`status=blocked\` and a concrete \`blockedReason\`.
+6. Mark done tasks as \`completed\` and move to the next actionable item.
+
+## Quality rules
+- Keep tasks atomic and verifiable.
+- Avoid single oversized umbrella tasks.
+- Reuse existing in-progress tasks instead of duplicating.
+- Keep dependency links explicit when order matters.`
+};
+var TASK_UPDATE_INPUT_SCHEMA = import_zod11.z.object({
+  id: import_zod11.z.string().min(1).describe("Task ID to update"),
+  title: import_zod11.z.string().min(1).optional().describe("New title"),
+  details: import_zod11.z.string().optional().describe("New details"),
+  status: import_zod11.z.enum(TASK_STATUSES).optional().describe("New status"),
+  dependencies: import_zod11.z.array(import_zod11.z.string()).optional().describe("Replace dependencies with this list"),
+  blockedReason: import_zod11.z.string().optional().describe("Blocked reason, used with status=blocked"),
+  metadata: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()).optional().describe("Replace metadata object"),
+  delete: import_zod11.z.boolean().optional().describe("Delete this task")
+});
+function normalizeTaskListId(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return "default";
+  }
+  return trimmed.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 120) || "default";
+}
+function now() {
+  return Date.now();
+}
+function dedupeStrings(values) {
+  if (!values?.length) {
+    return [];
+  }
+  return Array.from(new Set(values.map((value) => String(value).trim()).filter(Boolean)));
+}
+var TaskListService = class _TaskListService {
+  taskListId;
+  storagePath;
+  storageDir;
+  initialized = false;
+  createdAt = now();
+  updatedAt = now();
+  tasks = /* @__PURE__ */ new Map();
+  constructor(taskListId = _TaskListService.resolveTaskListId(), storageDir = _TaskListService.resolveStorageDir()) {
+    const normalized = normalizeTaskListId(taskListId);
+    this.storageDir = storageDir;
+    this.taskListId = normalized;
+    this.storagePath = import_path4.default.join(this.storageDir, `${normalized}.json`);
+  }
+  static resolveTaskListId() {
+    return process.env.PULSE_CODER_TASK_LIST_ID || process.env.CLAUDE_CODE_TASK_LIST_ID || "default";
+  }
+  static resolveStorageDir() {
+    return process.env.PULSE_CODER_TASKS_DIR || import_path4.default.join((0, import_os2.homedir)(), ".pulse-coder", "tasks");
+  }
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    await this.loadTaskList(this.taskListId);
+  }
+  async setTaskListId(taskListId) {
+    await this.initialize();
+    const normalized = normalizeTaskListId(taskListId);
+    if (normalized === this.taskListId) {
+      return {
+        switched: false,
+        taskListId: this.taskListId,
+        storagePath: this.storagePath
+      };
+    }
+    await this.loadTaskList(normalized);
+    return {
+      switched: true,
+      taskListId: this.taskListId,
+      storagePath: this.storagePath
+    };
+  }
+  async createTask(input) {
+    await this.initialize();
+    const timestamp = now();
+    const status = input.status ?? "pending";
+    const task = {
+      id: (0, import_crypto2.randomUUID)(),
+      title: input.title.trim(),
+      details: input.details,
+      status,
+      dependencies: dedupeStrings(input.dependencies),
+      blockedReason: status === "blocked" ? input.blockedReason ?? "Blocked without reason" : void 0,
+      metadata: input.metadata,
+      createdAt: timestamp,
+      updatedAt: timestamp,
+      completedAt: status === "completed" ? timestamp : void 0
+    };
+    this.tasks.set(task.id, task);
+    this.updatedAt = timestamp;
+    await this.persist();
+    return task;
+  }
+  async createTasks(inputs) {
+    const created = [];
+    for (const input of inputs) {
+      created.push(await this.createTask(input));
+    }
+    return created;
+  }
+  async listTasks(options) {
+    await this.initialize();
+    const statuses = options?.statuses?.length ? new Set(options.statuses) : null;
+    const includeCompleted = options?.includeCompleted ?? true;
+    let tasks = Array.from(this.tasks.values()).filter((task) => {
+      if (!includeCompleted && task.status === "completed") {
+        return false;
+      }
+      if (statuses && !statuses.has(task.status)) {
+        return false;
+      }
+      return true;
+    });
+    tasks = tasks.sort((a, b) => a.createdAt - b.createdAt);
+    if (options?.limit && options.limit > 0) {
+      tasks = tasks.slice(0, options.limit);
+    }
+    return tasks;
+  }
+  async getTask(id) {
+    await this.initialize();
+    return this.tasks.get(id) ?? null;
+  }
+  async updateTask(input) {
+    await this.initialize();
+    if (input.delete) {
+      const deleted = this.tasks.delete(input.id);
+      if (!deleted) {
+        return null;
+      }
+      this.updatedAt = now();
+      await this.persist();
+      return null;
+    }
+    const existing = this.tasks.get(input.id);
+    if (!existing) {
+      return null;
+    }
+    const timestamp = now();
+    const nextStatus = input.status ?? existing.status;
+    const next = {
+      ...existing,
+      title: input.title !== void 0 ? input.title : existing.title,
+      details: input.details !== void 0 ? input.details : existing.details,
+      status: nextStatus,
+      dependencies: input.dependencies !== void 0 ? dedupeStrings(input.dependencies) : existing.dependencies,
+      metadata: input.metadata !== void 0 ? input.metadata : existing.metadata,
+      blockedReason: this.resolveBlockedReason(nextStatus, input.blockedReason, existing.blockedReason),
+      updatedAt: timestamp,
+      completedAt: nextStatus === "completed" ? existing.completedAt ?? timestamp : void 0
+    };
+    this.tasks.set(input.id, next);
+    this.updatedAt = timestamp;
+    await this.persist();
+    return next;
+  }
+  async snapshot(options) {
+    const tasks = await this.listTasks(options);
+    return {
+      taskListId: this.taskListId,
+      storagePath: this.storagePath,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      total: tasks.length,
+      tasks
+    };
+  }
+  resolveBlockedReason(status, blockedReasonInput, previous) {
+    if (status !== "blocked") {
+      return void 0;
+    }
+    if (blockedReasonInput !== void 0) {
+      return blockedReasonInput || "Blocked without reason";
+    }
+    return previous ?? "Blocked without reason";
+  }
+  async loadTaskList(taskListId) {
+    const normalized = normalizeTaskListId(taskListId);
+    this.taskListId = normalized;
+    this.storagePath = import_path4.default.join(this.storageDir, `${normalized}.json`);
+    await import_fs10.promises.mkdir(this.storageDir, { recursive: true });
+    try {
+      const raw = await import_fs10.promises.readFile(this.storagePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      const parsedTasks = Array.isArray(parsed.tasks) ? parsed.tasks : [];
+      this.tasks = new Map(parsedTasks.filter((task) => !!task?.id).map((task) => [task.id, task]));
+      this.createdAt = typeof parsed.createdAt === "number" ? parsed.createdAt : now();
+      this.updatedAt = typeof parsed.updatedAt === "number" ? parsed.updatedAt : now();
+    } catch (error) {
+      if (error?.code !== "ENOENT") {
+        throw error;
+      }
+      const timestamp = now();
+      this.tasks = /* @__PURE__ */ new Map();
+      this.createdAt = timestamp;
+      this.updatedAt = timestamp;
+      await this.persist();
+    }
+    this.initialized = true;
+  }
+  async persist() {
+    const payload = {
+      taskListId: this.taskListId,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      tasks: Array.from(this.tasks.values()).sort((a, b) => a.createdAt - b.createdAt)
+    };
+    await import_fs10.promises.writeFile(this.storagePath, JSON.stringify(payload, null, 2), "utf-8");
+  }
+};
+function buildTaskCreateTool(service) {
+  return {
+    name: "task_create",
+    description: "Create one or more tracked tasks for complex work. Use this when work has multiple steps, dependencies, or blockers.",
+    inputSchema: TASK_CREATE_INPUT_SCHEMA,
+    execute: async ({ tasks, title, details, status, dependencies, blockedReason, metadata }) => {
+      const items = tasks?.length ? tasks : [{ title, details, status, dependencies, blockedReason, metadata }];
+      const created = await service.createTasks(items);
+      return {
+        taskListId: service.taskListId,
+        storagePath: service.storagePath,
+        createdCount: created.length,
+        tasks: created
+      };
+    }
+  };
+}
+function buildTaskGetTool(service) {
+  return {
+    name: "task_get",
+    description: "Get full details for a single task by task ID.",
+    inputSchema: TASK_GET_INPUT_SCHEMA,
+    execute: async ({ id }) => {
+      const task = await service.getTask(id);
+      if (!task) {
+        throw new Error(`Task not found: ${id}`);
+      }
+      return {
+        taskListId: service.taskListId,
+        storagePath: service.storagePath,
+        task
+      };
+    }
+  };
+}
+function buildTaskListTool(service) {
+  return {
+    name: "task_list",
+    description: "List tasks and their current status. Use this to check progress before and after major changes.",
+    inputSchema: TASK_LIST_INPUT_SCHEMA,
+    execute: async ({ statuses, includeCompleted, limit }) => {
+      const snapshot = await service.snapshot({ statuses, includeCompleted, limit });
+      const completed = snapshot.tasks.filter((task) => task.status === "completed").length;
+      const inProgress = snapshot.tasks.filter((task) => task.status === "in_progress").length;
+      const pending = snapshot.tasks.filter((task) => task.status === "pending").length;
+      const blocked = snapshot.tasks.filter((task) => task.status === "blocked").length;
+      return {
+        ...snapshot,
+        summary: {
+          total: snapshot.total,
+          completed,
+          inProgress,
+          pending,
+          blocked
+        }
+      };
+    }
+  };
+}
+function buildTaskUpdateTool(service) {
+  return {
+    name: "task_update",
+    description: "Update task fields, move status (pending/in_progress/completed/blocked), or delete tasks.",
+    inputSchema: TASK_UPDATE_INPUT_SCHEMA,
+    execute: async (input) => {
+      const task = await service.updateTask(input);
+      if (input.delete) {
+        return {
+          taskListId: service.taskListId,
+          storagePath: service.storagePath,
+          deleted: true,
+          id: input.id
+        };
+      }
+      if (!task) {
+        throw new Error(`Task not found: ${input.id}`);
+      }
+      return {
+        taskListId: service.taskListId,
+        storagePath: service.storagePath,
+        deleted: false,
+        task
+      };
+    }
+  };
+}
+var builtInTaskTrackingPlugin = {
+  name: "pulse-coder-engine/built-in-task-tracking",
+  version: "1.0.0",
+  dependencies: ["pulse-coder-engine/built-in-skills"],
+  async initialize(context) {
+    const service = new TaskListService();
+    await service.initialize();
+    context.registerService("taskListService", service);
+    context.registerService("taskTracking", service);
+    const skillRegistry = context.getService("skillRegistry");
+    if (skillRegistry) {
+      const registration = skillRegistry.registerSkill(TASK_TRACKING_SKILL);
+      context.logger.info("[TaskTracking] Registered built-in task tracking skill", registration);
+    } else {
+      context.logger.warn("[TaskTracking] skillRegistry service unavailable; skipped task tracking skill registration");
+    }
+    context.registerTools({
+      task_create: buildTaskCreateTool(service),
+      task_get: buildTaskGetTool(service),
+      task_list: buildTaskListTool(service),
+      task_update: buildTaskUpdateTool(service)
+    });
+    context.logger.info("[TaskTracking] Registered task tools", {
+      taskListId: service.taskListId,
+      storagePath: service.storagePath,
+      skillRegistryAvailable: !!skillRegistry
+    });
+  }
+};
+
+// src/built-in/sub-agent-plugin/index.ts
+var import_zod12 = require("zod");
+var import_fs11 = require("fs");
+var import_path5 = __toESM(require("path"), 1);
 var ConfigLoader = class {
   async getAgentFilesInfo(configDirs) {
     const fileInfos = [];
     for (let configDir of configDirs) {
       try {
-        await import_fs10.promises.access(configDir);
-        const files = await import_fs10.promises.readdir(configDir);
+        await import_fs11.promises.access(configDir);
+        const files = await import_fs11.promises.readdir(configDir);
         fileInfos.push({ files, configDir });
       } catch {
         continue;
@@ -2100,7 +2544,7 @@ var ConfigLoader = class {
         const files = fileInfo.files;
         for (const file of files) {
           if (file.endsWith(".md")) {
-            const config = await this.parseConfig(import_path4.default.join(fileInfo.configDir, file));
+            const config = await this.parseConfig(import_path5.default.join(fileInfo.configDir, file));
             if (config) configs.push(config);
           }
         }
@@ -2112,7 +2556,7 @@ var ConfigLoader = class {
   }
   async parseConfig(filePath) {
     try {
-      const content = await import_fs10.promises.readFile(filePath, "utf-8");
+      const content = await import_fs11.promises.readFile(filePath, "utf-8");
       const lines = content.split("\n");
       let name = "";
       let description = "";
@@ -2141,7 +2585,7 @@ var ConfigLoader = class {
         }
       }
       if (!name) {
-        name = import_path4.default.basename(filePath, ".md");
+        name = import_path5.default.basename(filePath, ".md");
       }
       return {
         name: name.trim(),
@@ -2192,9 +2636,9 @@ var SubAgentPlugin = class {
     const toolName = `${config.name}_agent`;
     const tool2 = {
       description: config.description,
-      inputSchema: import_zod11.z.object({
-        task: import_zod11.z.string().describe("\u8981\u6267\u884C\u7684\u4EFB\u52A1\u63CF\u8FF0"),
-        context: import_zod11.z.any().optional().describe("\u4EFB\u52A1\u4E0A\u4E0B\u6587\u4FE1\u606F")
+      inputSchema: import_zod12.z.object({
+        task: import_zod12.z.string().describe("\u8981\u6267\u884C\u7684\u4EFB\u52A1\u63CF\u8FF0"),
+        context: import_zod12.z.any().optional().describe("\u4EFB\u52A1\u4E0A\u4E0B\u6587\u4FE1\u606F")
       }),
       execute: async ({ task, context: taskContext }) => {
         const tools = { ...BuiltinToolsMap, ...context.getTools() };
@@ -2221,6 +2665,7 @@ var builtInPlugins = [
   builtInMCPPlugin,
   builtInSkillsPlugin,
   builtInPlanModePlugin,
+  builtInTaskTrackingPlugin,
   new SubAgentPlugin()
 ];
 
@@ -2408,12 +2853,14 @@ var Engine = class {
   PluginManager,
   PulseAgent,
   ReadTool,
+  TaskListService,
   TavilyTool,
   WriteTool,
   builtInMCPPlugin,
   builtInPlanModePlugin,
   builtInPlugins,
   builtInSkillsPlugin,
+  builtInTaskTrackingPlugin,
   getFinalToolsMap,
   loop,
   maybeCompactContext,