@probelabs/probe 0.6.0-rc312 → 0.6.0-rc314

package/cjs/agent/ProbeAgent.cjs

@@ -17714,7 +17714,7 @@ var init_dist2 = __esm({
       "ETIMEDOUT",
       "EPIPE"
     ];
-    VERSION = true ? "4.0.21" : "0.0.0-test";
+    VERSION = true ? "4.0.22" : "0.0.0-test";
     suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
     suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
     ignoreOverride = /* @__PURE__ */ Symbol(
@@ -20482,33 +20482,36 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
                   providerOptions: part.providerOptions,
                   schema: bedrockReasoningMetadataSchema
                 });
-                if (reasoningMetadata != null) {
-                  if (reasoningMetadata.signature != null) {
-                    bedrockContent.push({
-                      reasoningContent: {
-                        reasoningText: {
-                          // trim the last text part if it's the last message in the block
-                          // because Bedrock does not allow trailing whitespace
-                          // in pre-filled assistant responses
-                          text: trimIfLast(
-                            isLastBlock,
-                            isLastMessage,
-                            isLastContentPart,
-                            part.text
-                          ),
-                          signature: reasoningMetadata.signature
-                        }
+                if ((reasoningMetadata == null ? void 0 : reasoningMetadata.signature) != null) {
+                  bedrockContent.push({
+                    reasoningContent: {
+                      reasoningText: {
+                        text: part.text,
+                        signature: reasoningMetadata.signature
                       }
-                    });
-                  } else if (reasoningMetadata.redactedData != null) {
-                    bedrockContent.push({
-                      reasoningContent: {
-                        redactedReasoning: {
-                          data: reasoningMetadata.redactedData
-                        }
+                    }
+                  });
+                } else if ((reasoningMetadata == null ? void 0 : reasoningMetadata.redactedData) != null) {
+                  bedrockContent.push({
+                    reasoningContent: {
+                      redactedReasoning: {
+                        data: reasoningMetadata.redactedData
                       }
-                    });
-                  }
+                    }
+                  });
+                } else {
+                  bedrockContent.push({
+                    reasoningContent: {
+                      reasoningText: {
+                        text: trimIfLast(
+                          isLastBlock,
+                          isLastMessage,
+                          isLastContentPart,
+                          part.text
+                        )
+                      }
+                    }
+                  });
                 }
                 break;
               }
@@ -20954,7 +20957,17 @@ var init_dist3 = __esm({
       /**
        * Anthropic beta features to enable
        */
-      anthropicBeta: external_exports.array(external_exports.string()).optional()
+      anthropicBeta: external_exports.array(external_exports.string()).optional(),
+      /**
+       * Service tier for the request.
+       * @see https://docs.aws.amazon.com/bedrock/latest/userguide/service-tiers-inference.html
+       *
+       * - 'reserved': Uses provisioned throughput capacity
+       * - 'priority': Prioritizes low-latency inference when capacity is available
+       * - 'default': Standard on-demand tier
+       * - 'flex': Lower-cost tier for flexible latency workloads
+       */
+      serviceTier: external_exports.enum(["reserved", "priority", "default", "flex"]).optional()
     });
     BedrockErrorSchema = external_exports.object({
       message: external_exports.string(),
@@ -21244,6 +21257,7 @@ var init_dist3 = __esm({
         const {
           reasoningConfig: _,
           additionalModelRequestFields: __,
+          serviceTier: ___,
           ...filteredBedrockOptions
         } = (providerOptions == null ? void 0 : providerOptions.bedrock) || {};
         const additionalModelResponseFieldPaths = isAnthropicModel ? ["/delta/stop_sequence"] : void 0;
@@ -21258,6 +21272,11 @@ var init_dist3 = __esm({
             ...Object.keys(inferenceConfig).length > 0 && {
               inferenceConfig
             },
+            ...bedrockOptions.serviceTier != null && {
+              serviceTier: {
+                type: bedrockOptions.serviceTier
+              }
+            },
             ...filteredBedrockOptions,
             ...toolConfig.tools !== void 0 && toolConfig.tools.length > 0 ? { toolConfig } : {}
           },
@@ -22166,7 +22185,7 @@ var init_dist3 = __esm({
       details: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
       preview: external_exports.unknown().optional()
     });
-    VERSION2 = true ? "4.0.83" : "0.0.0-test";
+    VERSION2 = true ? "4.0.89" : "0.0.0-test";
     bedrockRerankingResponseSchema = lazySchema(
       () => zodSchema(
         external_exports.object({
@@ -24340,10 +24359,28 @@ var init_simpleTelemetry = __esm({
         }
       }
     };
-    SimpleAppTracer = class {
-      constructor(telemetry, sessionId = null) {
+    SimpleAppTracer = class _SimpleAppTracer {
+      constructor(telemetry, sessionId = null, options = {}) {
         this.telemetry = telemetry;
         this.sessionId = sessionId || this.generateSessionId();
+        this.parentSessionId = options.parentSessionId || null;
+        this.rootSessionId = options.rootSessionId || this.sessionId;
+        this.agentKind = options.agentKind || "main";
+      }
+      /**
+       * Create a child tracer for a delegated subagent.
+       * Inherits the same telemetry backend but scopes events to the child session.
+       * @param {string} childSessionId - The subagent's session ID
+       * @param {Object} [options] - Additional options
+       * @param {string} [options.agentKind='delegate'] - Kind of child agent
+       * @returns {SimpleAppTracer} A new tracer scoped to the child session
+       */
+      createChildTracer(childSessionId, options = {}) {
+        return new _SimpleAppTracer(this.telemetry, childSessionId, {
+          parentSessionId: this.sessionId,
+          rootSessionId: this.rootSessionId,
+          agentKind: options.agentKind || "delegate"
+        });
       }
       generateSessionId() {
         return Math.random().toString(36).substring(2, 15);
@@ -26909,7 +26946,8 @@ async function delegate({
       // Simpler responses
       maxIterations: remainingIterations,
       debug,
-      tracer,
+      tracer: tracer && typeof tracer.createChildTracer === "function" ? tracer.createChildTracer(sessionId, { agentKind: "delegate" }) : (tracer && debug && console.warn("[delegate] createChildTracer not available, using parent tracer \u2014 events will not be scoped to subagent"), tracer),
+      delegationTask: task,
       path: path9,
       // Workspace root (from delegateTool)
       allowedFolders,
@@ -50916,11 +50954,21 @@ var init_TaskManager = __esm({
           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 (task.dependencies.length > 0) line += ` depends_on="${this._escapeXml(task.dependencies.join(","))}"`;
           if (blockers.length > 0) line += ` blocked_by="${this._escapeXml(blockers.join(","))}"`;
           line += `>${this._escapeXml(task.title)}</task>`;
           return line;
         });
+        let completed = 0, inProgress = 0, pending = 0, cancelled = 0;
+        for (const t of tasks) {
+          if (t.status === "completed") completed++;
+          else if (t.status === "in_progress") inProgress++;
+          else if (t.status === "pending") pending++;
+          else if (t.status === "cancelled") cancelled++;
+        }
+        const statusLine = `  <!-- ${completed}/${tasks.length} completed` + (inProgress > 0 ? `, ${inProgress} in progress` : "") + (pending > 0 ? `, ${pending} pending` : "") + (cancelled > 0 ? `, ${cancelled} cancelled` : "") + ` -->`;
         return `<task_status>
+${statusLine}
 ${taskLines.join("\n")}
 </task_status>`;
       }
@@ -51046,24 +51094,76 @@ ${taskLines.join("\n")}
 
 // src/agent/tasks/taskTool.js
 function createTaskCompletionBlockedMessage(taskSummary) {
-  return `You cannot complete yet. The following tasks are still unresolved:
+  return `<task_completion_blocked>
+You CANNOT provide a final answer yet. There are unresolved tasks:
 
 ${taskSummary}
 
-For each pending/in_progress task, either:
-- Complete it: call task tool with action="complete", id="task-X"
-- Cancel it: call task tool with action="update", id="task-X", status="cancelled"
+<required_actions>
+For EACH unresolved task, do ONE of the following RIGHT NOW:
+- Work is DONE \u2192 action="complete", id="<task-id>"
+- Work is NOT needed \u2192 action="update", id="<task-id>", status="cancelled"
+- Work is BLOCKED \u2192 complete its dependencies first, then return to it
+- Work is NOT started \u2192 set to "in_progress" and do the work, then complete it
+</required_actions>
 
-After all tasks are resolved, provide your final answer.`;
+You will continue to be blocked until every task is completed or cancelled.
+</task_completion_blocked>`;
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "[]";
+  }
+}
+function serializeTask(task, index) {
+  return {
+    id: task.id,
+    title: task.title,
+    status: task.status,
+    priority: task.priority || null,
+    dependencies: task.dependencies || [],
+    after: null,
+    // 'after' is an insertion hint, not stored on the task
+    order: index
+  };
 }
 function createTaskTool(options = {}) {
-  const { taskManager, tracer, debug = false } = options;
+  const { taskManager, tracer, debug = false, delegationTask = null } = options;
   if (!taskManager) {
     throw new Error("TaskManager instance is required");
   }
+  const getAgentScope = () => {
+    if (!tracer) return {};
+    return {
+      "agent.session_id": tracer.sessionId || null,
+      "agent.parent_session_id": tracer.parentSessionId || null,
+      "agent.root_session_id": tracer.rootSessionId || null,
+      "agent.kind": tracer.agentKind || "main",
+      ...delegationTask ? { "delegation.task": delegationTask } : {}
+    };
+  };
+  const getListContext = (allTasks) => {
+    const all = allTasks || taskManager.listTasks();
+    const incompleteCount = all.filter((t) => t.status !== "completed" && t.status !== "cancelled").length;
+    return {
+      "task.total_count": all.length,
+      "task.incomplete_remaining": incompleteCount
+    };
+  };
   const recordTaskEvent = (eventType, data2 = {}) => {
     if (tracer && typeof tracer.recordTaskEvent === "function") {
-      tracer.recordTaskEvent(eventType, data2);
+      if (_globalSequence >= Number.MAX_SAFE_INTEGER) _globalSequence = 0;
+      try {
+        tracer.recordTaskEvent(eventType, {
+          "task.sequence": ++_globalSequence,
+          ...getAgentScope(),
+          ...data2
+        });
+      } catch (err) {
+        if (debug) console.error("[TaskTool] Failed to record telemetry event:", err);
+      }
     }
   };
   return {
@@ -51097,26 +51197,31 @@ function createTaskTool(options = {}) {
           case "create": {
             if (tasks && Array.isArray(tasks)) {
               const created = taskManager.createTasks(tasks);
-              const ids = created.map((t) => t.id).join(", ");
+              const allTasks = taskManager.listTasks();
+              const taskIndex = new Map(allTasks.map((t, i) => [t.id, i]));
               recordTaskEvent("batch_created", {
                 "task.action": "create",
                 "task.count": created.length,
-                "task.ids": ids,
-                "task.total_count": taskManager.listTasks().length
+                "task.items_json": safeStringify(created.map((t) => serializeTask(t, taskIndex.get(t.id) ?? 0))),
+                ...getListContext(allTasks)
               });
-              return `Created ${created.length} tasks: ${ids}
+              return `Created ${created.length} tasks: ${created.map((t) => t.id).join(", ")}
 
 ${taskManager.formatTasksForPrompt()}`;
             } else if (title) {
               const task = taskManager.createTask({ title, description, priority, dependencies, after });
+              const allTasks = taskManager.listTasks();
+              const order = allTasks.findIndex((t) => t.id === task.id);
               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
+                "task.title": task.title,
+                "task.status": task.status,
+                "task.priority": task.priority || null,
+                "task.dependencies": safeStringify(task.dependencies || []),
+                "task.after": after || null,
+                "task.order": order,
+                ...getListContext(allTasks)
               });
               return `Created task ${task.id}: ${task.title}
 
@@ -51128,13 +51233,15 @@ ${taskManager.formatTasksForPrompt()}`;
           case "update": {
             if (tasks && Array.isArray(tasks)) {
               const updated = taskManager.updateTasks(tasks);
-              const ids = updated.map((t) => t.id).join(", ");
+              const allTasks = taskManager.listTasks();
+              const taskIndex = new Map(allTasks.map((t, i) => [t.id, i]));
               recordTaskEvent("batch_updated", {
                 "task.action": "update",
                 "task.count": updated.length,
-                "task.ids": ids
+                "task.items_json": safeStringify(updated.map((t) => serializeTask(t, taskIndex.get(t.id) ?? 0))),
+                ...getListContext(allTasks)
               });
-              return `Updated ${updated.length} tasks: ${ids}
+              return `Updated ${updated.length} tasks: ${updated.map((t) => t.id).join(", ")}
 
 ${taskManager.formatTasksForPrompt()}`;
             } else if (id) {
@@ -51145,11 +51252,18 @@ ${taskManager.formatTasksForPrompt()}`;
               if (priority) updates.priority = priority;
               if (dependencies) updates.dependencies = dependencies;
               const task = taskManager.updateTask(id, updates);
+              const allTasks = taskManager.listTasks();
+              const order = allTasks.findIndex((t) => t.id === task.id);
               recordTaskEvent("updated", {
                 "task.action": "update",
-                "task.id": id,
-                "task.new_status": status || "unchanged",
-                "task.fields_updated": Object.keys(updates).join(", ")
+                "task.id": task.id,
+                "task.title": task.title,
+                "task.status": task.status,
+                "task.priority": task.priority || null,
+                "task.dependencies": safeStringify(task.dependencies || []),
+                "task.order": order,
+                "task.fields_updated": Object.keys(updates).join(", "),
+                ...getListContext(allTasks)
               });
               return `Updated task ${task.id}
 
@@ -51166,22 +51280,30 @@ ${taskManager.formatTasksForPrompt()}`;
                 throw new Error(`Invalid task item at index ${index}: must be a string ID or object with 'id' property`);
               });
               const completed = taskManager.completeTasks(ids);
+              const allTasks = taskManager.listTasks();
+              const taskIndex = new Map(allTasks.map((t, i) => [t.id, i]));
               recordTaskEvent("batch_completed", {
                 "task.action": "complete",
                 "task.count": completed.length,
-                "task.ids": ids.join(", "),
-                "task.incomplete_remaining": taskManager.getIncompleteTasks().length
+                "task.items_json": safeStringify(completed.map((t) => serializeTask(t, taskIndex.get(t.id) ?? 0))),
+                ...getListContext(allTasks)
               });
               return `Completed ${completed.length} tasks
 
 ${taskManager.formatTasksForPrompt()}`;
             } else if (id) {
               const task = taskManager.completeTask(id);
+              const allTasks = taskManager.listTasks();
+              const order = allTasks.findIndex((t) => t.id === task.id);
               recordTaskEvent("completed", {
                 "task.action": "complete",
-                "task.id": id,
+                "task.id": task.id,
                 "task.title": task.title,
-                "task.incomplete_remaining": taskManager.getIncompleteTasks().length
+                "task.status": task.status,
+                "task.priority": task.priority || null,
+                "task.dependencies": safeStringify(task.dependencies || []),
+                "task.order": order,
+                ...getListContext(allTasks)
               });
               return `Completed task ${task.id}: ${task.title}
 
@@ -51197,22 +51319,26 @@ ${taskManager.formatTasksForPrompt()}`;
                 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 tasksBefore = ids.map((tid) => taskManager.getTask(tid)).filter(Boolean);
               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
+                "task.items_json": safeStringify(tasksBefore.map((t, i) => ({ id: t.id, title: t.title, status: t.status }))),
+                ...getListContext()
               });
               return `Deleted ${deleted.length} tasks: ${deleted.join(", ")}
 
 ${taskManager.formatTasksForPrompt()}`;
             } else if (id) {
+              const taskBefore = taskManager.getTask(id);
               taskManager.deleteTask(id);
               recordTaskEvent("deleted", {
                 "task.action": "delete",
                 "task.id": id,
-                "task.total_count": taskManager.listTasks().length
+                "task.title": taskBefore?.title || null,
+                "task.status": taskBefore?.status || null,
+                ...getListContext()
               });
               return `Deleted task ${id}
 
@@ -51223,12 +51349,13 @@ ${taskManager.formatTasksForPrompt()}`;
           }
           case "list": {
             const allTasks = taskManager.listTasks();
-            const incomplete = taskManager.getIncompleteTasks();
+            const ctx = getListContext(allTasks);
             recordTaskEvent("listed", {
               "task.action": "list",
-              "task.total_count": allTasks.length,
-              "task.incomplete_count": incomplete.length,
-              "task.completed_count": allTasks.length - incomplete.length
+              "task.total_count": ctx["task.total_count"],
+              "task.incomplete_count": ctx["task.incomplete_remaining"],
+              "task.completed_count": ctx["task.total_count"] - ctx["task.incomplete_remaining"],
+              "task.items_json": safeStringify(allTasks.map((t, i) => serializeTask(t, i)))
             });
             return taskManager.formatTasksForPrompt();
           }
@@ -51251,7 +51378,7 @@ ${taskManager.formatTasksForPrompt()}`;
     }
   };
 }
-var taskItemSchema, taskSchema, taskSystemPrompt;
+var taskItemSchema, taskSchema, taskSystemPrompt, _globalSequence;
 var init_taskTool = __esm({
   "src/agent/tasks/taskTool.js"() {
     "use strict";
@@ -51277,41 +51404,138 @@ var init_taskTool = __esm({
       dependencies: external_exports2.array(external_exports2.string()).optional(),
       after: external_exports2.string().optional()
     });
-    taskSystemPrompt = `[Task Management]
-
-Use the task tool to track progress on complex requests with multiple distinct goals.
+    taskSystemPrompt = `<task_management_system>
 
-## When to Use Tasks
+<purpose>
+Track progress on requests with multiple distinct goals using the task tool.
+Tasks are visible to the user in real time \u2014 keeping them accurate is critical.
+</purpose>
 
-CREATE tasks when the request has **multiple separate deliverables**:
+<when_to_use_tasks>
+CREATE tasks when the request has multiple separate deliverables:
 - "Fix bug A AND add feature B" \u2192 two tasks
 - "Investigate auth, payments, AND notifications" \u2192 three tasks
-- "Implement X, then add tests, then update docs" \u2192 three sequential tasks
+- "Implement X, then add tests, then update docs" \u2192 three sequential tasks with dependencies
 
-SKIP tasks for single-goal requests, even complex ones:
-- "How does ranking work?" \u2014 just investigate and answer
-- "Explain the authentication flow" \u2014 just trace and explain
+DO NOT create tasks for single-goal requests, even complex ones:
+- "How does ranking work?" \u2192 just investigate and answer
+- "Explain the authentication flow" \u2192 just trace and explain
 Multiple internal steps (search, read, analyze) for one goal \u2260 multiple tasks.
 
-## Granularity
-
-Tasks = logical units of work, not files or steps.
+Granularity: tasks = logical units of work, not individual files or steps.
 - "Fix 8 similar test files" \u2192 ONE task (same fix repeated)
 - "Update API + tests + docs" \u2192 THREE tasks (different work types)
-- Max 3\u20134 tasks. More means you're too granular.
-
-## Workflow
-
-1. **Plan**: Call task tool with action="create" and a tasks array up front
-2. **Execute**: Update status to "in_progress" / "completed" as you work. Add, split, or cancel tasks as you learn more.
-3. **Finish**: All tasks must be "completed" or "cancelled" before providing your final answer.
-
-## Rules
-
-- Dependencies are enforced: a task cannot start until its dependencies are completed
+</when_to_use_tasks>
+
+<dependency_chains>
+Use dependencies to enforce ordering. A task CANNOT start until ALL its dependencies are completed.
+
+<pattern name="sequential_chain" description="Tasks that must happen in strict order">
+tasks: [
+  { id: "design", title: "Design the API schema" },
+  { id: "implement", title: "Implement endpoints", dependencies: ["design"] },
+  { id: "test", title: "Write integration tests", dependencies: ["implement"] }
+]
+Result: design \u2192 implement \u2192 test. "implement" is blocked until "design" is completed.
+</pattern>
+
+<pattern name="fan_out" description="Multiple tasks unlock after one prerequisite">
+tasks: [
+  { id: "setup", title: "Set up database" },
+  { id: "auth", title: "Add auth module", dependencies: ["setup"] },
+  { id: "api", title: "Add API routes", dependencies: ["setup"] }
+]
+Result: both "auth" and "api" become ready once "setup" is completed.
+</pattern>
+
+<pattern name="fan_in" description="One task waits for multiple prerequisites">
+tasks: [
+  { id: "auth", title: "Auth module" },
+  { id: "api", title: "API routes" },
+  { id: "e2e", title: "End-to-end tests", dependencies: ["auth", "api"] }
+]
+Result: "e2e" is blocked until both "auth" and "api" are completed.
+</pattern>
+</dependency_chains>
+
+<modifying_tasks_mid_work>
+When new requirements emerge during execution, modify the task plan dynamically.
+
+<technique name="add_subtask">
+Add a new task after an existing one, with a dependency to enforce order:
+  action: "create", id: "fix-edge-case", title: "Handle null input edge case",
+    dependencies: ["implement"], after: "implement"
+</technique>
+
+<technique name="split_task">
+If a task is bigger than expected, create subtasks with dependencies on it, then complete or cancel the original.
+</technique>
+
+<technique name="insert_into_chain">
+Insert a new task between two existing tasks in a chain:
+Step 1 \u2014 Create the new task depending on the predecessor:
+  action: "create", id: "review", title: "Code review", dependencies: ["implement"], after: "implement"
+Step 2 \u2014 Update the successor to depend on the new task:
+  action: "update", id: "test", dependencies: ["review"]
+Original: design \u2192 implement \u2192 test
+Result:   design \u2192 implement \u2192 review \u2192 test
+</technique>
+</modifying_tasks_mid_work>
+
+<workflow_rules>
+These rules are MANDATORY. Violating them produces incorrect progress tracking.
+
+<rule id="1" name="plan_first">
+Call task tool with action="create" and a tasks array BEFORE starting any work.
+Use dependencies to express ordering constraints between tasks.
+</rule>
+
+<rule id="2" name="mark_in_progress">
+Set the current task to status="in_progress" BEFORE you begin working on it.
+Only one task should be in_progress at a time.
+</rule>
+
+<rule id="3" name="complete_immediately" priority="critical">
+The MOMENT you finish a task's work, call the task tool with action="complete" for that task.
+Do this in the SAME response \u2014 not in the next step, not at the end, not batched with other completions.
+Every task must be completed the instant its work is verified done.
+</rule>
+
+<rule id="4" name="verify_before_completing">
+Do NOT mark a task completed unless you have verified the result:
+- Code compiles without errors
+- Tests pass
+- Output is correct and complete
+"I wrote the code" is NOT sufficient \u2014 you must confirm it works.
+</rule>
+
+<rule id="5" name="respect_dependencies">
+NEVER work on a task whose dependencies are not yet completed.
+The task list shows blocked_by attributes \u2014 check them. If a task is blocked, complete its blockers first.
+</rule>
+
+<rule id="6" name="adapt_the_plan">
+If you discover new work during execution, create new tasks with proper dependencies.
+Do NOT silently do extra work without tracking it in the task list.
+If a task needs subtasks, create them as new tasks depending on the current one.
+</rule>
+
+<rule id="7" name="finish_clean">
+ALL tasks must be "completed" or "cancelled" before you provide your final answer.
+You CANNOT finish with pending or in_progress tasks. The system will block you.
+</rule>
+</workflow_rules>
+
+<system_enforcement>
+- Dependencies are strictly enforced: blocked tasks cannot be started
 - Circular dependencies are rejected
-- Completion is blocked while tasks remain unresolved
+- You will be blocked from finishing while tasks remain unresolved
+- Task status is visible to the user in real time \u2014 stale status is misleading
+</system_enforcement>
+
+</task_management_system>
 `;
+    _globalSequence = 0;
   }
 });
 
@@ -82008,12 +82232,12 @@ var require_code = __commonJS({
     exports2._ = _;
     var plus = new _Code("+");
     function str(strs, ...args) {
-      const expr = [safeStringify(strs[0])];
+      const expr = [safeStringify2(strs[0])];
       let i = 0;
       while (i < args.length) {
         expr.push(plus);
         addCodeArg(expr, args[i]);
-        expr.push(plus, safeStringify(strs[++i]));
+        expr.push(plus, safeStringify2(strs[++i]));
       }
       optimize(expr);
       return new _Code(expr);
@@ -82065,16 +82289,16 @@ var require_code = __commonJS({
     }
     exports2.strConcat = strConcat;
     function interpolate(x) {
-      return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify(Array.isArray(x) ? x.join(",") : x);
+      return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify2(Array.isArray(x) ? x.join(",") : x);
     }
     function stringify(x) {
-      return new _Code(safeStringify(x));
+      return new _Code(safeStringify2(x));
     }
     exports2.stringify = stringify;
-    function safeStringify(x) {
+    function safeStringify2(x) {
       return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
     }
-    exports2.safeStringify = safeStringify;
+    exports2.safeStringify = safeStringify2;
     function getProperty(key) {
       return typeof key == "string" && exports2.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`;
     }
@@ -101280,6 +101504,7 @@ var init_ProbeAgent = __esm({
         this._mcpInitialized = false;
         this.enableTasks = !!options.enableTasks;
         this.taskManager = null;
+        this.delegationTask = options.delegationTask || null;
         this.delegationManager = new DelegationManager();
         this.concurrencyLimiter = options.concurrencyLimiter || null;
         this.requestTimeout = options.requestTimeout ?? (() => {
@@ -103726,12 +103951,17 @@ You are working with a workspace. Available paths: ${workspaceDesc}
                 this.toolImplementations.task = createTaskTool({
                   taskManager: this.taskManager,
                   tracer: this.tracer,
-                  debug: this.debug
+                  debug: this.debug,
+                  delegationTask: this.delegationTask
                 });
               }
               if (this.tracer && typeof this.tracer.recordTaskEvent === "function") {
                 this.tracer.recordTaskEvent("session_started", {
-                  "task.enabled": true
+                  "task.enabled": true,
+                  "agent.session_id": this.tracer?.sessionId ?? null,
+                  "agent.parent_session_id": this.tracer?.parentSessionId ?? null,
+                  "agent.root_session_id": this.tracer?.rootSessionId ?? null,
+                  "agent.kind": this.tracer?.agentKind ?? "main"
                 });
               }
               if (this.debug) {