pulse-coder-engine 0.0.1-alpha.10 → 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,
@@ -415,15 +417,28 @@ var maybeCompactContext = async (context, options) => {
 };
 
 // src/core/loop.ts
-function applyToolHooks(tools, hooks) {
+function wrapToolsWithHooks(tools, beforeHooks, afterHooks) {
   const wrapped = {};
   for (const [name, t] of Object.entries(tools)) {
     wrapped[name] = {
       ...t,
       execute: async (input, ctx) => {
-        const finalInput = hooks.onBeforeToolCall ? await hooks.onBeforeToolCall(name, input) ?? input : input;
+        let finalInput = input;
+        for (const hook of beforeHooks) {
+          const result = await hook({ name, input: finalInput });
+          if (result && "input" in result) {
+            finalInput = result.input;
+          }
+        }
         const output = await t.execute(finalInput, ctx);
-        return hooks.onAfterToolCall ? await hooks.onAfterToolCall(name, finalInput, output) ?? output : output;
+        let finalOutput = output;
+        for (const hook of afterHooks) {
+          const result = await hook({ name, input: finalInput, output: finalOutput });
+          if (result && "output" in result) {
+            finalOutput = result.output;
+          }
+        }
+        return finalOutput;
       }
     };
   }
@@ -433,6 +448,7 @@ async function loop(context, options) {
   let errorCount = 0;
   let totalSteps = 0;
   let compactionAttempts = 0;
+  const loopHooks = options?.hooks ?? {};
   while (true) {
     try {
       if (compactionAttempts < MAX_COMPACTION_ATTEMPTS) {
@@ -449,8 +465,24 @@ async function loop(context, options) {
         }
       }
       let tools = options?.tools || {};
-      if (options?.hooks) {
-        tools = applyToolHooks(tools, options.hooks);
+      let systemPrompt = options?.systemPrompt;
+      if (loopHooks.beforeLLMCall?.length) {
+        for (const hook of loopHooks.beforeLLMCall) {
+          const result2 = await hook({ context, systemPrompt, tools });
+          if (result2) {
+            if ("systemPrompt" in result2 && result2.systemPrompt !== void 0) {
+              systemPrompt = result2.systemPrompt;
+            }
+            if ("tools" in result2 && result2.tools !== void 0) {
+              tools = result2.tools;
+            }
+          }
+        }
+      }
+      const beforeToolHooks = loopHooks.beforeToolCall ?? [];
+      const afterToolHooks = loopHooks.afterToolCall ?? [];
+      if (beforeToolHooks.length || afterToolHooks.length) {
+        tools = wrapToolsWithHooks(tools, beforeToolHooks, afterToolHooks);
       }
       const toolExecutionContext = {
         onClarificationRequest: options?.onClarificationRequest,
@@ -461,7 +493,7 @@ async function loop(context, options) {
         toolExecutionContext,
         provider: options?.provider,
         model: options?.model,
-        systemPrompt: options?.systemPrompt,
+        systemPrompt,
         onStepFinish: (step) => {
           options?.onStepFinish?.(step);
         },
@@ -489,6 +521,11 @@ async function loop(context, options) {
           options?.onResponse?.(messages);
         }
       }
+      if (loopHooks.afterLLMCall?.length) {
+        for (const hook of loopHooks.afterLLMCall) {
+          await hook({ context, finishReason, text });
+        }
+      }
       if (finishReason === "stop") {
         return text || "Task completed.";
       }
@@ -712,7 +749,7 @@ var GrepTool = {
   }),
   execute: async ({
     pattern,
-    path: path5 = ".",
+    path: path6 = ".",
     glob: glob2,
     type,
     outputMode = "files_with_matches",
@@ -747,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("*")) {
@@ -806,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 };
   }
 };
@@ -1066,9 +1103,15 @@ var PluginManager = class {
   enginePlugins = /* @__PURE__ */ new Map();
   userConfigPlugins = [];
   tools = /* @__PURE__ */ new Map();
-  runHooks = /* @__PURE__ */ new Map();
+  hooks = {
+    beforeRun: [],
+    afterRun: [],
+    beforeLLMCall: [],
+    afterLLMCall: [],
+    beforeToolCall: [],
+    afterToolCall: []
+  };
   services = /* @__PURE__ */ new Map();
-  protocols = /* @__PURE__ */ new Map();
   config = /* @__PURE__ */ new Map();
   events = new import_events.EventEmitter();
   logger;
@@ -1177,14 +1220,10 @@ var PluginManager = class {
         },
         getTool: (name) => this.tools.get(name),
         getTools: () => Object.fromEntries(this.tools),
-        registerRunHook: (name, hook) => {
-          this.runHooks.set(name, hook);
-        },
-        getRunHook: (name) => this.runHooks.get(name),
-        registerProtocol: (name, handler) => {
-          this.protocols.set(name, handler);
+        registerHook: (hookName, handler) => {
+          this.hooks[hookName].push(handler);
+          this.logger.debug(`Plugin "${plugin.name}" registered hook: ${hookName}`);
         },
-        getProtocol: (name) => this.protocols.get(name),
         registerService: (name, service) => {
           this.services.set(name, service);
         },
@@ -1380,10 +1419,10 @@ var PluginManager = class {
     return Object.fromEntries(this.tools);
   }
   /**
-   * 运行时钩子获取
+   * 获取指定类型的 hook 处理函数数组
    */
-  getRunHooks() {
-    return Array.from(this.runHooks.values());
+  getHooks(hookName) {
+    return [...this.hooks[hookName]];
   }
   /**
    * 服务获取
@@ -1391,12 +1430,6 @@ var PluginManager = class {
   getService(name) {
     return this.services.get(name);
   }
-  /**
-   * 协议获取
-   */
-  getProtocol(name) {
-    return this.protocols.get(name);
-  }
   /**
    * 获取插件状态
    */
@@ -1405,9 +1438,10 @@ var PluginManager = class {
       enginePlugins: Array.from(this.enginePlugins.keys()),
       userConfigPlugins: this.userConfigPlugins.map((c) => c.name || "unnamed"),
       tools: Array.from(this.tools.keys()),
-      runHooks: Array.from(this.runHooks.keys()),
-      services: Array.from(this.services.keys()),
-      protocols: Array.from(this.protocols.keys())
+      hooks: Object.fromEntries(
+        Object.entries(this.hooks).map(([k, v]) => [k, v.length])
+      ),
+      services: Array.from(this.services.keys())
     };
   }
   /**
@@ -1582,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);
   }
   /**
    * 搜索技能（模糊匹配）
@@ -1606,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.",
@@ -1627,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`);
       }
@@ -1644,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)`);
   }
 };
@@ -1762,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 {
@@ -1884,25 +1973,6 @@ var BuiltInPlanModeService = class {
     }
     return lines.join("\n");
   }
-  applyHooks(baseHooks) {
-    return {
-      onBeforeToolCall: async (name, input) => {
-        this.observePotentialPolicyViolation(name, input);
-        if (baseHooks?.onBeforeToolCall) {
-          const nextInput = await baseHooks.onBeforeToolCall(name, input);
-          return nextInput ?? input;
-        }
-        return input;
-      },
-      onAfterToolCall: async (name, input, output) => {
-        if (baseHooks?.onAfterToolCall) {
-          const nextOutput = await baseHooks.onAfterToolCall(name, input, output);
-          return nextOutput ?? output;
-        }
-        return output;
-      }
-    };
-  }
   getEvents(limit = 50) {
     return this.events.slice(-Math.max(0, limit));
   }
@@ -2039,21 +2109,18 @@ var builtInPlanModePlugin = {
   version: "1.0.0",
   async initialize(context) {
     const service = new BuiltInPlanModeService(context.logger, context.events, "executing");
-    context.registerRunHook("plan-mode", ({ context: runContext, tools, systemPrompt, hooks }) => {
+    context.registerHook("beforeLLMCall", ({ context: runContext, tools, systemPrompt }) => {
       const mode = service.getMode();
       if (mode === "executing") {
-        return {
-          systemPrompt,
-          hooks
-        };
+        return;
       }
       const transition = service.processContextMessages(runContext.messages);
       const append = service.buildPromptAppend(Object.keys(tools), transition);
       const finalSystemPrompt = appendSystemPrompt(systemPrompt, append);
-      return {
-        systemPrompt: finalSystemPrompt,
-        hooks: service.applyHooks(hooks)
-      };
+      return { systemPrompt: finalSystemPrompt };
+    });
+    context.registerHook("beforeToolCall", ({ name, input }) => {
+      service.observePotentialPolicyViolation(name, input);
     });
     context.registerService("planMode", service);
     context.registerService("planModeService", service);
@@ -2063,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;
@@ -2090,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);
           }
         }
@@ -2102,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 = "";
@@ -2131,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(),
@@ -2182,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() };
@@ -2211,6 +2665,7 @@ var builtInPlugins = [
   builtInMCPPlugin,
   builtInSkillsPlugin,
   builtInPlanModePlugin,
+  builtInTaskTrackingPlugin,
   new SubAgentPlugin()
 ];
 
@@ -2264,52 +2719,70 @@ var Engine = class {
       // 默认启用扫描
     };
   }
-  async applyRunHooks(context, systemPrompt, hooks) {
-    let nextSystemPrompt = systemPrompt;
-    let nextHooks = hooks;
-    for (const runHook of this.pluginManager.getRunHooks()) {
-      const result = await runHook({
-        context,
-        messages: context.messages,
-        tools: this.tools,
-        systemPrompt: nextSystemPrompt,
-        hooks: nextHooks
+  /**
+   * Collect all hooks for a given loop invocation.
+   * Merges plugin hooks with the legacy EngineOptions.hooks (ToolHooks).
+   */
+  collectLoopHooks() {
+    const loopHooks = {
+      beforeLLMCall: this.pluginManager.getHooks("beforeLLMCall"),
+      afterLLMCall: this.pluginManager.getHooks("afterLLMCall"),
+      beforeToolCall: [...this.pluginManager.getHooks("beforeToolCall")],
+      afterToolCall: [...this.pluginManager.getHooks("afterToolCall")]
+    };
+    const legacyHooks = this.options.hooks;
+    if (legacyHooks?.onBeforeToolCall) {
+      const legacyBefore = legacyHooks.onBeforeToolCall;
+      loopHooks.beforeToolCall.push(async ({ name, input }) => {
+        const modified = await legacyBefore(name, input);
+        return modified !== void 0 ? { input: modified } : void 0;
       });
-      if (!result) {
-        continue;
-      }
-      if ("systemPrompt" in result) {
-        nextSystemPrompt = result.systemPrompt;
-      }
-      if ("hooks" in result) {
-        nextHooks = result.hooks;
-      }
     }
-    return {
-      systemPrompt: nextSystemPrompt,
-      hooks: nextHooks
-    };
+    if (legacyHooks?.onAfterToolCall) {
+      const legacyAfter = legacyHooks.onAfterToolCall;
+      loopHooks.afterToolCall.push(async ({ name, input, output }) => {
+        const modified = await legacyAfter(name, input, output);
+        return modified !== void 0 ? { output: modified } : void 0;
+      });
+    }
+    return loopHooks;
   }
   /**
    * 运行AI循环
    */
   async run(context, options) {
-    const baseSystemPrompt = options?.systemPrompt ?? this.options.systemPrompt;
-    const baseHooks = options?.hooks ?? this.options.hooks;
-    const { systemPrompt, hooks } = await this.applyRunHooks(context, baseSystemPrompt, baseHooks);
-    return loop(context, {
+    let systemPrompt = options?.systemPrompt ?? this.options.systemPrompt;
+    let tools = { ...this.tools };
+    const beforeRunHooks = this.pluginManager.getHooks("beforeRun");
+    for (const hook of beforeRunHooks) {
+      const result = await hook({ context, systemPrompt, tools });
+      if (result) {
+        if ("systemPrompt" in result && result.systemPrompt !== void 0) {
+          systemPrompt = result.systemPrompt;
+        }
+        if ("tools" in result && result.tools !== void 0) {
+          tools = result.tools;
+        }
+      }
+    }
+    const loopHooks = this.collectLoopHooks();
+    const resultText = await loop(context, {
       ...options,
-      tools: this.tools,
-      // Engine 级别选项作为默认值；调用方通过 options 传入可在单次调用中覆盖
+      tools,
       provider: options?.provider ?? this.options.llmProvider,
       model: options?.model ?? this.options.model,
       systemPrompt,
-      hooks,
+      hooks: loopHooks,
       onToolCall: (toolCall) => {
         options?.onToolCall?.(toolCall);
       },
       onClarificationRequest: options?.onClarificationRequest
     });
+    const afterRunHooks = this.pluginManager.getHooks("afterRun");
+    for (const hook of afterRunHooks) {
+      await hook({ context, result: resultText });
+    }
+    return resultText;
   }
   /**
    * 获取插件状态
@@ -2380,12 +2853,14 @@ var Engine = class {
   PluginManager,
   PulseAgent,
   ReadTool,
+  TaskListService,
   TavilyTool,
   WriteTool,
   builtInMCPPlugin,
   builtInPlanModePlugin,
   builtInPlugins,
   builtInSkillsPlugin,
+  builtInTaskTrackingPlugin,
   getFinalToolsMap,
   loop,
   maybeCompactContext,