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

package/dist/built-in/index.cjs

@@ -33,10 +33,12 @@ __export(built_in_exports, {
   BuiltInPlanModeService: () => BuiltInPlanModeService,
   BuiltInSkillRegistry: () => BuiltInSkillRegistry,
   SubAgentPlugin: () => SubAgentPlugin,
+  TaskListService: () => TaskListService,
   builtInMCPPlugin: () => builtInMCPPlugin,
   builtInPlanModePlugin: () => builtInPlanModePlugin,
   builtInPlugins: () => builtInPlugins,
   builtInSkillsPlugin: () => builtInSkillsPlugin,
+  builtInTaskTrackingPlugin: () => builtInTaskTrackingPlugin,
   default: () => built_in_default
 });
 module.exports = __toCommonJS(built_in_exports);
@@ -202,16 +204,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);
   }
   /**
    * 搜索技能（模糊匹配）
@@ -226,7 +256,7 @@ var BuiltInSkillRegistry = class {
 var skillToolSchema = import_zod.z.object({
   name: import_zod.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.",
@@ -247,10 +277,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`);
       }
@@ -264,14 +294,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)`);
   }
 };
@@ -382,6 +419,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 {
@@ -504,25 +561,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));
   }
@@ -659,21 +697,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);
@@ -683,10 +718,397 @@ var builtInPlanModePlugin = {
   }
 };
 
+// src/built-in/task-tracking-plugin/index.ts
+var import_fs3 = require("fs");
+var import_path = __toESM(require("path"), 1);
+var import_os2 = require("os");
+var import_crypto = require("crypto");
+var import_zod2 = require("zod");
+var TASK_STATUSES = ["pending", "in_progress", "completed", "blocked"];
+var CREATE_TASK_ITEM_SCHEMA = import_zod2.z.object({
+  title: import_zod2.z.string().min(1).describe("Task title"),
+  details: import_zod2.z.string().optional().describe("Task details / acceptance notes"),
+  status: import_zod2.z.enum(TASK_STATUSES).optional().describe("Initial status; defaults to pending"),
+  dependencies: import_zod2.z.array(import_zod2.z.string()).optional().describe("Task IDs that must be completed first"),
+  blockedReason: import_zod2.z.string().optional().describe("Reason when status is blocked"),
+  metadata: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.any()).optional().describe("Additional machine-readable metadata")
+});
+var TASK_CREATE_INPUT_SCHEMA = import_zod2.z.object({
+  title: import_zod2.z.string().min(1).optional().describe("Task title (single-task mode)"),
+  details: import_zod2.z.string().optional().describe("Task details (single-task mode)"),
+  status: import_zod2.z.enum(TASK_STATUSES).optional().describe("Initial status (single-task mode)"),
+  dependencies: import_zod2.z.array(import_zod2.z.string()).optional().describe("Dependencies (single-task mode)"),
+  blockedReason: import_zod2.z.string().optional().describe("Blocked reason (single-task mode)"),
+  metadata: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.any()).optional().describe("Metadata (single-task mode)"),
+  tasks: import_zod2.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_zod2.z.object({
+  id: import_zod2.z.string().min(1).describe("Task ID to retrieve")
+});
+var TASK_LIST_INPUT_SCHEMA = import_zod2.z.object({
+  statuses: import_zod2.z.array(import_zod2.z.enum(TASK_STATUSES)).optional().describe("Filter by statuses"),
+  includeCompleted: import_zod2.z.boolean().optional().describe("Set false to hide completed tasks"),
+  limit: import_zod2.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_zod2.z.object({
+  id: import_zod2.z.string().min(1).describe("Task ID to update"),
+  title: import_zod2.z.string().min(1).optional().describe("New title"),
+  details: import_zod2.z.string().optional().describe("New details"),
+  status: import_zod2.z.enum(TASK_STATUSES).optional().describe("New status"),
+  dependencies: import_zod2.z.array(import_zod2.z.string()).optional().describe("Replace dependencies with this list"),
+  blockedReason: import_zod2.z.string().optional().describe("Blocked reason, used with status=blocked"),
+  metadata: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.any()).optional().describe("Replace metadata object"),
+  delete: import_zod2.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_path.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_path.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_crypto.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_path.default.join(this.storageDir, `${normalized}.json`);
+    await import_fs3.promises.mkdir(this.storageDir, { recursive: true });
+    try {
+      const raw = await import_fs3.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_fs3.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_zod10 = require("zod");
-var import_fs9 = require("fs");
-var import_path3 = __toESM(require("path"), 1);
+var import_zod11 = require("zod");
+var import_fs10 = require("fs");
+var import_path4 = __toESM(require("path"), 1);
 
 // src/ai/index.ts
 var import_ai = require("ai");
@@ -718,8 +1140,8 @@ var CLARIFICATION_TIMEOUT = Number(process.env.CLARIFICATION_TIMEOUT ?? 3e5);
 var CLARIFICATION_ENABLED = process.env.CLARIFICATION_ENABLED !== "false";
 
 // src/prompt/system.ts
-var import_fs3 = __toESM(require("fs"), 1);
-var import_path = __toESM(require("path"), 1);
+var import_fs4 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
 var DEFAULT_PROMPT = `
 You are Pulse Coder, the best coding agent on the planet.
 
@@ -855,13 +1277,13 @@ var AGENTS_FILE_REGEX = /^agents\.md$/i;
 var loadAgentsPrompt = () => {
   try {
     const cwd = process.cwd();
-    const entries = import_fs3.default.readdirSync(cwd, { withFileTypes: true });
+    const entries = import_fs4.default.readdirSync(cwd, { withFileTypes: true });
     const target = entries.find((entry) => entry.isFile() && AGENTS_FILE_REGEX.test(entry.name));
     if (!target) {
       return null;
     }
-    const filePath = import_path.default.join(cwd, target.name);
-    const content = import_fs3.default.readFileSync(filePath, "utf8").trim();
+    const filePath = import_path2.default.join(cwd, target.name);
+    const content = import_fs4.default.readFileSync(filePath, "utf8").trim();
     return content.length > 0 ? content : null;
   } catch {
     return null;
@@ -1047,15 +1469,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;
       }
     };
   }
@@ -1065,6 +1500,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) {
@@ -1081,8 +1517,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,
@@ -1093,7 +1545,7 @@ async function loop(context, options) {
         toolExecutionContext,
         provider: options?.provider,
         model: options?.model,
-        systemPrompt: options?.systemPrompt,
+        systemPrompt,
         onStepFinish: (step) => {
           options?.onStepFinish?.(step);
         },
@@ -1121,6 +1573,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.";
       }
@@ -1180,8 +1637,8 @@ function sleep(ms) {
 }
 
 // src/tools/read.ts
-var import_zod2 = __toESM(require("zod"), 1);
-var import_fs4 = require("fs");
+var import_zod3 = __toESM(require("zod"), 1);
+var import_fs5 = require("fs");
 
 // src/tools/utils.ts
 var truncateOutput = (output) => {
@@ -1201,20 +1658,20 @@ var truncateOutput = (output) => {
 var ReadTool = {
   name: "read",
   description: "Read the contents of a file. Supports reading specific line ranges with offset and limit.",
-  inputSchema: import_zod2.default.object({
-    filePath: import_zod2.default.string().describe("The absolute path to the file to read"),
-    offset: import_zod2.default.number().optional().describe("The line number to start reading from (0-based). Only provide if the file is too large to read at once."),
-    limit: import_zod2.default.number().optional().describe("The number of lines to read. Only provide if the file is too large to read at once.")
+  inputSchema: import_zod3.default.object({
+    filePath: import_zod3.default.string().describe("The absolute path to the file to read"),
+    offset: import_zod3.default.number().optional().describe("The line number to start reading from (0-based). Only provide if the file is too large to read at once."),
+    limit: import_zod3.default.number().optional().describe("The number of lines to read. Only provide if the file is too large to read at once.")
   }),
   execute: async ({ filePath, offset, limit }) => {
-    if (!(0, import_fs4.existsSync)(filePath)) {
+    if (!(0, import_fs5.existsSync)(filePath)) {
       throw new Error(`File does not exist: ${filePath}`);
     }
-    const stats = (0, import_fs4.statSync)(filePath);
+    const stats = (0, import_fs5.statSync)(filePath);
     if (stats.isDirectory()) {
       throw new Error(`Cannot read directory: ${filePath}. Use 'ls' tool to list directory contents.`);
     }
-    const content = (0, import_fs4.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs5.readFileSync)(filePath, "utf-8");
     const lines = content.split("\n");
     const totalLines = lines.length;
     if (offset === void 0 && limit === void 0) {
@@ -1241,23 +1698,23 @@ var ReadTool = {
 };
 
 // src/tools/write.ts
-var import_zod3 = __toESM(require("zod"), 1);
-var import_fs5 = require("fs");
-var import_path2 = require("path");
+var import_zod4 = __toESM(require("zod"), 1);
+var import_fs6 = require("fs");
+var import_path3 = require("path");
 var WriteTool = {
   name: "write",
   description: "Write contents to a file. Automatically creates parent directories if they do not exist. Will overwrite existing files.",
-  inputSchema: import_zod3.default.object({
-    filePath: import_zod3.default.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
-    content: import_zod3.default.string().describe("The content to write to the file")
+  inputSchema: import_zod4.default.object({
+    filePath: import_zod4.default.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
+    content: import_zod4.default.string().describe("The content to write to the file")
   }),
   execute: async ({ filePath, content }) => {
-    const fileExists = (0, import_fs5.existsSync)(filePath);
-    const dir = (0, import_path2.dirname)(filePath);
-    if (!(0, import_fs5.existsSync)(dir)) {
-      (0, import_fs5.mkdirSync)(dir, { recursive: true });
+    const fileExists = (0, import_fs6.existsSync)(filePath);
+    const dir = (0, import_path3.dirname)(filePath);
+    if (!(0, import_fs6.existsSync)(dir)) {
+      (0, import_fs6.mkdirSync)(dir, { recursive: true });
     }
-    (0, import_fs5.writeFileSync)(filePath, content, "utf-8");
+    (0, import_fs6.writeFileSync)(filePath, content, "utf-8");
     const bytes = Buffer.byteLength(content, "utf-8");
     return {
       success: true,
@@ -1268,22 +1725,22 @@ var WriteTool = {
 };
 
 // src/tools/edit.ts
-var import_zod4 = __toESM(require("zod"), 1);
-var import_fs6 = require("fs");
+var import_zod5 = __toESM(require("zod"), 1);
+var import_fs7 = require("fs");
 var EditTool = {
   name: "edit",
   description: "Performs exact string replacements in files. Use this to edit existing files by replacing old_string with new_string.",
-  inputSchema: import_zod4.default.object({
-    filePath: import_zod4.default.string().describe("The absolute path to the file to modify"),
-    oldString: import_zod4.default.string().describe("The exact text to replace (must match exactly)"),
-    newString: import_zod4.default.string().describe("The text to replace it with (must be different from old_string)"),
-    replaceAll: import_zod4.default.boolean().optional().default(false).describe("Replace all occurrences of old_string (default false)")
+  inputSchema: import_zod5.default.object({
+    filePath: import_zod5.default.string().describe("The absolute path to the file to modify"),
+    oldString: import_zod5.default.string().describe("The exact text to replace (must match exactly)"),
+    newString: import_zod5.default.string().describe("The text to replace it with (must be different from old_string)"),
+    replaceAll: import_zod5.default.boolean().optional().default(false).describe("Replace all occurrences of old_string (default false)")
   }),
   execute: async ({ filePath, oldString, newString, replaceAll = false }) => {
     if (oldString === newString) {
       throw new Error("old_string and new_string must be different");
     }
-    const content = (0, import_fs6.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs7.readFileSync)(filePath, "utf-8");
     if (!content.includes(oldString)) {
       throw new Error(`old_string not found in file: ${filePath}`);
     }
@@ -1307,7 +1764,7 @@ var EditTool = {
       newContent = content.slice(0, index) + newString + content.slice(index + oldString.length);
       replacements = 1;
     }
-    (0, import_fs6.writeFileSync)(filePath, newContent, "utf-8");
+    (0, import_fs7.writeFileSync)(filePath, newContent, "utf-8");
     const changedIndex = newContent.indexOf(newString);
     const contextLength = 200;
     const start = Math.max(0, changedIndex - contextLength);
@@ -1324,27 +1781,27 @@ var EditTool = {
 };
 
 // src/tools/grep.ts
-var import_zod5 = __toESM(require("zod"), 1);
+var import_zod6 = __toESM(require("zod"), 1);
 var import_child_process = require("child_process");
-var import_fs7 = require("fs");
+var import_fs8 = require("fs");
 var GrepTool = {
   name: "grep",
   description: "A powerful search tool built on ripgrep. Supports regex patterns, file filtering, and multiple output modes.",
-  inputSchema: import_zod5.default.object({
-    pattern: import_zod5.default.string().describe("The regular expression pattern to search for in file contents"),
-    path: import_zod5.default.string().optional().describe("File or directory to search in. Defaults to current working directory."),
-    glob: import_zod5.default.string().optional().describe('Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}")'),
-    type: import_zod5.default.string().optional().describe("File type to search (e.g., js, py, rust, go, java, ts, tsx, json, md)"),
-    outputMode: import_zod5.default.enum(["content", "files_with_matches", "count"]).optional().default("files_with_matches").describe('Output mode: "content" shows matching lines, "files_with_matches" shows file paths, "count" shows match counts'),
-    context: import_zod5.default.number().optional().describe('Number of lines to show before and after each match (only with output_mode: "content")'),
-    caseInsensitive: import_zod5.default.boolean().optional().default(false).describe("Case insensitive search"),
-    headLimit: import_zod5.default.number().optional().default(0).describe("Limit output to first N lines/entries. 0 means unlimited."),
-    offset: import_zod5.default.number().optional().default(0).describe("Skip first N lines/entries before applying head_limit"),
-    multiline: import_zod5.default.boolean().optional().default(false).describe("Enable multiline mode where patterns can span lines")
+  inputSchema: import_zod6.default.object({
+    pattern: import_zod6.default.string().describe("The regular expression pattern to search for in file contents"),
+    path: import_zod6.default.string().optional().describe("File or directory to search in. Defaults to current working directory."),
+    glob: import_zod6.default.string().optional().describe('Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}")'),
+    type: import_zod6.default.string().optional().describe("File type to search (e.g., js, py, rust, go, java, ts, tsx, json, md)"),
+    outputMode: import_zod6.default.enum(["content", "files_with_matches", "count"]).optional().default("files_with_matches").describe('Output mode: "content" shows matching lines, "files_with_matches" shows file paths, "count" shows match counts'),
+    context: import_zod6.default.number().optional().describe('Number of lines to show before and after each match (only with output_mode: "content")'),
+    caseInsensitive: import_zod6.default.boolean().optional().default(false).describe("Case insensitive search"),
+    headLimit: import_zod6.default.number().optional().default(0).describe("Limit output to first N lines/entries. 0 means unlimited."),
+    offset: import_zod6.default.number().optional().default(0).describe("Skip first N lines/entries before applying head_limit"),
+    multiline: import_zod6.default.boolean().optional().default(false).describe("Enable multiline mode where patterns can span lines")
   }),
   execute: async ({
     pattern,
-    path: path4 = ".",
+    path: path5 = ".",
     glob,
     type,
     outputMode = "files_with_matches",
@@ -1379,11 +1836,11 @@ var GrepTool = {
     if (type) {
       args.push("--type", type);
     }
-    if (path4 && path4 !== ".") {
-      if (!(0, import_fs7.existsSync)(path4)) {
-        throw new Error(`Path does not exist: ${path4}`);
+    if (path5 && path5 !== ".") {
+      if (!(0, import_fs8.existsSync)(path5)) {
+        throw new Error(`Path does not exist: ${path5}`);
       }
-      args.push(path4);
+      args.push(path5);
     }
     let command = args.map((arg) => {
       if (arg.includes(" ") || arg.includes("$") || arg.includes("*")) {
@@ -1430,31 +1887,31 @@ Command: ${command}`
 };
 
 // src/tools/ls.ts
-var import_zod6 = __toESM(require("zod"), 1);
-var import_fs8 = require("fs");
+var import_zod7 = __toESM(require("zod"), 1);
+var import_fs9 = require("fs");
 var LsTool = {
   name: "ls",
   description: "List files and directories in a given path",
-  inputSchema: import_zod6.default.object({
-    path: import_zod6.default.string().optional().describe("The path to list files from (defaults to current directory)")
+  inputSchema: import_zod7.default.object({
+    path: import_zod7.default.string().optional().describe("The path to list files from (defaults to current directory)")
   }),
-  execute: async ({ path: path4 = "." }) => {
-    const files = (0, import_fs8.readdirSync)(path4);
+  execute: async ({ path: path5 = "." }) => {
+    const files = (0, import_fs9.readdirSync)(path5);
     return { files };
   }
 };
 
 // src/tools/bash.ts
-var import_zod7 = __toESM(require("zod"), 1);
+var import_zod8 = __toESM(require("zod"), 1);
 var import_child_process2 = require("child_process");
 var BashTool = {
   name: "bash",
   description: "Execute a bash command and return the output. Supports timeout and working directory configuration.",
-  inputSchema: import_zod7.default.object({
-    command: import_zod7.default.string().describe("The bash command to execute"),
-    timeout: import_zod7.default.number().optional().describe("Optional timeout in milliseconds (max 600000ms / 10 minutes). Defaults to 120000ms (2 minutes)."),
-    cwd: import_zod7.default.string().optional().describe("Optional working directory for command execution. Defaults to current directory."),
-    description: import_zod7.default.string().optional().describe("Optional description of what this command does (for logging/debugging)")
+  inputSchema: import_zod8.default.object({
+    command: import_zod8.default.string().describe("The bash command to execute"),
+    timeout: import_zod8.default.number().optional().describe("Optional timeout in milliseconds (max 600000ms / 10 minutes). Defaults to 120000ms (2 minutes)."),
+    cwd: import_zod8.default.string().optional().describe("Optional working directory for command execution. Defaults to current directory."),
+    description: import_zod8.default.string().optional().describe("Optional description of what this command does (for logging/debugging)")
   }),
   execute: async ({ command, timeout = 12e4, cwd, description }) => {
     if (timeout && (timeout < 0 || timeout > 6e5)) {
@@ -1495,13 +1952,13 @@ ${stderr}`),
 };
 
 // src/tools/tavily.ts
-var import_zod8 = __toESM(require("zod"), 1);
+var import_zod9 = __toESM(require("zod"), 1);
 var TavilyTool = {
   name: "tavily",
   description: "Search the web using Tavily API",
-  inputSchema: import_zod8.default.object({
-    query: import_zod8.default.string().describe("The search query"),
-    maxResults: import_zod8.default.number().optional().default(5).describe("Maximum number of results to return")
+  inputSchema: import_zod9.default.object({
+    query: import_zod9.default.string().describe("The search query"),
+    maxResults: import_zod9.default.number().optional().default(5).describe("Maximum number of results to return")
   }),
   execute: async ({ query, maxResults = 5 }) => {
     const apiKey = process.env.TAVILY_API_KEY;
@@ -1539,23 +1996,23 @@ var TavilyTool = {
 };
 
 // src/tools/clarify.ts
-var import_zod9 = __toESM(require("zod"), 1);
-var import_crypto = require("crypto");
+var import_zod10 = __toESM(require("zod"), 1);
+var import_crypto2 = require("crypto");
 var ClarifyTool = {
   name: "clarify",
   description: "Ask the user a clarifying question and wait for their response. Use this when you need information from the user to proceed with the task.",
-  inputSchema: import_zod9.default.object({
-    question: import_zod9.default.string().describe("The question to ask the user"),
-    context: import_zod9.default.string().optional().describe("Additional context to help the user answer"),
-    defaultAnswer: import_zod9.default.string().optional().describe("Default answer if user does not respond within timeout"),
-    timeout: import_zod9.default.number().optional().describe("Timeout in milliseconds (default: 5 minutes)")
+  inputSchema: import_zod10.default.object({
+    question: import_zod10.default.string().describe("The question to ask the user"),
+    context: import_zod10.default.string().optional().describe("Additional context to help the user answer"),
+    defaultAnswer: import_zod10.default.string().optional().describe("Default answer if user does not respond within timeout"),
+    timeout: import_zod10.default.number().optional().describe("Timeout in milliseconds (default: 5 minutes)")
   }),
   execute: async (input, toolContext) => {
     if (!toolContext?.onClarificationRequest) {
       throw new Error("Clarification is not supported in this context. The clarify tool requires a CLI interface with user interaction.");
     }
     const timeout = input.timeout ?? CLARIFICATION_TIMEOUT;
-    const requestId = (0, import_crypto.randomUUID)();
+    const requestId = (0, import_crypto2.randomUUID)();
     try {
       const timeoutPromise = new Promise((_, reject) => {
         setTimeout(() => {
@@ -1610,8 +2067,8 @@ var ConfigLoader = class {
     const fileInfos = [];
     for (let configDir of configDirs) {
       try {
-        await import_fs9.promises.access(configDir);
-        const files = await import_fs9.promises.readdir(configDir);
+        await import_fs10.promises.access(configDir);
+        const files = await import_fs10.promises.readdir(configDir);
         fileInfos.push({ files, configDir });
       } catch {
         continue;
@@ -1628,7 +2085,7 @@ var ConfigLoader = class {
         const files = fileInfo.files;
         for (const file of files) {
           if (file.endsWith(".md")) {
-            const config = await this.parseConfig(import_path3.default.join(fileInfo.configDir, file));
+            const config = await this.parseConfig(import_path4.default.join(fileInfo.configDir, file));
             if (config) configs.push(config);
           }
         }
@@ -1640,7 +2097,7 @@ var ConfigLoader = class {
   }
   async parseConfig(filePath) {
     try {
-      const content = await import_fs9.promises.readFile(filePath, "utf-8");
+      const content = await import_fs10.promises.readFile(filePath, "utf-8");
       const lines = content.split("\n");
       let name = "";
       let description = "";
@@ -1669,7 +2126,7 @@ var ConfigLoader = class {
         }
       }
       if (!name) {
-        name = import_path3.default.basename(filePath, ".md");
+        name = import_path4.default.basename(filePath, ".md");
       }
       return {
         name: name.trim(),
@@ -1720,9 +2177,9 @@ var SubAgentPlugin = class {
     const toolName = `${config.name}_agent`;
     const tool2 = {
       description: config.description,
-      inputSchema: import_zod10.z.object({
-        task: import_zod10.z.string().describe("\u8981\u6267\u884C\u7684\u4EFB\u52A1\u63CF\u8FF0"),
-        context: import_zod10.z.any().optional().describe("\u4EFB\u52A1\u4E0A\u4E0B\u6587\u4FE1\u606F")
+      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")
       }),
       execute: async ({ task, context: taskContext }) => {
         const tools = { ...BuiltinToolsMap, ...context.getTools() };
@@ -1749,6 +2206,7 @@ var builtInPlugins = [
   builtInMCPPlugin,
   builtInSkillsPlugin,
   builtInPlanModePlugin,
+  builtInTaskTrackingPlugin,
   new SubAgentPlugin()
 ];
 var built_in_default = builtInPlugins;
@@ -1757,9 +2215,11 @@ var built_in_default = builtInPlugins;
   BuiltInPlanModeService,
   BuiltInSkillRegistry,
   SubAgentPlugin,
+  TaskListService,
   builtInMCPPlugin,
   builtInPlanModePlugin,
   builtInPlugins,
-  builtInSkillsPlugin
+  builtInSkillsPlugin,
+  builtInTaskTrackingPlugin
 });
 //# sourceMappingURL=index.cjs.map