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

package/dist/built-in/index.js

@@ -159,16 +159,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);
   }
   /**
    * 搜索技能（模糊匹配）
@@ -183,7 +211,7 @@ var BuiltInSkillRegistry = class {
 var skillToolSchema = z.object({
   name: 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.",
@@ -204,10 +232,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`);
       }
@@ -221,14 +249,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)`);
   }
 };
@@ -339,6 +374,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 {
@@ -461,25 +516,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));
   }
@@ -616,21 +652,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);
@@ -640,10 +673,397 @@ var builtInPlanModePlugin = {
   }
 };
 
+// src/built-in/task-tracking-plugin/index.ts
+import { promises as fs } from "fs";
+import path2 from "path";
+import { homedir as homedir2 } from "os";
+import { randomUUID } from "crypto";
+import { z as z2 } from "zod";
+var TASK_STATUSES = ["pending", "in_progress", "completed", "blocked"];
+var CREATE_TASK_ITEM_SCHEMA = z2.object({
+  title: z2.string().min(1).describe("Task title"),
+  details: z2.string().optional().describe("Task details / acceptance notes"),
+  status: z2.enum(TASK_STATUSES).optional().describe("Initial status; defaults to pending"),
+  dependencies: z2.array(z2.string()).optional().describe("Task IDs that must be completed first"),
+  blockedReason: z2.string().optional().describe("Reason when status is blocked"),
+  metadata: z2.record(z2.string(), z2.any()).optional().describe("Additional machine-readable metadata")
+});
+var TASK_CREATE_INPUT_SCHEMA = z2.object({
+  title: z2.string().min(1).optional().describe("Task title (single-task mode)"),
+  details: z2.string().optional().describe("Task details (single-task mode)"),
+  status: z2.enum(TASK_STATUSES).optional().describe("Initial status (single-task mode)"),
+  dependencies: z2.array(z2.string()).optional().describe("Dependencies (single-task mode)"),
+  blockedReason: z2.string().optional().describe("Blocked reason (single-task mode)"),
+  metadata: z2.record(z2.string(), z2.any()).optional().describe("Metadata (single-task mode)"),
+  tasks: z2.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 = z2.object({
+  id: z2.string().min(1).describe("Task ID to retrieve")
+});
+var TASK_LIST_INPUT_SCHEMA = z2.object({
+  statuses: z2.array(z2.enum(TASK_STATUSES)).optional().describe("Filter by statuses"),
+  includeCompleted: z2.boolean().optional().describe("Set false to hide completed tasks"),
+  limit: z2.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 = z2.object({
+  id: z2.string().min(1).describe("Task ID to update"),
+  title: z2.string().min(1).optional().describe("New title"),
+  details: z2.string().optional().describe("New details"),
+  status: z2.enum(TASK_STATUSES).optional().describe("New status"),
+  dependencies: z2.array(z2.string()).optional().describe("Replace dependencies with this list"),
+  blockedReason: z2.string().optional().describe("Blocked reason, used with status=blocked"),
+  metadata: z2.record(z2.string(), z2.any()).optional().describe("Replace metadata object"),
+  delete: z2.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 = path2.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 || path2.join(homedir2(), ".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: 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 = path2.join(this.storageDir, `${normalized}.json`);
+    await fs.mkdir(this.storageDir, { recursive: true });
+    try {
+      const raw = await fs.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 fs.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
-import { z as z10 } from "zod";
-import { promises as fs2 } from "fs";
-import path3 from "path";
+import { z as z11 } from "zod";
+import { promises as fs3 } from "fs";
+import path4 from "path";
 
 // src/ai/index.ts
 import { generateText, streamText } from "ai";
@@ -675,8 +1095,8 @@ var CLARIFICATION_TIMEOUT = Number(process.env.CLARIFICATION_TIMEOUT ?? 3e5);
 var CLARIFICATION_ENABLED = process.env.CLARIFICATION_ENABLED !== "false";
 
 // src/prompt/system.ts
-import fs from "fs";
-import path2 from "path";
+import fs2 from "fs";
+import path3 from "path";
 var DEFAULT_PROMPT = `
 You are Pulse Coder, the best coding agent on the planet.
 
@@ -812,13 +1232,13 @@ var AGENTS_FILE_REGEX = /^agents\.md$/i;
 var loadAgentsPrompt = () => {
   try {
     const cwd = process.cwd();
-    const entries = fs.readdirSync(cwd, { withFileTypes: true });
+    const entries = fs2.readdirSync(cwd, { withFileTypes: true });
     const target = entries.find((entry) => entry.isFile() && AGENTS_FILE_REGEX.test(entry.name));
     if (!target) {
       return null;
     }
-    const filePath = path2.join(cwd, target.name);
-    const content = fs.readFileSync(filePath, "utf8").trim();
+    const filePath = path3.join(cwd, target.name);
+    const content = fs2.readFileSync(filePath, "utf8").trim();
     return content.length > 0 ? content : null;
   } catch {
     return null;
@@ -1004,15 +1424,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;
       }
     };
   }
@@ -1022,6 +1455,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) {
@@ -1038,8 +1472,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,
@@ -1050,7 +1500,7 @@ async function loop(context, options) {
         toolExecutionContext,
         provider: options?.provider,
         model: options?.model,
-        systemPrompt: options?.systemPrompt,
+        systemPrompt,
         onStepFinish: (step) => {
           options?.onStepFinish?.(step);
         },
@@ -1078,6 +1528,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.";
       }
@@ -1137,8 +1592,8 @@ function sleep(ms) {
 }
 
 // src/tools/read.ts
-import z2 from "zod";
-import { readFileSync as readFileSync3, existsSync as existsSync3, statSync } from "fs";
+import z3 from "zod";
+import { readFileSync as readFileSync3, existsSync as existsSync2, statSync } from "fs";
 
 // src/tools/utils.ts
 var truncateOutput = (output) => {
@@ -1158,13 +1613,13 @@ var truncateOutput = (output) => {
 var ReadTool = {
   name: "read",
   description: "Read the contents of a file. Supports reading specific line ranges with offset and limit.",
-  inputSchema: z2.object({
-    filePath: z2.string().describe("The absolute path to the file to read"),
-    offset: z2.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: z2.number().optional().describe("The number of lines to read. Only provide if the file is too large to read at once.")
+  inputSchema: z3.object({
+    filePath: z3.string().describe("The absolute path to the file to read"),
+    offset: z3.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: z3.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 (!existsSync3(filePath)) {
+    if (!existsSync2(filePath)) {
       throw new Error(`File does not exist: ${filePath}`);
     }
     const stats = statSync(filePath);
@@ -1198,20 +1653,20 @@ var ReadTool = {
 };
 
 // src/tools/write.ts
-import z3 from "zod";
-import { writeFileSync, mkdirSync, existsSync as existsSync4 } from "fs";
+import z4 from "zod";
+import { writeFileSync, mkdirSync, existsSync as existsSync3 } from "fs";
 import { dirname } from "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: z3.object({
-    filePath: z3.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
-    content: z3.string().describe("The content to write to the file")
+  inputSchema: z4.object({
+    filePath: z4.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
+    content: z4.string().describe("The content to write to the file")
   }),
   execute: async ({ filePath, content }) => {
-    const fileExists = existsSync4(filePath);
+    const fileExists = existsSync3(filePath);
     const dir = dirname(filePath);
-    if (!existsSync4(dir)) {
+    if (!existsSync3(dir)) {
       mkdirSync(dir, { recursive: true });
     }
     writeFileSync(filePath, content, "utf-8");
@@ -1225,16 +1680,16 @@ var WriteTool = {
 };
 
 // src/tools/edit.ts
-import z4 from "zod";
+import z5 from "zod";
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "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: z4.object({
-    filePath: z4.string().describe("The absolute path to the file to modify"),
-    oldString: z4.string().describe("The exact text to replace (must match exactly)"),
-    newString: z4.string().describe("The text to replace it with (must be different from old_string)"),
-    replaceAll: z4.boolean().optional().default(false).describe("Replace all occurrences of old_string (default false)")
+  inputSchema: z5.object({
+    filePath: z5.string().describe("The absolute path to the file to modify"),
+    oldString: z5.string().describe("The exact text to replace (must match exactly)"),
+    newString: z5.string().describe("The text to replace it with (must be different from old_string)"),
+    replaceAll: z5.boolean().optional().default(false).describe("Replace all occurrences of old_string (default false)")
   }),
   execute: async ({ filePath, oldString, newString, replaceAll = false }) => {
     if (oldString === newString) {
@@ -1281,27 +1736,27 @@ var EditTool = {
 };
 
 // src/tools/grep.ts
-import z5 from "zod";
+import z6 from "zod";
 import { execSync } from "child_process";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 var GrepTool = {
   name: "grep",
   description: "A powerful search tool built on ripgrep. Supports regex patterns, file filtering, and multiple output modes.",
-  inputSchema: z5.object({
-    pattern: z5.string().describe("The regular expression pattern to search for in file contents"),
-    path: z5.string().optional().describe("File or directory to search in. Defaults to current working directory."),
-    glob: z5.string().optional().describe('Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}")'),
-    type: z5.string().optional().describe("File type to search (e.g., js, py, rust, go, java, ts, tsx, json, md)"),
-    outputMode: z5.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: z5.number().optional().describe('Number of lines to show before and after each match (only with output_mode: "content")'),
-    caseInsensitive: z5.boolean().optional().default(false).describe("Case insensitive search"),
-    headLimit: z5.number().optional().default(0).describe("Limit output to first N lines/entries. 0 means unlimited."),
-    offset: z5.number().optional().default(0).describe("Skip first N lines/entries before applying head_limit"),
-    multiline: z5.boolean().optional().default(false).describe("Enable multiline mode where patterns can span lines")
+  inputSchema: z6.object({
+    pattern: z6.string().describe("The regular expression pattern to search for in file contents"),
+    path: z6.string().optional().describe("File or directory to search in. Defaults to current working directory."),
+    glob: z6.string().optional().describe('Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}")'),
+    type: z6.string().optional().describe("File type to search (e.g., js, py, rust, go, java, ts, tsx, json, md)"),
+    outputMode: z6.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: z6.number().optional().describe('Number of lines to show before and after each match (only with output_mode: "content")'),
+    caseInsensitive: z6.boolean().optional().default(false).describe("Case insensitive search"),
+    headLimit: z6.number().optional().default(0).describe("Limit output to first N lines/entries. 0 means unlimited."),
+    offset: z6.number().optional().default(0).describe("Skip first N lines/entries before applying head_limit"),
+    multiline: z6.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",
@@ -1336,11 +1791,11 @@ var GrepTool = {
     if (type) {
       args.push("--type", type);
     }
-    if (path4 && path4 !== ".") {
-      if (!existsSync5(path4)) {
-        throw new Error(`Path does not exist: ${path4}`);
+    if (path5 && path5 !== ".") {
+      if (!existsSync4(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("*")) {
@@ -1387,31 +1842,31 @@ Command: ${command}`
 };
 
 // src/tools/ls.ts
-import z6 from "zod";
+import z7 from "zod";
 import { readdirSync } from "fs";
 var LsTool = {
   name: "ls",
   description: "List files and directories in a given path",
-  inputSchema: z6.object({
-    path: z6.string().optional().describe("The path to list files from (defaults to current directory)")
+  inputSchema: z7.object({
+    path: z7.string().optional().describe("The path to list files from (defaults to current directory)")
   }),
-  execute: async ({ path: path4 = "." }) => {
-    const files = readdirSync(path4);
+  execute: async ({ path: path5 = "." }) => {
+    const files = readdirSync(path5);
     return { files };
   }
 };
 
 // src/tools/bash.ts
-import z7 from "zod";
+import z8 from "zod";
 import { execSync as execSync2 } from "child_process";
 var BashTool = {
   name: "bash",
   description: "Execute a bash command and return the output. Supports timeout and working directory configuration.",
-  inputSchema: z7.object({
-    command: z7.string().describe("The bash command to execute"),
-    timeout: z7.number().optional().describe("Optional timeout in milliseconds (max 600000ms / 10 minutes). Defaults to 120000ms (2 minutes)."),
-    cwd: z7.string().optional().describe("Optional working directory for command execution. Defaults to current directory."),
-    description: z7.string().optional().describe("Optional description of what this command does (for logging/debugging)")
+  inputSchema: z8.object({
+    command: z8.string().describe("The bash command to execute"),
+    timeout: z8.number().optional().describe("Optional timeout in milliseconds (max 600000ms / 10 minutes). Defaults to 120000ms (2 minutes)."),
+    cwd: z8.string().optional().describe("Optional working directory for command execution. Defaults to current directory."),
+    description: z8.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)) {
@@ -1452,13 +1907,13 @@ ${stderr}`),
 };
 
 // src/tools/tavily.ts
-import z8 from "zod";
+import z9 from "zod";
 var TavilyTool = {
   name: "tavily",
   description: "Search the web using Tavily API",
-  inputSchema: z8.object({
-    query: z8.string().describe("The search query"),
-    maxResults: z8.number().optional().default(5).describe("Maximum number of results to return")
+  inputSchema: z9.object({
+    query: z9.string().describe("The search query"),
+    maxResults: z9.number().optional().default(5).describe("Maximum number of results to return")
   }),
   execute: async ({ query, maxResults = 5 }) => {
     const apiKey = process.env.TAVILY_API_KEY;
@@ -1496,23 +1951,23 @@ var TavilyTool = {
 };
 
 // src/tools/clarify.ts
-import z9 from "zod";
-import { randomUUID } from "crypto";
+import z10 from "zod";
+import { randomUUID as randomUUID2 } from "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: z9.object({
-    question: z9.string().describe("The question to ask the user"),
-    context: z9.string().optional().describe("Additional context to help the user answer"),
-    defaultAnswer: z9.string().optional().describe("Default answer if user does not respond within timeout"),
-    timeout: z9.number().optional().describe("Timeout in milliseconds (default: 5 minutes)")
+  inputSchema: z10.object({
+    question: z10.string().describe("The question to ask the user"),
+    context: z10.string().optional().describe("Additional context to help the user answer"),
+    defaultAnswer: z10.string().optional().describe("Default answer if user does not respond within timeout"),
+    timeout: z10.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 = randomUUID();
+    const requestId = randomUUID2();
     try {
       const timeoutPromise = new Promise((_, reject) => {
         setTimeout(() => {
@@ -1567,8 +2022,8 @@ var ConfigLoader = class {
     const fileInfos = [];
     for (let configDir of configDirs) {
       try {
-        await fs2.access(configDir);
-        const files = await fs2.readdir(configDir);
+        await fs3.access(configDir);
+        const files = await fs3.readdir(configDir);
         fileInfos.push({ files, configDir });
       } catch {
         continue;
@@ -1585,7 +2040,7 @@ var ConfigLoader = class {
         const files = fileInfo.files;
         for (const file of files) {
           if (file.endsWith(".md")) {
-            const config = await this.parseConfig(path3.join(fileInfo.configDir, file));
+            const config = await this.parseConfig(path4.join(fileInfo.configDir, file));
             if (config) configs.push(config);
           }
         }
@@ -1597,7 +2052,7 @@ var ConfigLoader = class {
   }
   async parseConfig(filePath) {
     try {
-      const content = await fs2.readFile(filePath, "utf-8");
+      const content = await fs3.readFile(filePath, "utf-8");
       const lines = content.split("\n");
       let name = "";
       let description = "";
@@ -1626,7 +2081,7 @@ var ConfigLoader = class {
         }
       }
       if (!name) {
-        name = path3.basename(filePath, ".md");
+        name = path4.basename(filePath, ".md");
       }
       return {
         name: name.trim(),
@@ -1677,9 +2132,9 @@ var SubAgentPlugin = class {
     const toolName = `${config.name}_agent`;
     const tool2 = {
       description: config.description,
-      inputSchema: z10.object({
-        task: z10.string().describe("\u8981\u6267\u884C\u7684\u4EFB\u52A1\u63CF\u8FF0"),
-        context: z10.any().optional().describe("\u4EFB\u52A1\u4E0A\u4E0B\u6587\u4FE1\u606F")
+      inputSchema: z11.object({
+        task: z11.string().describe("\u8981\u6267\u884C\u7684\u4EFB\u52A1\u63CF\u8FF0"),
+        context: z11.any().optional().describe("\u4EFB\u52A1\u4E0A\u4E0B\u6587\u4FE1\u606F")
       }),
       execute: async ({ task, context: taskContext }) => {
         const tools = { ...BuiltinToolsMap, ...context.getTools() };
@@ -1706,6 +2161,7 @@ var builtInPlugins = [
   builtInMCPPlugin,
   builtInSkillsPlugin,
   builtInPlanModePlugin,
+  builtInTaskTrackingPlugin,
   new SubAgentPlugin()
 ];
 var built_in_default = builtInPlugins;
@@ -1713,10 +2169,12 @@ export {
   BuiltInPlanModeService,
   BuiltInSkillRegistry,
   SubAgentPlugin,
+  TaskListService,
   builtInMCPPlugin,
   builtInPlanModePlugin,
   builtInPlugins,
   builtInSkillsPlugin,
+  builtInTaskTrackingPlugin,
   built_in_default as default
 };
 //# sourceMappingURL=index.js.map