@probelabs/probe 0.6.0-rc203 → 0.6.0-rc205

package/build/agent/index.js

@@ -3068,6 +3068,222 @@ var init_utils = __esm({
   }
 });
 
+// src/utils/error-types.js
+function escapeXml(str) {
+  return String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function categorizeError(error) {
+  if (error instanceof ProbeError) {
+    return error;
+  }
+  const message = error?.message || String(error);
+  const lowerMessage = message.toLowerCase();
+  const errorCode = error?.code != null ? String(error.code).toLowerCase() : "";
+  if (lowerMessage.includes("path does not exist") || lowerMessage.includes("no such file or directory") || errorCode === "enoent") {
+    return new PathError(message, {
+      originalError: error,
+      suggestion: "The specified path does not exist. Please verify the path or use a different directory."
+    });
+  }
+  if (lowerMessage.includes("not a directory") || errorCode === "enotdir") {
+    return new PathError(message, {
+      originalError: error,
+      suggestion: "The path is not a directory. Please provide a valid directory path."
+    });
+  }
+  if (lowerMessage.includes("permission denied") || errorCode === "eacces") {
+    return new PathError(message, {
+      originalError: error,
+      recoverable: false,
+      suggestion: "Permission denied. This is a system-level restriction that cannot be resolved by changing the query."
+    });
+  }
+  if (lowerMessage.includes("timed out") || lowerMessage.includes("timeout") || errorCode === "etimedout" || error?.killed === true) {
+    return new TimeoutError(message, {
+      originalError: error,
+      suggestion: "The operation timed out. Try a more specific query, reduce the search scope, or increase the timeout."
+    });
+  }
+  const rateLimitPatterns = ["rate_limit", "rate limit", "429", "too many requests", "overloaded"];
+  if (rateLimitPatterns.some((p) => lowerMessage.includes(p))) {
+    return new ApiError(message, {
+      originalError: error,
+      recoverable: true,
+      suggestion: "API rate limit or overload encountered. The system will retry automatically with backoff."
+    });
+  }
+  const serverErrorPatterns = ["500", "502", "503", "504", "internal server error", "bad gateway", "service unavailable"];
+  if (serverErrorPatterns.some((p) => lowerMessage.includes(p))) {
+    return new ApiError(message, {
+      originalError: error,
+      recoverable: true,
+      suggestion: "API server error encountered. The system will retry automatically."
+    });
+  }
+  if ((lowerMessage.includes("context") || lowerMessage.includes("token")) && (lowerMessage.includes("limit") || lowerMessage.includes("exceed"))) {
+    return new ApiError(message, {
+      originalError: error,
+      recoverable: true,
+      suggestion: "Context or token limit exceeded. The conversation may be automatically compacted."
+    });
+  }
+  if (lowerMessage.includes("invalid parameter") || lowerMessage.includes("missing parameter") || lowerMessage.includes("required") || lowerMessage.includes("must be")) {
+    return new ParameterError(message, {
+      originalError: error
+    });
+  }
+  if (lowerMessage.includes("invalid") && (lowerMessage.includes("api") || lowerMessage.includes("key") || lowerMessage.includes("auth"))) {
+    return new ApiError(message, {
+      originalError: error,
+      recoverable: false,
+      suggestion: "API authentication error. Please check the API key configuration."
+    });
+  }
+  if (lowerMessage.includes("delegation failed") || lowerMessage.includes("delegate agent") || lowerMessage.includes("subagent")) {
+    return new DelegationError(message, {
+      originalError: error
+    });
+  }
+  if (errorCode === "econnreset" || errorCode === "econnrefused" || errorCode === "enotfound" || lowerMessage.includes("network") || lowerMessage.includes("connection")) {
+    return new ApiError(message, {
+      originalError: error,
+      recoverable: true,
+      suggestion: "Network error encountered. The system will retry automatically."
+    });
+  }
+  return new ProbeError(message, {
+    category: ErrorCategory.INTERNAL_ERROR,
+    recoverable: false,
+    originalError: error,
+    suggestion: "An unexpected error occurred. Please check the error message for details."
+  });
+}
+function formatErrorForAI(error) {
+  const structuredError = categorizeError(error);
+  return structuredError.toXml();
+}
+var ErrorCategory, ProbeError, PathError, ParameterError, TimeoutError, ApiError, DelegationError;
+var init_error_types = __esm({
+  "src/utils/error-types.js"() {
+    "use strict";
+    ErrorCategory = {
+      PATH_ERROR: "path_error",
+      // Path doesn't exist, not a directory, permission denied
+      PARAMETER_ERROR: "parameter_error",
+      // Invalid parameters provided
+      TIMEOUT_ERROR: "timeout_error",
+      // Operation timed out
+      API_ERROR: "api_error",
+      // AI provider errors (rate limit, token limit)
+      DELEGATION_ERROR: "delegation_error",
+      // Subagent failures
+      INTERNAL_ERROR: "internal_error"
+      // Unexpected system errors
+    };
+    ProbeError = class extends Error {
+      /**
+       * Create a ProbeError
+       * @param {string} message - Error message
+       * @param {Object} options - Options
+       * @param {string} [options.category] - Error category from ErrorCategory
+       * @param {boolean} [options.recoverable] - Whether the error is recoverable by AI action
+       * @param {string} [options.suggestion] - Suggested action for recovery
+       * @param {Object} [options.details] - Additional error details
+       * @param {Error} [options.originalError] - Original error that was wrapped
+       */
+      constructor(message, options = {}) {
+        super(message);
+        this.name = "ProbeError";
+        this.category = options.category || ErrorCategory.INTERNAL_ERROR;
+        this.recoverable = options.recoverable ?? false;
+        this.suggestion = options.suggestion || null;
+        this.details = options.details || {};
+        this.originalError = options.originalError || null;
+      }
+      /**
+       * Format error as XML for AI consumption
+       * @returns {string} - XML-formatted error
+       */
+      toXml() {
+        const parts = [
+          `<error type="${this.category}" recoverable="${this.recoverable}">`,
+          `<message>${escapeXml(this.message)}</message>`
+        ];
+        if (this.suggestion) {
+          parts.push(`<suggestion>${escapeXml(this.suggestion)}</suggestion>`);
+        }
+        if (Object.keys(this.details).length > 0) {
+          parts.push(`<details>${escapeXml(JSON.stringify(this.details))}</details>`);
+        }
+        parts.push("</error>");
+        return parts.join("\n");
+      }
+      /**
+       * Format error for plain text (backward compatible)
+       * @returns {string} - Plain text error
+       */
+      toString() {
+        return `Error: ${this.message}`;
+      }
+    };
+    PathError = class extends ProbeError {
+      constructor(message, options = {}) {
+        super(message, {
+          ...options,
+          category: ErrorCategory.PATH_ERROR,
+          recoverable: options.recoverable ?? true,
+          suggestion: options.suggestion || "Please verify the path exists or try searching in a different directory."
+        });
+        this.name = "PathError";
+      }
+    };
+    ParameterError = class extends ProbeError {
+      constructor(message, options = {}) {
+        super(message, {
+          ...options,
+          category: ErrorCategory.PARAMETER_ERROR,
+          recoverable: options.recoverable ?? true,
+          suggestion: options.suggestion || "Please check and correct the parameter values."
+        });
+        this.name = "ParameterError";
+      }
+    };
+    TimeoutError = class extends ProbeError {
+      constructor(message, options = {}) {
+        super(message, {
+          ...options,
+          category: ErrorCategory.TIMEOUT_ERROR,
+          recoverable: options.recoverable ?? true,
+          suggestion: options.suggestion || "The operation timed out. Try a more specific query or increase the timeout."
+        });
+        this.name = "TimeoutError";
+      }
+    };
+    ApiError = class extends ProbeError {
+      constructor(message, options = {}) {
+        super(message, {
+          ...options,
+          category: ErrorCategory.API_ERROR,
+          recoverable: options.recoverable ?? false,
+          suggestion: options.suggestion || "This is an API provider error. The system will retry automatically if possible."
+        });
+        this.name = "ApiError";
+      }
+    };
+    DelegationError = class extends ProbeError {
+      constructor(message, options = {}) {
+        super(message, {
+          ...options,
+          category: ErrorCategory.DELEGATION_ERROR,
+          recoverable: options.recoverable ?? true,
+          suggestion: options.suggestion || "The delegated task failed. Consider breaking down the task further or trying a different approach."
+        });
+        this.name = "DelegationError";
+      }
+    };
+  }
+});
+
 // src/utils/path-validation.js
 import path4 from "path";
 import { promises as fs5 } from "fs";
@@ -3077,11 +3293,27 @@ async function validateCwdPath(inputPath, defaultPath = process.cwd()) {
   try {
     const stats = await fs5.stat(normalizedPath);
     if (!stats.isDirectory()) {
-      throw new Error(`Path is not a directory: ${normalizedPath}`);
+      throw new PathError(`Path is not a directory: ${normalizedPath}`, {
+        suggestion: "The specified path is a file, not a directory. Please provide a directory path for searching.",
+        details: { path: normalizedPath, type: "file" }
+      });
     }
   } catch (error) {
+    if (error instanceof PathError) {
+      throw error;
+    }
     if (error.code === "ENOENT") {
-      throw new Error(`Path does not exist: ${normalizedPath}`);
+      throw new PathError(`Path does not exist: ${normalizedPath}`, {
+        suggestion: "The specified path does not exist. Please verify the path is correct or use a different directory.",
+        details: { path: normalizedPath }
+      });
+    }
+    if (error.code === "EACCES") {
+      throw new PathError(`Permission denied: ${normalizedPath}`, {
+        recoverable: false,
+        suggestion: "Permission denied accessing this path. This is a system-level restriction.",
+        details: { path: normalizedPath }
+      });
     }
     throw error;
   }
@@ -3090,6 +3322,7 @@ async function validateCwdPath(inputPath, defaultPath = process.cwd()) {
 var init_path_validation = __esm({
   "src/utils/path-validation.js"() {
     "use strict";
+    init_error_types();
   }
 });
 
@@ -3210,18 +3443,25 @@ Search results: ${resultCount} matches, ${tokenCount} tokens`;
     return stdout;
   } catch (error) {
     if (error.code === "ETIMEDOUT" || error.killed) {
-      const timeoutMessage = `Search operation timed out after ${options.timeout} seconds.
-Binary: ${binaryPath}
-Args: ${args.join(" ")}
-Cwd: ${cwd}`;
+      const timeoutMessage = `Search operation timed out after ${options.timeout} seconds`;
       console.error(timeoutMessage);
-      throw new Error(timeoutMessage);
+      throw new TimeoutError(timeoutMessage, {
+        suggestion: "The search operation timed out. Try a more specific query, reduce the search scope, or increase the timeout.",
+        details: {
+          timeout: options.timeout,
+          query: options.query,
+          path: options.path
+        }
+      });
     }
-    const errorMessage = `Error executing search command: ${error.message}
-Binary: ${binaryPath}
-Args: ${args.join(" ")}
-Cwd: ${cwd}`;
-    throw new Error(errorMessage);
+    const structuredError = categorizeError(error);
+    structuredError.details = {
+      ...structuredError.details,
+      binary: binaryPath,
+      args: args.join(" "),
+      cwd
+    };
+    throw structuredError;
   }
 }
 var execFileAsync, SEARCH_FLAG_MAP;
@@ -3230,6 +3470,7 @@ var init_search = __esm({
     "use strict";
     init_utils();
     init_path_validation();
+    init_error_types();
     execFileAsync = promisify2(execFile);
     SEARCH_FLAG_MAP = {
       filesOnly: "--files-only",
@@ -3522,7 +3763,8 @@ async function delegate({
   allowedTools = null,
   disableTools = false,
   searchDelegate = void 0,
-  schema = null
+  schema = null,
+  enableTasks = false
 }) {
   if (!task || typeof task !== "string") {
     throw new Error("Task parameter is required and must be a string");
@@ -3577,7 +3819,9 @@ async function delegate({
       architectureFileName,
       allowedTools,
       disableTools,
-      searchDelegate
+      searchDelegate,
+      enableTasks
+      // Inherit from parent (subagent gets isolated TaskManager)
     });
     if (debug) {
       console.error(`[DELEGATE] Created subagent with session ${sessionId}`);
@@ -8202,6 +8446,439 @@ This is a new project.</content>
   }
 });
 
+// src/agent/tasks/taskTool.js
+function createTaskCompletionBlockedMessage(taskSummary) {
+  return `<task_completion_blocked>
+You cannot complete yet. The following tasks are still unresolved:
+
+${taskSummary}
+
+Required action:
+1. For each "pending" or "in_progress" task, either:
+   - Complete the work and mark it: <task><action>complete</action><id>task-X</id></task>
+   - Or cancel if no longer needed: <task><action>update</action><id>task-X</id><status>cancelled</status></task>
+
+2. After ALL tasks are resolved (completed or cancelled), call attempt_completion again.
+
+Use <task><action>list</action></task> to review current status.
+</task_completion_blocked>`;
+}
+function createTaskTool(options = {}) {
+  const { taskManager, tracer, debug = false } = options;
+  if (!taskManager) {
+    throw new Error("TaskManager instance is required");
+  }
+  const recordTaskEvent = (eventType, data = {}) => {
+    if (tracer && typeof tracer.recordTaskEvent === "function") {
+      tracer.recordTaskEvent(eventType, data);
+    }
+  };
+  return {
+    name: "task",
+    description: "Manage tasks for tracking progress during code exploration",
+    parameters: taskSchema,
+    /**
+     * Execute task action
+     * @param {Object} params - Tool parameters
+     * @returns {string} Result message
+     */
+    execute: async (params) => {
+      try {
+        const validation = taskSchema.safeParse(params);
+        if (!validation.success) {
+          recordTaskEvent("validation_error", {
+            "task.error": validation.error.message
+          });
+          return `Error: Invalid task parameters - ${validation.error.message}`;
+        }
+        const { action, tasks, id, title, description, status, priority, dependencies, after } = validation.data;
+        switch (action) {
+          case "create": {
+            if (tasks && Array.isArray(tasks)) {
+              const created = taskManager.createTasks(tasks);
+              const ids = created.map((t) => t.id).join(", ");
+              recordTaskEvent("batch_created", {
+                "task.action": "create",
+                "task.count": created.length,
+                "task.ids": ids,
+                "task.total_count": taskManager.listTasks().length
+              });
+              return `Created ${created.length} tasks: ${ids}
+
+${taskManager.formatTasksForPrompt()}`;
+            } else if (title) {
+              const task = taskManager.createTask({ title, description, priority, dependencies, after });
+              recordTaskEvent("created", {
+                "task.action": "create",
+                "task.id": task.id,
+                "task.title": title,
+                "task.priority": priority || "none",
+                "task.has_dependencies": dependencies && dependencies.length > 0,
+                "task.after": after || "none",
+                "task.total_count": taskManager.listTasks().length
+              });
+              return `Created task ${task.id}: ${task.title}
+
+${taskManager.formatTasksForPrompt()}`;
+            } else {
+              return 'Error: Create action requires either "tasks" array or "title" parameter';
+            }
+          }
+          case "update": {
+            if (tasks && Array.isArray(tasks)) {
+              const updated = taskManager.updateTasks(tasks);
+              const ids = updated.map((t) => t.id).join(", ");
+              recordTaskEvent("batch_updated", {
+                "task.action": "update",
+                "task.count": updated.length,
+                "task.ids": ids
+              });
+              return `Updated ${updated.length} tasks: ${ids}
+
+${taskManager.formatTasksForPrompt()}`;
+            } else if (id) {
+              const updates = {};
+              if (status) updates.status = status;
+              if (title) updates.title = title;
+              if (description) updates.description = description;
+              if (priority) updates.priority = priority;
+              if (dependencies) updates.dependencies = dependencies;
+              const task = taskManager.updateTask(id, updates);
+              recordTaskEvent("updated", {
+                "task.action": "update",
+                "task.id": id,
+                "task.new_status": status || "unchanged",
+                "task.fields_updated": Object.keys(updates).join(", ")
+              });
+              return `Updated task ${task.id}
+
+${taskManager.formatTasksForPrompt()}`;
+            } else {
+              return 'Error: Update action requires either "tasks" array or "id" parameter';
+            }
+          }
+          case "complete": {
+            if (tasks && Array.isArray(tasks)) {
+              const ids = tasks.map((t, index) => {
+                if (typeof t === "string") return t;
+                if (t && typeof t.id === "string") return t.id;
+                throw new Error(`Invalid task item at index ${index}: must be a string ID or object with 'id' property`);
+              });
+              const completed = taskManager.completeTasks(ids);
+              recordTaskEvent("batch_completed", {
+                "task.action": "complete",
+                "task.count": completed.length,
+                "task.ids": ids.join(", "),
+                "task.incomplete_remaining": taskManager.getIncompleteTasks().length
+              });
+              return `Completed ${completed.length} tasks
+
+${taskManager.formatTasksForPrompt()}`;
+            } else if (id) {
+              const task = taskManager.completeTask(id);
+              recordTaskEvent("completed", {
+                "task.action": "complete",
+                "task.id": id,
+                "task.title": task.title,
+                "task.incomplete_remaining": taskManager.getIncompleteTasks().length
+              });
+              return `Completed task ${task.id}: ${task.title}
+
+${taskManager.formatTasksForPrompt()}`;
+            } else {
+              return 'Error: Complete action requires either "tasks" array or "id" parameter';
+            }
+          }
+          case "delete": {
+            if (tasks && Array.isArray(tasks)) {
+              const ids = tasks.map((t, index) => {
+                if (typeof t === "string") return t;
+                if (t && typeof t.id === "string") return t.id;
+                throw new Error(`Invalid task item at index ${index}: must be a string ID or object with 'id' property`);
+              });
+              const deleted = taskManager.deleteTasks(ids);
+              recordTaskEvent("batch_deleted", {
+                "task.action": "delete",
+                "task.count": deleted.length,
+                "task.ids": deleted.join(", "),
+                "task.total_count": taskManager.listTasks().length
+              });
+              return `Deleted ${deleted.length} tasks: ${deleted.join(", ")}
+
+${taskManager.formatTasksForPrompt()}`;
+            } else if (id) {
+              taskManager.deleteTask(id);
+              recordTaskEvent("deleted", {
+                "task.action": "delete",
+                "task.id": id,
+                "task.total_count": taskManager.listTasks().length
+              });
+              return `Deleted task ${id}
+
+${taskManager.formatTasksForPrompt()}`;
+            } else {
+              return 'Error: Delete action requires either "tasks" array or "id" parameter';
+            }
+          }
+          case "list": {
+            const allTasks = taskManager.listTasks();
+            const incomplete = taskManager.getIncompleteTasks();
+            recordTaskEvent("listed", {
+              "task.action": "list",
+              "task.total_count": allTasks.length,
+              "task.incomplete_count": incomplete.length,
+              "task.completed_count": allTasks.length - incomplete.length
+            });
+            return taskManager.formatTasksForPrompt();
+          }
+          default:
+            recordTaskEvent("unknown_action", {
+              "task.action": action
+            });
+            return `Error: Unknown action "${action}". Valid actions: create, update, complete, delete, list`;
+        }
+      } catch (error) {
+        recordTaskEvent("error", {
+          "task.error": error.message,
+          "task.action": params?.action || "unknown"
+        });
+        if (debug) {
+          console.error("[TaskTool] Error:", error);
+        }
+        return `Error: ${error.message}`;
+      }
+    }
+  };
+}
+var taskItemSchema, taskSchema, taskToolDefinition, taskSystemPrompt, taskGuidancePrompt;
+var init_taskTool = __esm({
+  "src/agent/tasks/taskTool.js"() {
+    "use strict";
+    init_zod();
+    taskItemSchema = external_exports.object({
+      id: external_exports.string().optional(),
+      title: external_exports.string().optional(),
+      description: external_exports.string().optional(),
+      status: external_exports.enum(["pending", "in_progress", "completed", "cancelled"]).optional(),
+      priority: external_exports.enum(["low", "medium", "high", "critical"]).optional(),
+      dependencies: external_exports.array(external_exports.string()).optional(),
+      after: external_exports.string().optional()
+    });
+    taskSchema = external_exports.object({
+      action: external_exports.enum(["create", "update", "complete", "delete", "list"]),
+      tasks: external_exports.array(external_exports.union([external_exports.string(), taskItemSchema])).optional(),
+      id: external_exports.string().optional(),
+      title: external_exports.string().optional(),
+      description: external_exports.string().optional(),
+      status: external_exports.enum(["pending", "in_progress", "completed", "cancelled"]).optional(),
+      priority: external_exports.enum(["low", "medium", "high", "critical"]).optional(),
+      dependencies: external_exports.array(external_exports.string()).optional(),
+      after: external_exports.string().optional()
+    });
+    taskToolDefinition = `## task
+Manage tasks for tracking progress during code exploration and problem-solving. Create tasks to break down complex problems, track dependencies, and ensure all work is completed.
+
+Parameters:
+- action: (required) The action to perform: create, update, complete, delete, list
+- tasks: (optional) JSON array for batch operations - alternative to single-task params
+- id: (optional) Task ID for single operations (e.g., "task-1")
+- title: (optional) Task title for create/update
+- description: (optional) Task description for create/update
+- status: (optional) Task status for update: pending, in_progress, completed, cancelled
+- priority: (optional) Task priority: low, medium, high, critical
+- dependencies: (optional) JSON array of task IDs that must be completed first
+- after: (optional) Task ID to insert the new task after (for ordering). By default, new tasks are appended to the end
+
+Usage Examples:
+
+Creating a single task:
+<task>
+<action>create</action>
+<title>Analyze authentication module</title>
+<description>Search and understand how authentication works</description>
+<priority>high</priority>
+</task>
+
+Creating multiple tasks with dependencies:
+<task>
+<action>create</action>
+<tasks>[
+  {"title": "Search for user model", "priority": "high"},
+  {"title": "Analyze authentication flow", "dependencies": ["task-1"]},
+  {"title": "Review session management", "dependencies": ["task-2"]}
+]</tasks>
+</task>
+
+Inserting a task after a specific task (instead of appending to end):
+<task>
+<action>create</action>
+<title>Investigate error handling</title>
+<after>task-2</after>
+</task>
+
+Updating a task status:
+<task>
+<action>update</action>
+<id>task-1</id>
+<status>in_progress</status>
+</task>
+
+Batch updating multiple tasks:
+<task>
+<action>update</action>
+<tasks>[
+  {"id": "task-1", "status": "completed"},
+  {"id": "task-2", "status": "in_progress"}
+]</tasks>
+</task>
+
+Completing a task:
+<task>
+<action>complete</action>
+<id>task-1</id>
+</task>
+
+Cancelling a task:
+<task>
+<action>update</action>
+<id>task-1</id>
+<status>cancelled</status>
+</task>
+
+Deleting a task:
+<task>
+<action>delete</action>
+<id>task-1</id>
+</task>
+
+Listing all tasks:
+<task>
+<action>list</action>
+</task>
+`;
+    taskSystemPrompt = `[Task Management System]
+
+You have access to a task tracking tool to organize your work on complex requests.
+
+## When to Create Tasks
+
+CREATE TASKS when the request has **multiple distinct deliverables or goals**:
+- "Fix bug A AND add feature B" \u2192 Two separate tasks
+- "Investigate auth, payments, AND notifications" \u2192 Three independent areas
+- "Implement X, then add tests, then update docs" \u2192 Sequential phases with different outputs
+- User explicitly asks for a plan or task breakdown
+
+SKIP TASKS for single-goal requests, even if they require multiple searches:
+- "How does ranking work?" \u2192 Just investigate and answer (one goal)
+- "What does function X do?" \u2192 Just look it up (one goal)
+- "Explain the authentication flow" \u2192 Just trace and explain (one goal)
+- "Find where errors are logged" \u2192 Just search and report (one goal)
+
+**Key insight**: Multiple *internal steps* (search, read, analyze) are NOT the same as multiple *goals*.
+A single investigation with many steps is still ONE task, not many.
+
+MODIFY TASKS when (during execution):
+- You discover the problem is more complex than expected \u2192 Add new tasks
+- A single task covers too much scope \u2192 Split into smaller tasks
+- You find related work that needs attention \u2192 Add dependent tasks
+- A task becomes irrelevant based on findings \u2192 Cancel it
+- Task priorities change based on discoveries \u2192 Update priority
+- You learn new context \u2192 Update task description
+
+## Task Workflow
+
+**STEP 1 - Plan (at start):**
+Analyze the request and create tasks for each logical step:
+
+<task>
+<action>create</action>
+<tasks>[
+  {"title": "Search for authentication module", "priority": "high"},
+  {"title": "Analyze login flow implementation", "dependencies": ["task-1"]},
+  {"title": "Find session management code", "dependencies": ["task-1"]},
+  {"title": "Summarize authentication architecture", "dependencies": ["task-2", "task-3"]}
+]</tasks>
+</task>
+
+**STEP 2 - Execute (during work):**
+Update task status as you work:
+
+<task>
+<action>update</action>
+<id>task-1</id>
+<status>in_progress</status>
+</task>
+
+... do the work (search, extract, etc.) ...
+
+<task>
+<action>complete</action>
+<id>task-1</id>
+</task>
+
+**STEP 2b - Adapt (when you discover new work):**
+As you work, you may discover that:
+- A task is more complex than expected \u2192 Split it into subtasks
+- New areas need investigation \u2192 Add new tasks
+- Some tasks are no longer needed \u2192 Cancel them
+- Task order should change \u2192 Update dependencies
+
+*Adding a new task when you discover more work:*
+<task>
+<action>create</action>
+<title>Investigate caching layer</title>
+<description>Found references to Redis caching in auth module</description>
+</task>
+
+*Inserting a task after a specific task (to maintain logical order):*
+<task>
+<action>create</action>
+<title>Check rate limiting</title>
+<after>task-2</after>
+</task>
+
+*Cancelling and splitting a complex task:*
+<task>
+<action>update</action>
+<id>task-3</id>
+<status>cancelled</status>
+</task>
+<task>
+<action>create</action>
+<tasks>[
+  {"title": "Review JWT token generation", "priority": "high"},
+  {"title": "Review token refresh logic"}
+]</tasks>
+</task>
+
+**STEP 3 - Finish (before completion):**
+Before calling attempt_completion, ensure ALL tasks are either:
+- \`completed\` - you finished the work
+- \`cancelled\` - no longer needed
+
+If you created tasks, you MUST resolve them all before completing.
+
+## Key Rules
+
+1. **Dependencies are enforced**: A task cannot start until its dependencies are completed
+2. **Circular dependencies are rejected**: task-1 \u2192 task-2 \u2192 task-1 is invalid
+3. **Completion is blocked**: attempt_completion will fail if tasks remain unresolved
+4. **List to review**: Use <task><action>list</action></task> to see current task status
+5. **Tasks are living documents**: Add, split, or cancel tasks as you learn more about the problem
+`;
+    taskGuidancePrompt = `<task_guidance>
+Does this request have MULTIPLE DISTINCT GOALS?
+- "Do A AND B AND C" (multiple goals) \u2192 Create tasks for each goal
+- "Investigate/explain/find X" (single goal) \u2192 Skip tasks, just answer directly
+
+Multiple internal steps (search, read, analyze) for ONE goal = NO tasks needed.
+Only create tasks when there are separate deliverables the user is asking for.
+
+If creating tasks, use the task tool with action="create" first.
+</task_guidance>`;
+  }
+});
+
 // src/tools/common.js
 import { resolve as resolve2, isAbsolute as isAbsolute2 } from "path";
 function buildToolTagPattern(tools2 = DEFAULT_VALID_TOOLS) {
@@ -8221,6 +8898,7 @@ function getValidParamsForTool(toolName) {
     listSkills: listSkillsSchema,
     useSkill: useSkillSchema,
     bash: bashSchema,
+    task: taskSchema,
     attempt_completion: attemptCompletionSchema,
     edit: editSchema,
     create: createSchema
@@ -8327,6 +9005,62 @@ function createMessagePreview(message, charsPerSide = 200) {
   const end = message.substring(message.length - charsPerSide);
   return `${start}...${end}`;
 }
+function detectUnrecognizedToolCall(xmlString, validTools) {
+  if (!xmlString || typeof xmlString !== "string") {
+    return null;
+  }
+  const knownToolNames = [
+    "search",
+    "query",
+    "extract",
+    "listFiles",
+    "searchFiles",
+    "listSkills",
+    "useSkill",
+    "readImage",
+    "implement",
+    "edit",
+    "create",
+    "delegate",
+    "bash",
+    "task",
+    "attempt_completion",
+    "attempt_complete",
+    "read_file",
+    "write_file",
+    "run_command",
+    "grep",
+    "find",
+    "cat",
+    "list_directory"
+  ];
+  for (const toolName of knownToolNames) {
+    if (validTools.includes(toolName)) {
+      continue;
+    }
+    const openTag = `<${toolName}>`;
+    const closeTag = `</${toolName}>`;
+    const openIndex = xmlString.indexOf(openTag);
+    if (openIndex === -1) {
+      continue;
+    }
+    let isNested = false;
+    for (const validTool of validTools) {
+      const validOpenTag = `<${validTool}>`;
+      const validCloseTag = `</${validTool}>`;
+      const validOpenIndex = xmlString.indexOf(validOpenTag);
+      const validCloseIndex = xmlString.indexOf(validCloseTag);
+      if (validOpenIndex !== -1 && validCloseIndex !== -1 && validOpenIndex < openIndex && openIndex < validCloseIndex) {
+        isNested = true;
+        break;
+      }
+    }
+    if (!isNested) {
+      return toolName;
+    }
+  }
+  return null;
+}
 function parseTargets(targets) {
   if (!targets || typeof targets !== "string") {
     return [];
@@ -8369,6 +9103,7 @@ var init_common = __esm({
     "use strict";
     init_zod();
     init_edit();
+    init_taskTool();
     searchSchema = external_exports.object({
       query: external_exports.string().describe("Search query with Elasticsearch syntax. Use quotes for exact matches, AND/OR for boolean logic, - for negation."),
       path: external_exports.string().optional().default(".").describe('Path to search in. For dependencies use "go:github.com/owner/repo", "js:package_name", or "rust:cargo_name" etc.')
@@ -8679,6 +9414,7 @@ User: Check system info
       "searchFiles",
       "implement",
       "bash",
+      "task",
       "attempt_completion"
     ];
   }
@@ -8764,15 +9500,29 @@ function parseDelegatedTargets(rawResponse) {
 }
 function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, allowTests }) {
   return [
-    "You are a code-search subagent. Your ONLY job is to return ALL relevant code locations.",
-    "Use ONLY the search tool. Do NOT answer the question or explain anything.",
-    'Return ONLY valid JSON with this shape: {"targets": ["path/to/file.ext#Symbol", "path/to/file.ext:line", "path/to/file.ext:start-end"]}.',
-    "Prefer #Symbol when a function/class name is clear; otherwise use line numbers.",
-    `Search query: ${searchQuery}`,
+    "You are a code-search subagent. Your job is to find ALL relevant code locations for the given query.",
+    "",
+    "The query may be complex - it could be a natural language question, a multi-part request, or a simple keyword.",
+    "Break down complex queries into multiple searches to cover all aspects.",
+    "",
+    "Available tools:",
+    "- search: Find code matching keywords or patterns. Run multiple searches for different aspects of complex queries.",
+    "- extract: Verify code snippets to ensure targets are actually relevant before including them.",
+    "- listFiles: Understand directory structure to find where relevant code might live.",
+    "",
+    "Strategy for complex queries:",
+    "1. Analyze the query - identify key concepts, entities, and relationships",
+    '2. Run focused searches for each concept (e.g., "error handling" + "authentication" separately)',
+    "3. Use extract to verify relevance of promising results",
+    "4. Combine all relevant targets in your final response",
+    "",
+    `Query: ${searchQuery}`,
     `Search path(s): ${searchPath}`,
     `Options: exact=${exact ? "true" : "false"}, language=${language || "auto"}, allow_tests=${allowTests ? "true" : "false"}.`,
-    "Run additional searches only if needed to capture all relevant locations.",
-    "Deduplicate targets."
+    "",
+    'Return ONLY valid JSON: {"targets": ["path/to/file.ext#Symbol", "path/to/file.ext:line", "path/to/file.ext:start-end"]}',
+    "Prefer #Symbol when a function/class name is clear; otherwise use line numbers.",
+    "Deduplicate targets. Do NOT explain or answer - ONLY return the JSON targets."
   ].join("\n");
 }
 var CODE_SEARCH_SCHEMA, searchTool, queryTool, extractTool, delegateTool;
@@ -8784,6 +9534,7 @@ var init_vercel = __esm({
     init_extract();
     init_delegate();
     init_common();
+    init_error_types();
     CODE_SEARCH_SCHEMA = {
       type: "object",
       properties: {
@@ -8846,7 +9597,7 @@ var init_vercel = __esm({
               return await runRawSearch();
             } catch (error) {
               console.error("Error executing search command:", error);
-              return `Error executing search command: ${error.message}`;
+              return formatErrorForAI(error);
             }
           }
           try {
@@ -8873,7 +9624,7 @@ var init_vercel = __esm({
               bashConfig: null,
               architectureFileName: options.architectureFileName || null,
               promptType: "code-searcher",
-              allowedTools: ["search", "attempt_completion"],
+              allowedTools: ["search", "extract", "listFiles", "attempt_completion"],
               searchDelegate: false,
               schema: CODE_SEARCH_SCHEMA
             });
@@ -8905,7 +9656,7 @@ var init_vercel = __esm({
               return await runRawSearch();
             } catch (fallbackError) {
               console.error("Error executing search command:", fallbackError);
-              return `Error executing search command: ${fallbackError.message}`;
+              return formatErrorForAI(fallbackError);
             }
           }
         }
@@ -8942,7 +9693,7 @@ var init_vercel = __esm({
             return results;
           } catch (error) {
             console.error("Error executing query command:", error);
-            return `Error executing query command: ${error.message}`;
+            return formatErrorForAI(error);
           }
         }
       });
@@ -9018,7 +9769,7 @@ var init_vercel = __esm({
             return results;
           } catch (error) {
             console.error("Error executing extract command:", error);
-            return `Error executing extract command: ${error.message}`;
+            return formatErrorForAI(error);
           }
         }
       });
@@ -10904,6 +11655,16 @@ var init_simpleTelemetry = __esm({
           ...data
         });
       }
+      /**
+       * Record task management events
+       */
+      recordTaskEvent(eventType, data = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`task.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data
+        });
+      }
       setAttributes(attributes) {
         if (this.telemetry && this.telemetry.enableConsole) {
           console.log("[Attributes]", attributes);
@@ -17932,6 +18693,507 @@ var init_hooks = __esm({
   }
 });
 
+// src/agent/tasks/TaskManager.js
+var TaskManager;
+var init_TaskManager = __esm({
+  "src/agent/tasks/TaskManager.js"() {
+    "use strict";
+    TaskManager = class _TaskManager {
+      /**
+       * Create a new TaskManager instance
+       * @param {Object} [options] - Configuration options
+       * @param {boolean} [options.debug=false] - Enable debug logging
+       */
+      constructor(options = {}) {
+        this.tasks = /* @__PURE__ */ new Map();
+        this.taskCounter = 0;
+        this.debug = options.debug || false;
+      }
+      /**
+       * Generate the next task ID
+       * @returns {string} New task ID
+       * @private
+       */
+      _generateId() {
+        this.taskCounter++;
+        return `task-${this.taskCounter}`;
+      }
+      /**
+       * Get current timestamp in ISO format
+       * @returns {string} ISO timestamp
+       * @private
+       */
+      _now() {
+        return (/* @__PURE__ */ new Date()).toISOString();
+      }
+      /**
+       * Create a single task
+       * @param {Object} taskData - Task data
+       * @param {string} taskData.title - Task title
+       * @param {string} [taskData.description] - Task description
+       * @param {'low'|'medium'|'high'|'critical'} [taskData.priority] - Task priority
+       * @param {string[]} [taskData.dependencies] - Task IDs this task depends on
+       * @param {string} [taskData.after] - Task ID to insert this task after (for ordering)
+       * @returns {Task} Created task
+       * @throws {Error} If dependencies are invalid or create a cycle
+       */
+      createTask(taskData) {
+        const id = this._generateId();
+        const now = this._now();
+        const dependencies = taskData.dependencies || [];
+        for (const depId of dependencies) {
+          if (!this.tasks.has(depId)) {
+            throw new Error(`Dependency "${depId}" does not exist. Available tasks: ${this._getAvailableTaskIds()}`);
+          }
+        }
+        const afterTaskId = taskData.after;
+        if (afterTaskId && !this.tasks.has(afterTaskId)) {
+          throw new Error(`Task "${afterTaskId}" does not exist. Cannot insert after non-existent task. Available tasks: ${this._getAvailableTaskIds()}`);
+        }
+        if (dependencies.length > 0 && !this._validateNoCycle(id, dependencies)) {
+          throw new Error(`Adding dependencies [${dependencies.join(", ")}] to "${id}" would create a circular dependency`);
+        }
+        const task = {
+          id,
+          title: taskData.title,
+          description: taskData.description || null,
+          status: "pending",
+          priority: taskData.priority || null,
+          dependencies,
+          createdAt: now,
+          updatedAt: now,
+          completedAt: null
+        };
+        if (afterTaskId) {
+          this._insertAfter(afterTaskId, id, task);
+        } else {
+          this.tasks.set(id, task);
+        }
+        if (this.debug) {
+          console.log(`[TaskManager] Created task: ${id} - ${task.title}${afterTaskId ? ` (after ${afterTaskId})` : ""}`);
+        }
+        return task;
+      }
+      /**
+       * Insert a task after a specific task in the Map order
+       * @param {string} afterId - Task ID to insert after
+       * @param {string} newId - New task ID
+       * @param {Task} newTask - New task object
+       * @private
+       */
+      _insertAfter(afterId, newId, newTask) {
+        const newTasks = /* @__PURE__ */ new Map();
+        for (const [id, task] of this.tasks) {
+          newTasks.set(id, task);
+          if (id === afterId) {
+            newTasks.set(newId, newTask);
+          }
+        }
+        this.tasks = newTasks;
+      }
+      /**
+       * Create multiple tasks in batch
+       * @param {Object[]} tasksData - Array of task data objects
+       * @returns {Task[]} Created tasks
+       */
+      createTasks(tasksData) {
+        const createdTasks = [];
+        for (const taskData of tasksData) {
+          const task = this.createTask(taskData);
+          createdTasks.push(task);
+        }
+        return createdTasks;
+      }
+      /**
+       * Get a task by ID
+       * @param {string} id - Task ID
+       * @returns {Task|null} Task or null if not found
+       */
+      getTask(id) {
+        return this.tasks.get(id) || null;
+      }
+      /**
+       * Valid status values for tasks
+       * @type {string[]}
+       * @private
+       */
+      static VALID_STATUSES = ["pending", "in_progress", "completed", "cancelled"];
+      /**
+       * Valid priority values for tasks
+       * @type {string[]}
+       * @private
+       */
+      static VALID_PRIORITIES = ["low", "medium", "high", "critical"];
+      /**
+       * Update a task
+       * @param {string} id - Task ID
+       * @param {Object} updates - Fields to update
+       * @returns {Task} Updated task
+       * @throws {Error} If task not found or update is invalid
+       */
+      updateTask(id, updates) {
+        const task = this.tasks.get(id);
+        if (!task) {
+          throw new Error(`Task "${id}" not found. Available tasks: ${this._getAvailableTaskIds()}`);
+        }
+        if (updates.status !== void 0) {
+          if (!_TaskManager.VALID_STATUSES.includes(updates.status)) {
+            throw new Error(`Invalid status "${updates.status}". Valid statuses: ${_TaskManager.VALID_STATUSES.join(", ")}`);
+          }
+          if (updates.status === "completed" && !task.completedAt) {
+            updates.completedAt = this._now();
+          }
+        }
+        if (updates.priority !== void 0 && updates.priority !== null) {
+          if (!_TaskManager.VALID_PRIORITIES.includes(updates.priority)) {
+            throw new Error(`Invalid priority "${updates.priority}". Valid priorities: ${_TaskManager.VALID_PRIORITIES.join(", ")}`);
+          }
+        }
+        if (updates.dependencies !== void 0) {
+          if (!Array.isArray(updates.dependencies)) {
+            throw new Error("Dependencies must be an array");
+          }
+          for (const depId of updates.dependencies) {
+            if (!this.tasks.has(depId)) {
+              throw new Error(`Dependency "${depId}" does not exist. Available tasks: ${this._getAvailableTaskIds()}`);
+            }
+          }
+          if (!this._validateNoCycle(id, updates.dependencies)) {
+            throw new Error(`Adding dependencies [${updates.dependencies.join(", ")}] to "${id}" would create a circular dependency`);
+          }
+        }
+        const updatedTask = {
+          ...task,
+          ...updates,
+          id,
+          // Ensure ID cannot be changed
+          createdAt: task.createdAt,
+          // Ensure createdAt cannot be changed
+          updatedAt: this._now()
+        };
+        this.tasks.set(id, updatedTask);
+        if (this.debug) {
+          console.log(`[TaskManager] Updated task: ${id}`, updates);
+        }
+        return updatedTask;
+      }
+      /**
+       * Update multiple tasks in batch
+       * @param {Object[]} updates - Array of {id, ...updates} objects
+       * @returns {Task[]} Updated tasks
+       */
+      updateTasks(updates) {
+        const updatedTasks = [];
+        for (const update of updates) {
+          const { id, ...taskUpdates } = update;
+          const task = this.updateTask(id, taskUpdates);
+          updatedTasks.push(task);
+        }
+        return updatedTasks;
+      }
+      /**
+       * Delete a task
+       * @param {string} id - Task ID
+       * @returns {boolean} True if deleted
+       * @throws {Error} If task has dependents
+       */
+      deleteTask(id) {
+        const task = this.tasks.get(id);
+        if (!task) {
+          throw new Error(`Task "${id}" not found. Available tasks: ${this._getAvailableTaskIds()}`);
+        }
+        const dependents = this._getDependents(id);
+        if (dependents.length > 0) {
+          throw new Error(`Cannot delete "${id}" - other tasks depend on it: ${dependents.join(", ")}`);
+        }
+        this.tasks.delete(id);
+        if (this.debug) {
+          console.log(`[TaskManager] Deleted task: ${id}`);
+        }
+        return true;
+      }
+      /**
+       * Delete multiple tasks in batch
+       * @param {string[]} ids - Task IDs to delete
+       * @returns {string[]} Deleted task IDs
+       */
+      deleteTasks(ids) {
+        const deletedIds = [];
+        for (const id of ids) {
+          this.deleteTask(id);
+          deletedIds.push(id);
+        }
+        return deletedIds;
+      }
+      /**
+       * Mark a task as completed
+       * @param {string} id - Task ID
+       * @returns {Task} Updated task
+       */
+      completeTask(id) {
+        return this.updateTask(id, { status: "completed" });
+      }
+      /**
+       * Mark multiple tasks as completed
+       * @param {string[]} ids - Task IDs
+       * @returns {Task[]} Updated tasks
+       */
+      completeTasks(ids) {
+        return ids.map((id) => this.completeTask(id));
+      }
+      /**
+       * List all tasks
+       * @param {Object} [filter] - Optional filter
+       * @param {'pending'|'in_progress'|'completed'|'cancelled'} [filter.status] - Filter by status
+       * @returns {Task[]} Array of tasks
+       */
+      listTasks(filter3 = {}) {
+        let tasks = Array.from(this.tasks.values());
+        if (filter3.status) {
+          tasks = tasks.filter((t) => t.status === filter3.status);
+        }
+        return tasks;
+      }
+      /**
+       * Check if there are any incomplete tasks (pending or in_progress)
+       * @returns {boolean} True if there are incomplete tasks
+       */
+      hasIncompleteTasks() {
+        for (const task of this.tasks.values()) {
+          if (task.status === "pending" || task.status === "in_progress") {
+            return true;
+          }
+        }
+        return false;
+      }
+      /**
+       * Get incomplete tasks (pending or in_progress)
+       * @returns {Task[]} Array of incomplete tasks
+       */
+      getIncompleteTasks() {
+        return Array.from(this.tasks.values()).filter(
+          (t) => t.status === "pending" || t.status === "in_progress"
+        );
+      }
+      /**
+       * Check if a dependency is resolved (completed or cancelled)
+       * @param {string} depId - Dependency task ID
+       * @returns {boolean} True if dependency is resolved or doesn't exist
+       * @private
+       */
+      _isDependencyResolved(depId) {
+        const dep = this.tasks.get(depId);
+        if (!dep) return true;
+        return dep.status === "completed" || dep.status === "cancelled";
+      }
+      /**
+       * Get tasks that are ready to start (all dependencies completed)
+       * @returns {Task[]} Array of ready tasks
+       */
+      getReadyTasks() {
+        return Array.from(this.tasks.values()).filter((task) => {
+          if (task.status !== "pending") return false;
+          return task.dependencies.every((depId) => this._isDependencyResolved(depId));
+        });
+      }
+      /**
+       * Get blocked tasks (have incomplete dependencies)
+       * @returns {Task[]} Array of blocked tasks
+       */
+      getBlockedTasks() {
+        return Array.from(this.tasks.values()).filter((task) => {
+          if (task.status !== "pending") return false;
+          return task.dependencies.some((depId) => !this._isDependencyResolved(depId));
+        });
+      }
+      /**
+       * Get human-readable task summary for checkpoint messages
+       * @returns {string} Formatted task summary
+       */
+      getTaskSummary() {
+        const tasks = this.listTasks();
+        if (tasks.length === 0) {
+          return "No tasks created.";
+        }
+        const lines = ["Tasks:"];
+        for (const task of tasks) {
+          let line = `- [${task.status}] ${task.id}: ${task.title}`;
+          if (task.status === "pending" && task.dependencies.length > 0) {
+            const blockers = task.dependencies.filter((depId) => !this._isDependencyResolved(depId));
+            if (blockers.length > 0) {
+              line += ` (blocked by: ${blockers.join(", ")})`;
+            }
+          }
+          lines.push(line);
+        }
+        return lines.join("\n");
+      }
+      /**
+       * Escape XML special characters to prevent injection
+       * @param {string} str - String to escape
+       * @returns {string} Escaped string
+       * @private
+       */
+      _escapeXml(str) {
+        if (typeof str !== "string") return String(str);
+        return str.replace(/[<>&'"]/g, (c) => ({
+          "<": "&lt;",
+          ">": "&gt;",
+          "&": "&amp;",
+          "'": "&apos;",
+          '"': "&quot;"
+        })[c]);
+      }
+      /**
+       * Format tasks for inclusion in AI prompts
+       * @returns {string} XML-formatted task list
+       */
+      formatTasksForPrompt() {
+        const tasks = this.listTasks();
+        if (tasks.length === 0) {
+          return "<task_status>No tasks created.</task_status>";
+        }
+        const taskLines = tasks.map((task) => {
+          const blockers = task.dependencies.filter((depId) => !this._isDependencyResolved(depId));
+          let line = `  <task id="${this._escapeXml(task.id)}" status="${this._escapeXml(task.status)}"`;
+          if (task.priority) line += ` priority="${this._escapeXml(task.priority)}"`;
+          if (blockers.length > 0) line += ` blocked_by="${this._escapeXml(blockers.join(","))}"`;
+          line += `>${this._escapeXml(task.title)}</task>`;
+          return line;
+        });
+        return `<task_status>
+${taskLines.join("\n")}
+</task_status>`;
+      }
+      /**
+       * Clear all tasks
+       */
+      clear() {
+        this.tasks.clear();
+        this.taskCounter = 0;
+        if (this.debug) {
+          console.log("[TaskManager] Cleared all tasks");
+        }
+      }
+      /**
+       * Export tasks for persistence
+       * @returns {Object} Serializable task data
+       */
+      export() {
+        return {
+          tasks: Array.from(this.tasks.entries()),
+          taskCounter: this.taskCounter
+        };
+      }
+      /**
+       * Import tasks from exported data
+       * @param {Object} data - Exported task data
+       * @throws {Error} If data is invalid or malformed
+       */
+      import(data) {
+        if (!data || typeof data !== "object") {
+          throw new Error("Invalid import data: must be an object");
+        }
+        if (Object.prototype.hasOwnProperty.call(data, "__proto__") || Object.prototype.hasOwnProperty.call(data, "constructor")) {
+          throw new Error("Invalid import data: prototype pollution attempt detected");
+        }
+        if (!Array.isArray(data.tasks)) {
+          throw new Error("Invalid import data: tasks must be an array");
+        }
+        if (typeof data.taskCounter !== "number" || !Number.isInteger(data.taskCounter) || data.taskCounter < 0) {
+          throw new Error("Invalid import data: taskCounter must be a non-negative integer");
+        }
+        for (const entry of data.tasks) {
+          if (!Array.isArray(entry) || entry.length !== 2) {
+            throw new Error("Invalid import data: each task entry must be a [id, task] tuple");
+          }
+          const [id, task] = entry;
+          if (typeof id !== "string") {
+            throw new Error("Invalid import data: task id must be a string");
+          }
+          if (!task || typeof task !== "object") {
+            throw new Error("Invalid import data: task must be an object");
+          }
+          if (Object.prototype.hasOwnProperty.call(task, "__proto__") || Object.prototype.hasOwnProperty.call(task, "constructor")) {
+            throw new Error("Invalid import data: prototype pollution attempt detected in task");
+          }
+        }
+        this.tasks = new Map(data.tasks);
+        this.taskCounter = data.taskCounter;
+      }
+      /**
+       * Get list of available task IDs for error messages
+       * @returns {string} Comma-separated list of task IDs
+       * @private
+       */
+      _getAvailableTaskIds() {
+        const ids = Array.from(this.tasks.keys());
+        return ids.length > 0 ? ids.join(", ") : "(none)";
+      }
+      /**
+       * Get tasks that depend on a given task
+       * @param {string} taskId - Task ID
+       * @returns {string[]} Array of dependent task IDs
+       * @private
+       */
+      _getDependents(taskId) {
+        const dependents = [];
+        for (const [id, task] of this.tasks) {
+          if (task.dependencies.includes(taskId)) {
+            dependents.push(id);
+          }
+        }
+        return dependents;
+      }
+      /**
+       * Validate that adding dependencies won't create a cycle
+       * Uses DFS to detect cycles
+       * @param {string} taskId - Task being updated
+       * @param {string[]} newDependencies - New dependencies to add
+       * @returns {boolean} True if no cycle would be created
+       * @private
+       */
+      _validateNoCycle(taskId, newDependencies) {
+        const graph = /* @__PURE__ */ new Map();
+        for (const [id, task] of this.tasks) {
+          graph.set(id, [...task.dependencies]);
+        }
+        graph.set(taskId, newDependencies);
+        const visited = /* @__PURE__ */ new Set();
+        const recursionStack = /* @__PURE__ */ new Set();
+        const hasCycle = (nodeId) => {
+          if (recursionStack.has(nodeId)) {
+            return true;
+          }
+          if (visited.has(nodeId)) {
+            return false;
+          }
+          visited.add(nodeId);
+          recursionStack.add(nodeId);
+          const deps = graph.get(nodeId) || [];
+          for (const depId of deps) {
+            if (hasCycle(depId)) {
+              return true;
+            }
+          }
+          recursionStack.delete(nodeId);
+          return false;
+        };
+        return !hasCycle(taskId);
+      }
+    };
+  }
+});
+
+// src/agent/tasks/index.js
+var init_tasks = __esm({
+  "src/agent/tasks/index.js"() {
+    "use strict";
+    init_TaskManager();
+    init_taskTool();
+  }
+});
+
 // src/index.js
 import dotenv from "dotenv";
 var init_index = __esm({
@@ -17956,6 +19218,7 @@ var init_index = __esm({
     init_probeTool();
     init_storage();
     init_hooks();
+    init_tasks();
     dotenv.config();
   }
 });
@@ -18115,6 +19378,7 @@ var init_tools2 = __esm({
     "use strict";
     init_index();
     init_xmlParsingUtils();
+    init_tasks();
     implementToolDefinition = `
 ## implement
 Description: Implement a given task. Can modify files. Can be used ONLY if task explicitly stated that something requires modification or implementation.
@@ -30449,6 +31713,8 @@ var init_semantics = __esm({
       constructor(ctx, knownIds, knownEdgeIds) {
         super();
         this.edgeCount = 0;
+        this.subgraphStack = [];
+        this.reportedSubgraphIdCollision = /* @__PURE__ */ new Set();
         this.validateVisitor();
         this.ctx = ctx;
         this.knownIds = knownIds;
@@ -30641,8 +31907,13 @@ var init_semantics = __esm({
         }
       }
       subgraph(ctx) {
+        const idTok = ctx.subgraphIdOrFirstWord && ctx.subgraphIdOrFirstWord[0];
+        if (idTok)
+          this.subgraphStack.push({ id: String(idTok.image) });
         if (ctx.subgraphStatement)
           ctx.subgraphStatement.forEach((s) => this.visit(s));
+        if (idTok)
+          this.subgraphStack.pop();
       }
       subgraphStatement(ctx) {
         for (const k of Object.keys(ctx)) {
@@ -30705,6 +31976,27 @@ var init_semantics = __esm({
         }
         if (ctx.nodeShape)
           ctx.nodeShape.forEach((n) => this.visit(n));
+        const idTok = ctx.nodeId && ctx.nodeId[0];
+        const idNumTok = ctx.nodeIdNum && ctx.nodeIdNum[0];
+        const idToken = idTok || idNumTok;
+        if (idToken && this.subgraphStack.length > 0) {
+          const id = String(idToken.image);
+          const hasCollision = this.subgraphStack.some((sg) => sg.id === id);
+          if (hasCollision) {
+            const key = `${id}:${idToken.startLine ?? 1}:${idToken.startColumn ?? 1}`;
+            if (!this.reportedSubgraphIdCollision.has(key)) {
+              this.reportedSubgraphIdCollision.add(key);
+              this.ctx.errors.push({
+                line: idToken.startLine ?? 1,
+                column: idToken.startColumn ?? 1,
+                severity: "error",
+                code: "FL-SUBGRAPH-ID-COLLISION",
+                message: `Node id '${id}' conflicts with an enclosing subgraph id and creates a cycle in Mermaid.`,
+                hint: "Rename the subgraph id or the node id, or use a quoted subgraph title with no explicit id."
+              });
+            }
+          }
+        }
         if (hasAttr) {
           const attr = ctx.attrObject?.[0];
           const pairs = attr?.children?.attrPair || [];
@@ -34745,6 +36037,7 @@ function computeFixes(text, errors, level = "safe") {
   const patchedLines = /* @__PURE__ */ new Set();
   const seen = /* @__PURE__ */ new Set();
   const piQuoteClosedLines = /* @__PURE__ */ new Set();
+  const subgraphCollisionRename = /* @__PURE__ */ new Map();
   function sanitizeAllQuotedSegmentsInShapes(lineText, lineNo) {
     const shapes = [
       { open: "[[", close: "]]" },
@@ -35464,6 +36757,28 @@ function computeFixes(text, errors, level = "safe") {
       }
       continue;
     }
+    if (is("FL-SUBGRAPH-ID-COLLISION", e)) {
+      if (level === "all") {
+        const lineText = lineTextAt(text, e.line);
+        if (lineText.trimStart().startsWith("subgraph"))
+          continue;
+        const caret0 = Math.max(0, e.column - 1);
+        const slice = lineText.slice(caret0);
+        const m = slice.match(/^([A-Za-z_][A-Za-z0-9_]*(?:-[A-Za-z0-9_]+)*)/);
+        if (m) {
+          const id = m[1];
+          let newId = subgraphCollisionRename.get(id);
+          if (!newId) {
+            newId = id.endsWith("_node") ? `${id}2` : `${id}_node`;
+            subgraphCollisionRename.set(id, newId);
+          }
+          if (newId !== id) {
+            edits.push(replaceRange(text, { line: e.line, column: caret0 + 1 }, id.length, newId));
+          }
+        }
+      }
+      continue;
+    }
     if (is("FL-LABEL-QUOTE-IN-UNQUOTED", e)) {
       if (level === "safe" || level === "all") {
         const lineText = lineTextAt(text, e.line);
@@ -45125,7 +46440,7 @@ var init_styles = __esm({
 });
 
 // node_modules/@probelabs/maid/out/renderer/utils.js
-function escapeXml(text) {
+function escapeXml2(text) {
   return String(text).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\"/g, "&quot;").replace(/'/g, "&apos;");
 }
 function measureText(text, fontSize = 12) {
@@ -45180,7 +46495,7 @@ function blockOverlay(x, y, width, height, title, branchYs = [], titleYOffset =
   const parts = [];
   parts.push(`<g class="cluster-overlay" transform="translate(${x},${y})">`);
   parts.push(`<rect class="cluster-border" x="0" y="0" width="${width}" height="${height}" rx="${radius}"/>`);
-  const titleText = title ? escapeXml(title) : "";
+  const titleText = title ? escapeXml2(title) : "";
   if (titleText) {
     const titleW = Math.max(24, measureText(titleText, 12) + 10);
     const yBg = -2 + titleYOffset;
@@ -45199,7 +46514,7 @@ function blockOverlay(x, y, width, height, title, branchYs = [], titleYOffset =
     const yRel = br.y - y;
     parts.push(`<line x1="0" y1="${yRel}" x2="${width}" y2="${yRel}" class="cluster-border" />`);
     if (br.title) {
-      const text = escapeXml(br.title);
+      const text = escapeXml2(br.title);
       const bw = Math.max(24, measureText(text, 12) + 10);
       const xBg = 6;
       parts.push(`<rect class="cluster-title-bg" x="${xBg}" y="${yRel - 10}" width="${bw}" height="18" rx="3"/>`);
@@ -46368,7 +47683,7 @@ function renderPie(model, opts = {}) {
   </style>`;
   if (model.title) {
     svg += `
-  <text class="pie-title" x="${cx}" y="${pad + 8}" text-anchor="middle">${escapeXml(model.title)}</text>`;
+  <text class="pie-title" x="${cx}" y="${pad + 8}" text-anchor="middle">${escapeXml2(model.title)}</text>`;
   }
   svg += `
   <g class="pie" aria-label="pie">`;
@@ -46392,7 +47707,7 @@ function renderPie(model, opts = {}) {
     const mid = (start + end) / 2;
     const cos = Math.cos(mid);
     const sin = Math.sin(mid);
-    const percentLabel = escapeXml(formatPercent(s.value, total));
+    const percentLabel = escapeXml2(formatPercent(s.value, total));
     if (angle < minOutsideAngle) {
       const r1 = radius * 0.9;
       const r2 = radius * 1.06;
@@ -46434,7 +47749,7 @@ function renderPie(model, opts = {}) {
     slices.forEach((s, i) => {
       const y = legendY + i * LEG_VSPACE;
       const fill = s.color || palette(i);
-      const text = escapeXml(`${s.label}${model.showData ? ` ${formatNumber(Number(s.value))}` : ""}`);
+      const text = escapeXml2(`${s.label}${model.showData ? ` ${formatNumber(Number(s.value))}` : ""}`);
       svg += `
     <rect x="${legendX}" y="${y - LEG_SW + 6}" width="${LEG_SW}" height="${LEG_SW}" fill="${fill}" stroke="${fill}" stroke-width="1" />`;
       svg += `
@@ -47010,11 +48325,11 @@ function renderSequence(model, opts = {}) {
   const accTitle = model.accTitle || model.title || void 0;
   const accDesc = model.accDescr || void 0;
   if (accTitle)
-    svgParts.push(`  <title>${escapeXml(accTitle)}</title>`);
+    svgParts.push(`  <title>${escapeXml2(accTitle)}</title>`);
   if (accDesc)
-    svgParts.push(`  <desc>${escapeXml(accDesc)}</desc>`);
+    svgParts.push(`  <desc>${escapeXml2(accDesc)}</desc>`);
   if (model.title) {
-    const t = escapeXml(model.title);
+    const t = escapeXml2(model.title);
     const tW = Math.max(20, measureText(model.title, 16));
     const xMid = width / 2;
     svgParts.push(`  <text class="node-label" x="${xMid}" y="0" text-anchor="middle" font-size="16">${t}</text>`);
@@ -47055,7 +48370,7 @@ function renderSequence(model, opts = {}) {
 function drawParticipant(out, p) {
   out.push(`  <g class="actor" transform="translate(${p.x},${p.y})">`);
   out.push(`    <rect class="node-shape" width="${p.width}" height="${p.height}" rx="0"/>`);
-  out.push(`    <text class="node-label" x="${p.width / 2}" y="${p.height / 2}" text-anchor="middle" dominant-baseline="middle">${escapeXml(p.display)}</text>`);
+  out.push(`    <text class="node-label" x="${p.width / 2}" y="${p.height / 2}" text-anchor="middle" dominant-baseline="middle">${escapeXml2(p.display)}</text>`);
   out.push("  </g>");
 }
 function drawParticipantBottom(out, p, layout) {
@@ -47063,7 +48378,7 @@ function drawParticipantBottom(out, p, layout) {
   const y = lifeline ? lifeline.y2 : layout.height - 28;
   out.push(`  <g class="actor" transform="translate(${p.x},${y})">`);
   out.push(`    <rect class="node-shape" width="${p.width}" height="${p.height}" rx="0"/>`);
-  out.push(`    <text class="node-label" x="${p.width / 2}" y="${p.height / 2}" text-anchor="middle" dominant-baseline="middle">${escapeXml(p.display)}</text>`);
+  out.push(`    <text class="node-label" x="${p.width / 2}" y="${p.height / 2}" text-anchor="middle" dominant-baseline="middle">${escapeXml2(p.display)}</text>`);
   out.push("  </g>");
 }
 function drawMessage(out, m) {
@@ -47101,12 +48416,12 @@ function drawMessageLabel(out, m, label, _counter) {
   const x = xMid - w / 2;
   const y = m.y - 14 - h / 2;
   out.push(`  <rect class="msg-label-bg" x="${x}" y="${y}" width="${w}" height="${h}" rx="3"/>`);
-  out.push(`  <text class="msg-label" x="${xMid}" y="${y + h / 2}" text-anchor="middle">${escapeXml(label)}</text>`);
+  out.push(`  <text class="msg-label" x="${xMid}" y="${y + h / 2}" text-anchor="middle">${escapeXml2(label)}</text>`);
 }
 function drawNote(out, n) {
   out.push(`  <g class="note" transform="translate(${n.x},${n.y})">`);
   out.push(`    <rect width="${n.width}" height="${n.height}" rx="0"/>`);
-  out.push(`    <text class="note-text" x="${n.width / 2}" y="${n.height / 2 + 4}" text-anchor="middle">${escapeXml(n.text)}</text>`);
+  out.push(`    <text class="note-text" x="${n.width / 2}" y="${n.height / 2 + 4}" text-anchor="middle">${escapeXml2(n.text)}</text>`);
   out.push("  </g>");
 }
 function applySequenceTheme(svg, theme) {
@@ -47872,13 +49187,13 @@ function renderClass(model, opts = {}) {
     let cy = y + padY + lineH;
     parts.push(`  <g transform="translate(${x},${y})">`);
     parts.push(`    <rect class="node-shape" width="${w}" height="${h}" rx="0"/>`);
-    parts.push(`    <text class="node-label class-title" x="${w / 2}" y="${padY + 12}" text-anchor="middle" dominant-baseline="middle">${escapeXml(title)}</text>`);
+    parts.push(`    <text class="node-label class-title" x="${w / 2}" y="${padY + 12}" text-anchor="middle" dominant-baseline="middle">${escapeXml2(title)}</text>`);
     let yCursor = padY + 18;
     if (attrs.length) {
       parts.push(`    <line class="class-divider" x1="0" y1="${yCursor}" x2="${w}" y2="${yCursor}"/>`);
       yCursor += 8;
       for (const a of attrs) {
-        parts.push(`    <text class="node-label class-member" x="${padX}" y="${yCursor}" dominant-baseline="hanging">${escapeXml(a)}</text>`);
+        parts.push(`    <text class="node-label class-member" x="${padX}" y="${yCursor}" dominant-baseline="hanging">${escapeXml2(a)}</text>`);
         yCursor += lineH;
       }
     }
@@ -47886,7 +49201,7 @@ function renderClass(model, opts = {}) {
       parts.push(`    <line class="class-divider" x1="0" y1="${yCursor}" x2="${w}" y2="${yCursor}"/>`);
       yCursor += 8;
       for (const m of methods) {
-        parts.push(`    <text class="node-label class-member" x="${padX}" y="${yCursor}" dominant-baseline="hanging">${escapeXml(m)}</text>`);
+        parts.push(`    <text class="node-label class-member" x="${padX}" y="${yCursor}" dominant-baseline="hanging">${escapeXml2(m)}</text>`);
         yCursor += lineH;
       }
     }
@@ -47912,7 +49227,7 @@ function renderClass(model, opts = {}) {
       const x = pt.x + ux * away + nx * perp;
       const y = pt.y + uy * away + ny * perp;
       const anchor = side === "start" ? "end" : "start";
-      parts.push(`<text class="edge-label-text" x="${x}" y="${y}" text-anchor="${anchor}">${escapeXml(text)}</text>`);
+      parts.push(`<text class="edge-label-text" x="${x}" y="${y}" text-anchor="${anchor}">${escapeXml2(text)}</text>`);
     };
     if (rel.leftCard && pts.length >= 2)
       placeEndpoint(pts[0], pts[1], rel.leftCard, "start");
@@ -47941,7 +49256,7 @@ function renderClass(model, opts = {}) {
         lines.push(cur);
       const dy = 14;
       let y0 = mid.y - (lines.length - 1) * dy / 2 - 10;
-      parts.push(`<text class="edge-label-text" x="${mid.x}" y="${y0}" text-anchor="middle">` + lines.map((ln, i2) => `<tspan x="${mid.x}" dy="${i2 === 0 ? 0 : dy}">${escapeXml(ln)}</tspan>`).join("") + `</text>`);
+      parts.push(`<text class="edge-label-text" x="${mid.x}" y="${y0}" text-anchor="middle">` + lines.map((ln, i2) => `<tspan x="${mid.x}" dy="${i2 === 0 ? 0 : dy}">${escapeXml2(ln)}</tspan>`).join("") + `</text>`);
     }
     const pStart = [pts[0], pts[1] ?? pts[0]];
     const pEnd = [pts[pts.length - 2] ?? pts[pts.length - 1], pts[pts.length - 1]];
@@ -48007,7 +49322,7 @@ function renderClass(model, opts = {}) {
     }
     parts.push(`  <g class="note" transform="translate(${nx},${ny})">`);
     parts.push(`    <rect width="${noteW}" height="${noteH}" rx="0"/>`);
-    parts.push(`    <text class="note-text" x="${noteW / 2}" y="${noteH / 2 + 4}" text-anchor="middle">${escapeXml(note.text)}</text>`);
+    parts.push(`    <text class="note-text" x="${noteW / 2}" y="${noteH / 2 + 4}" text-anchor="middle">${escapeXml2(note.text)}</text>`);
     parts.push("  </g>");
     const ax = anchor.x + anchor.width;
     const ay = anchor.y + 16;
@@ -64944,7 +66259,7 @@ var init_registry = __esm({
 });
 
 // src/agent/skills/formatting.js
-function escapeXml2(value) {
+function escapeXml3(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 function formatAvailableSkillsXml(skills) {
@@ -64952,8 +66267,8 @@ function formatAvailableSkillsXml(skills) {
   const lines = ["<available_skills>"];
   for (const skill of skills) {
     lines.push("  <skill>");
-    lines.push(`    <name>${escapeXml2(skill.name)}</name>`);
-    lines.push(`    <description>${escapeXml2(skill.description || "")}</description>`);
+    lines.push(`    <name>${escapeXml3(skill.name)}</name>`);
+    lines.push(`    <description>${escapeXml3(skill.description || "")}</description>`);
     lines.push("  </skill>");
   }
   lines.push("</available_skills>");
@@ -67306,6 +68621,8 @@ var init_ProbeAgent = __esm({
     init_RetryManager();
     init_FallbackManager();
     init_contextCompactor();
+    init_error_types();
+    init_tasks();
     dotenv2.config();
     MAX_TOOL_ITERATIONS = (() => {
       const val = parseInt(process.env.MAX_TOOL_ITERATIONS || "30", 10);
@@ -67346,6 +68663,7 @@ var init_ProbeAgent = __esm({
        * @param {string} [options.mcpConfigPath] - Path to MCP configuration file
        * @param {Object} [options.mcpConfig] - MCP configuration object (overrides mcpConfigPath)
        * @param {Array} [options.mcpServers] - Deprecated, use mcpConfig instead
+       * @param {boolean} [options.enableTasks=false] - Enable task management system for tracking progress
        * @param {Object} [options.storageAdapter] - Custom storage adapter for history management
        * @param {Object} [options.hooks] - Hook callbacks for events (e.g., {'tool:start': callback})
        * @param {Array<string>|null} [options.allowedTools] - List of allowed tool names. Use ['*'] for all tools (default), [] or null for no tools (raw AI mode), or specific tool names like ['search', 'query', 'extract']. Supports exclusion with '!' prefix (e.g., ['*', '!bash'])
@@ -67441,6 +68759,8 @@ var init_ProbeAgent = __esm({
         this.mcpServers = options.mcpServers || null;
         this.mcpBridge = null;
         this._mcpInitialized = false;
+        this.enableTasks = !!options.enableTasks;
+        this.taskManager = null;
         this.retryConfig = options.retry || {};
         this.retryManager = null;
         this.fallbackConfig = options.fallback || null;
@@ -68816,6 +70136,10 @@ Workspace: ${this.allowedFolders.join(", ")}`;
         }
         if (this.enableBash && isToolAllowed("bash")) {
           toolDefinitions += `${bashToolDefinition}
+`;
+        }
+        if (this.enableTasks && isToolAllowed("task")) {
+          toolDefinitions += `${taskToolDefinition}
 `;
         }
         if (isToolAllowed("attempt_completion")) {
@@ -68826,6 +70150,77 @@ Workspace: ${this.allowedFolders.join(", ")}`;
           toolDefinitions += `${delegateToolDefinition}
 `;
         }
+        let toolExamples = "";
+        if (isToolAllowed("search")) {
+          toolExamples += `
+<search>
+<query>error handling</query>
+<path>src/search</path>
+</search>
+`;
+        }
+        if (isToolAllowed("extract")) {
+          toolExamples += `
+<extract>
+<targets>src/config.js:15-25</targets>
+</extract>
+`;
+        }
+        if (isToolAllowed("attempt_completion")) {
+          toolExamples += `
+<attempt_completion>
+The configuration is loaded from src/config.js lines 15-25 which contains the database settings.
+</attempt_completion>
+`;
+        }
+        let availableToolsList = "";
+        if (isToolAllowed("search")) {
+          availableToolsList += `- search: Search code using keyword queries${this.searchDelegate ? " (returns extracted code blocks via a dedicated subagent)" : ""}.
+`;
+        }
+        if (isToolAllowed("query")) {
+          availableToolsList += "- query: Search code using structural AST patterns.\n";
+        }
+        if (isToolAllowed("extract")) {
+          availableToolsList += "- extract: Extract specific code blocks or lines from files.\n";
+        }
+        if (isToolAllowed("listFiles")) {
+          availableToolsList += "- listFiles: List files and directories in a specified location.\n";
+        }
+        if (isToolAllowed("searchFiles")) {
+          availableToolsList += "- searchFiles: Find files matching a glob pattern with recursive search capability.\n";
+        }
+        if (this.enableSkills && isToolAllowed("listSkills")) {
+          availableToolsList += "- listSkills: List available agent skills discovered in the repository.\n";
+        }
+        if (this.enableSkills && isToolAllowed("useSkill")) {
+          availableToolsList += "- useSkill: Load and activate a specific skill's instructions.\n";
+        }
+        if (isToolAllowed("readImage")) {
+          availableToolsList += "- readImage: Read and load an image file for AI analysis.\n";
+        }
+        if (this.allowEdit && isToolAllowed("implement")) {
+          availableToolsList += "- implement: Implement a feature or fix a bug using aider.\n";
+        }
+        if (this.allowEdit && isToolAllowed("edit")) {
+          availableToolsList += "- edit: Edit files using exact string replacement.\n";
+        }
+        if (this.allowEdit && isToolAllowed("create")) {
+          availableToolsList += "- create: Create new files with specified content.\n";
+        }
+        if (this.enableDelegate && isToolAllowed("delegate")) {
+          availableToolsList += "- delegate: Delegate big distinct tasks to specialized probe subagents.\n";
+        }
+        if (this.enableBash && isToolAllowed("bash")) {
+          availableToolsList += "- bash: Execute bash commands for system operations.\n";
+        }
+        if (this.enableTasks && isToolAllowed("task")) {
+          availableToolsList += "- task: Manage tasks for tracking progress (create, update, complete, delete, list).\n";
+        }
+        if (isToolAllowed("attempt_completion")) {
+          availableToolsList += "- attempt_completion: Finalize the task and provide the result to the user.\n";
+          availableToolsList += "- attempt_complete: Quick completion using previous response (shorthand).\n";
+        }
         let xmlToolGuidelines = `
 # Tool Use Formatting
 
@@ -68840,20 +70235,7 @@ Structure (note the closing tags):
 ...
 </tool_name>
 
-Examples:
-<search>
-<query>error handling</query>
-<path>src/search</path>
-</search>
-
-<extract>
-<targets>src/config.js:15-25</targets>
-</extract>
-
-<attempt_completion>
-The configuration is loaded from src/config.js lines 15-25 which contains the database settings.
-</attempt_completion>
-
+Examples:${toolExamples}
 # Special Case: Quick Completion
 If your previous response was already correct and complete, you may respond with just:
 <attempt_complete>
@@ -68882,16 +70264,7 @@ I need to find code related to error handling in the search module. The most app
 10. If your previous response was already correct and complete, you may use \`<attempt_complete>\` as a shorthand.
 
 Available Tools:
-- search: Search code using keyword queries${this.searchDelegate ? " (returns extracted code blocks via a dedicated subagent)" : ""}.
-- query: Search code using structural AST patterns.
-- extract: Extract specific code blocks or lines from files.
-- listFiles: List files and directories in a specified location.
-- searchFiles: Find files matching a glob pattern with recursive search capability.
-${this.enableSkills ? "- listSkills: List available agent skills discovered in the repository.\n- useSkill: Load and activate a specific skill's instructions.\n" : ""}- readImage: Read and load an image file for AI analysis.
-${this.allowEdit ? "- implement: Implement a feature or fix a bug using aider.\n- edit: Edit files using exact string replacement.\n- create: Create new files with specified content.\n" : ""}${this.enableDelegate ? "- delegate: Delegate big distinct tasks to specialized probe subagents.\n" : ""}${this.enableBash ? "- bash: Execute bash commands for system operations.\n" : ""}
-- attempt_completion: Finalize the task and provide the result to the user.
-- attempt_complete: Quick completion using previous response (shorthand).
-`;
+${availableToolsList}`;
         const commonInstructions = `<instructions>
 Follow these instructions carefully:
 1. Analyze the user's request.
@@ -68945,6 +70318,11 @@ To use a skill, call the useSkill tool with its name.
 `;
           }
         }
+        if (this.enableTasks) {
+          systemMessage += `
+${taskSystemPrompt}
+`;
+        }
         if (this.mcpBridge && this.mcpBridge.getToolNames().length > 0) {
           const allMcpTools = this.mcpBridge.getToolNames();
           const allowedMcpTools = this._filterMcpTools(allMcpTools);
@@ -69030,6 +70408,30 @@ You are working with a repository located at: ${searchDirectory}
         }
         try {
           const oldHistoryLength = this.history.length;
+          if (this.enableTasks) {
+            try {
+              this.taskManager = new TaskManager({ debug: this.debug });
+              const isToolAllowed = (toolName) => this.allowedTools.isEnabled(toolName);
+              if (isToolAllowed("task")) {
+                this.toolImplementations.task = createTaskTool({
+                  taskManager: this.taskManager,
+                  tracer: this.tracer,
+                  debug: this.debug
+                });
+              }
+              if (this.tracer && typeof this.tracer.recordTaskEvent === "function") {
+                this.tracer.recordTaskEvent("session_started", {
+                  "task.enabled": true
+                });
+              }
+              if (this.debug) {
+                console.log("[DEBUG] Task management initialized for this request");
+              }
+            } catch (taskInitError) {
+              console.error("[ProbeAgent] Failed to initialize task management:", taskInitError.message);
+              this.taskManager = null;
+            }
+          }
           await this.hooks.emit(HOOK_TYPES.MESSAGE_USER, {
             sessionId: this.sessionId,
             message,
@@ -69037,6 +70439,12 @@ You are working with a repository located at: ${searchDirectory}
           });
           const systemMessage = await this.getSystemMessage();
           let userMessage = { role: "user", content: message.trim() };
+          if (this.enableTasks) {
+            userMessage.content = userMessage.content + "\n\n" + taskGuidancePrompt;
+            if (this.debug) {
+              console.log("[DEBUG] Task guidance injected into user message");
+            }
+          }
           if (options.schema && !options._schemaFormatted) {
             const schemaInstructions = generateSchemaInstructions(options.schema, { debug: this.debug });
             userMessage.content = message.trim() + schemaInstructions;
@@ -69257,9 +70665,12 @@ You are working with a repository located at: ${searchDirectory}
                   return result;
                 };
                 if (this.tracer) {
+                  const inputPreview = message.length > 1e3 ? message.substring(0, 1e3) + "... [truncated]" : message;
                   await this.tracer.withSpan("ai.request", executeAIRequest, {
                     "ai.model": this.model,
                     "ai.provider": this.clientApiProvider || "auto",
+                    "ai.input": inputPreview,
+                    "ai.input_length": message.length,
                     "iteration": currentIteration,
                     "max_tokens": maxResponseTokens,
                     "temperature": 0.3,
@@ -69339,6 +70750,9 @@ You are working with a repository located at: ${searchDirectory}
               if (this.enableDelegate && this.allowedTools.isEnabled("delegate")) {
                 validTools.push("delegate");
               }
+              if (this.enableTasks && this.allowedTools.isEnabled("task")) {
+                validTools.push("task");
+              }
             }
             const nativeTools = validTools;
             const parsedTool = this.mcpBridge && !options._disableTools ? parseHybridXmlToolCall(assistantResponseContent, nativeTools, this.mcpBridge) : parseXmlToolCallWithThinking(assistantResponseContent, validTools);
@@ -69347,6 +70761,32 @@ You are working with a repository located at: ${searchDirectory}
               if (this.debug) console.log(`[DEBUG] Parsed tool call: ${toolName} with params:`, params);
               if (toolName === "attempt_completion") {
                 completionAttempted = true;
+                if (this.enableTasks && this.taskManager && this.taskManager.hasIncompleteTasks()) {
+                  const taskSummary = this.taskManager.getTaskSummary();
+                  const blockedMessage = createTaskCompletionBlockedMessage(taskSummary);
+                  const incompleteTasks = this.taskManager.getIncompleteTasks();
+                  if (this.tracer && typeof this.tracer.recordTaskEvent === "function") {
+                    this.tracer.recordTaskEvent("completion_blocked", {
+                      "task.incomplete_count": incompleteTasks.length,
+                      "task.incomplete_ids": incompleteTasks.map((t) => t.id).join(", "),
+                      "task.iteration": currentIteration
+                    });
+                  }
+                  if (this.debug) {
+                    console.log("[DEBUG] Task checkpoint: Blocking completion due to incomplete tasks");
+                    console.log("[DEBUG] Incomplete tasks:", taskSummary);
+                  }
+                  currentMessages.push({
+                    role: "assistant",
+                    content: assistantResponseContent
+                  });
+                  currentMessages.push({
+                    role: "user",
+                    content: blockedMessage
+                  });
+                  completionAttempted = false;
+                  continue;
+                }
                 if (params.result === "__PREVIOUS_RESPONSE__") {
                   const lastAssistantMessage = [...currentMessages].reverse().find(
                     (msg) => msg.role === "assistant" && msg.content && !(this.mcpBridge ? parseHybridXmlToolCall(msg.content, validTools, this.mcpBridge) : parseXmlToolCallWithThinking(msg.content, validTools))
@@ -69408,7 +70848,6 @@ ${toolResultContent}
 </tool_result>` });
                   } catch (error) {
                     console.error(`Error executing MCP tool ${toolName}:`, error);
-                    const toolResultContent = `Error executing MCP tool ${toolName}: ${error.message}`;
                     if (this.debug) {
                       console.error(`[DEBUG] ========================================`);
                       console.error(`[DEBUG] MCP tool '${toolName}' failed with error:`);
@@ -69416,8 +70855,9 @@ ${toolResultContent}
                       console.error(`[DEBUG] ========================================
 `);
                     }
+                    const errorXml = formatErrorForAI(error);
                     currentMessages.push({ role: "user", content: `<tool_result>
-${toolResultContent}
+${errorXml}
 </tool_result>` });
                   }
                 } else if (this.toolImplementations[toolName]) {
@@ -69475,6 +70915,8 @@ ${toolResultContent}
                           model: this.model,
                           // Inherit model
                           searchDelegate: this.searchDelegate,
+                          enableTasks: this.enableTasks,
+                          // Inherit task management (subagent gets isolated TaskManager)
                           debug: this.debug,
                           tracer: this.tracer
                         };
@@ -69554,10 +70996,11 @@ ${toolResultContent}
                   } catch (error) {
                     console.error(`[ERROR] Tool execution failed for ${toolName}:`, error);
                     currentMessages.push({ role: "assistant", content: assistantResponseContent });
+                    const errorXml = formatErrorForAI(error);
                     currentMessages.push({
                       role: "user",
                       content: `<tool_result>
-Error: ${error.message}
+${errorXml}
 </tool_result>`
                     });
                   }
@@ -69570,7 +71013,10 @@ Error: ${error.message}
                   currentMessages.push({
                     role: "user",
                     content: `<tool_result>
-Error: Unknown tool '${toolName}'. Available tools: ${allAvailableTools.join(", ")}
+<error type="parameter_error" recoverable="true">
+<message>Unknown tool '${toolName}'</message>
+<suggestion>Available tools: ${allAvailableTools.join(", ")}. Please use one of these tools.</suggestion>
+</error>
 </tool_result>`
                   });
                 }
@@ -69587,7 +71033,20 @@ Error: Unknown tool '${toolName}'. Available tools: ${allAvailableTools.join(",
                 break;
               }
               currentMessages.push({ role: "assistant", content: assistantResponseContent });
-              const reminderContent = `Please use one of the available tools to help answer the question, or use attempt_completion if you have enough information to provide a final answer.
+              const unrecognizedTool = detectUnrecognizedToolCall(assistantResponseContent, validTools);
+              let reminderContent;
+              if (unrecognizedTool) {
+                if (this.debug) {
+                  console.log(`[DEBUG] Detected unrecognized tool '${unrecognizedTool}' in assistant response.`);
+                }
+                const toolError = new ParameterError(`Tool '${unrecognizedTool}' is not available in this context.`, {
+                  suggestion: `Available tools: ${validTools.join(", ")}. Please use one of these tools instead.`
+                });
+                reminderContent = `<tool_result>
+${formatErrorForAI(toolError)}
+</tool_result>`;
+              } else {
+                reminderContent = `Please use one of the available tools to help answer the question, or use attempt_completion if you have enough information to provide a final answer.
 
 Remember: Use proper XML format with BOTH opening and closing tags:
 
@@ -69595,16 +71054,26 @@ Remember: Use proper XML format with BOTH opening and closing tags:
 <parameter>value</parameter>
 </tool_name>
 
-Or for quick completion if your previous response was already correct and complete:
-<attempt_complete>
+Available tools: ${validTools.join(", ")}
 
-IMPORTANT: When using <attempt_complete>, this must be the ONLY content in your response. No additional text, explanations, or other content should be included. This tag signals to reuse your previous response as the final answer.`;
+To complete with a direct answer:
+<attempt_completion>Your final answer here</attempt_completion>
+
+Or if your previous response already contains a complete, direct answer (not a thinking block or JSON):
+<attempt_complete></attempt_complete>
+
+Note: <attempt_complete></attempt_complete> reuses your PREVIOUS assistant message as the final answer. Only use this if that message was already a valid, complete response to the user's question.`;
+              }
               currentMessages.push({
                 role: "user",
                 content: reminderContent
               });
               if (this.debug) {
-                console.log(`[DEBUG] No tool call detected in assistant response. Prompting for tool use.`);
+                if (unrecognizedTool) {
+                  console.log(`[DEBUG] Unrecognized tool '${unrecognizedTool}' used. Providing error feedback.`);
+                } else {
+                  console.log(`[DEBUG] No tool call detected in assistant response. Prompting for tool use.`);
+                }
               }
             }
             if (currentMessages.length > MAX_HISTORY_MESSAGES) {
@@ -70296,7 +71765,7 @@ Convert your previous response content into actual JSON data that follows this s
         if (content.includes("Your response does not match the expected JSON schema") || content.includes("Please provide a valid JSON response") || content.includes("Schema validation error:")) {
           return true;
         }
-        if (content.includes("When using <attempt_complete>") && content.includes("this must be the ONLY content in your response")) {
+        if (content.includes("<attempt_complete></attempt_complete>") && content.includes("reuses your PREVIOUS assistant message")) {
           return true;
         }
         return false;
@@ -71109,6 +72578,9 @@ function parseArgs() {
     // Disable skill discovery and activation
     skillDirs: null,
     // Comma-separated list of repo-relative skill directories
+    // Task management
+    enableTasks: false,
+    // Enable task tracking for progress management
     // Bash tool configuration
     enableBash: false,
     bashAllow: null,
@@ -71179,6 +72651,8 @@ function parseArgs() {
       config.disableSkills = true;
     } else if (arg === "--skills-dir" && i + 1 < args.length) {
       config.skillDirs = args[++i].split(",").map((dir) => dir.trim()).filter(Boolean);
+    } else if (arg === "--allow-tasks") {
+      config.enableTasks = true;
     } else if (arg === "--enable-bash") {
       config.enableBash = true;
     } else if (arg === "--bash-allow" && i + 1 < args.length) {
@@ -71233,6 +72707,7 @@ Options:
                                    Convenience flag equivalent to --allowed-tools none
   --skills-dir <dirs>              Comma-separated list of repo-relative skill directories to scan
   --no-skills                      Disable skill discovery and activation
+  --allow-tasks                    Enable task management for tracking multi-step progress
   --verbose                        Enable verbose output
   --outline                        Use outline-xml format for code search results
   --mcp                           Run as MCP server
@@ -71354,6 +72829,11 @@ var ProbeAgentMcpServer = class {
               architecture_file: {
                 type: "string",
                 description: "Optional architecture context filename in repo root (defaults to AGENTS.md with CLAUDE.md fallback; ARCHITECTURE.md is always included when present)."
+              },
+              enable_tasks: {
+                type: "boolean",
+                description: "Optional: Enable task management for tracking multi-step progress. When enabled, the agent can create, track, and complete tasks.",
+                default: false
               }
             },
             required: ["query"]
@@ -71456,7 +72936,8 @@ var ProbeAgentMcpServer = class {
             maxResponseTokens: args.max_response_tokens,
             disableMermaidValidation: !!args.no_mermaid_validation,
             allowedTools: args.allowed_tools,
-            disableTools: args.disable_tools
+            disableTools: args.disable_tools,
+            enableTasks: !!args.enable_tasks
           };
           this.agent = new ProbeAgent(agentConfig2);
           await this.agent.initialize();
@@ -71700,7 +73181,8 @@ async function main() {
       enableSkills: !config.disableSkills,
       skillDirs: config.skillDirs,
       enableBash: config.enableBash,
-      bashConfig
+      bashConfig,
+      enableTasks: config.enableTasks
     };
     const agent = new ProbeAgent(agentConfig2);
     await agent.initialize();