@probelabs/probe 0.6.0-rc311 → 0.6.0-rc313

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.82" : "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,
@@ -42349,7 +42387,7 @@ var require_brace_expansion = __commonJS({
           var x = numeric(n[0]);
           var y = numeric(n[1]);
           var width = Math.max(n[0].length, n[1].length);
-          var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
+          var incr = n.length == 3 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
           var test = lte;
           var reverse = y < x;
           if (reverse) {
@@ -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) {
@@ -104288,7 +104518,27 @@ IMPORTANT: This is a time budget constraint, NOT a system shutdown or error. The
 
 Do NOT say things like "the system is shutting down" or "try again later" \u2014 the user submitted a request and is waiting for YOUR answer right now.
 
-Provide your BEST answer NOW using the information you have already gathered. Do NOT call any more tools. Summarize your findings and respond completely. If something was not completed, honestly state what was not done and provide any partial results or recommendations you can offer.`
+You MUST now produce a detailed PROGRESS REPORT so that a follow-up agent can continue your work without starting over. Structure your response as follows:
+
+## Task
+What was the original request / goal.
+
+## Completed Work
+What you successfully accomplished \u2014 include ALL findings, code snippets, file paths, data, and conclusions gathered. Be specific and include actual content, not just descriptions.
+
+## Key Findings
+Concrete facts, answers, or data points you discovered. Include file paths with line numbers, code snippets, configuration values, etc.
+
+## Attempted but Inconclusive
+What you tried that did not yield clear results \u2014 include the approach and why it was inconclusive, so the next agent does not repeat it.
+
+## Not Started / Remaining
+What parts of the task you did not get to, and any recommendations for how to approach them.
+
+## Suggested Next Steps
+Specific, actionable steps for a follow-up agent to continue this work efficiently.
+
+IMPORTANT: Include ALL useful data you gathered inline \u2014 do not just say "I found X", actually include X. The next agent will only see this report, not your tool call history.`
                       };
                     }
                     if (this.debug) {
@@ -104297,11 +104547,39 @@ Provide your BEST answer NOW using the information you have already gathered. Do
                     return { toolChoice: "none" };
                   }
                   if (stepNumber === maxIterations - 1) {
-                    const searchesTried = _toolCallLog.filter((tc) => tc.name === "search").map((tc) => `"${tc.args.query || ""}"${tc.args.exact ? " (exact)" : ""}`).filter((v, i, a) => a.indexOf(v) === i);
-                    const searchSummary = searchesTried.length > 0 ? `
-Searches attempted: ${searchesTried.join(", ")}` : "";
+                    const toolActivity = _toolCallLog.filter((tc) => tc.name !== "_assistant_text").map((tc) => {
+                      const argStr = tc.name === "search" ? `query="${tc.args.query || ""}"${tc.args.exact ? " exact" : ""} path=${tc.args.path || "."}` : JSON.stringify(tc.args || {}).substring(0, 200);
+                      const brief = tc.resultBrief ? ` \u2192 ${tc.resultBrief.substring(0, 150)}` : "";
+                      return `  [step ${tc.step}] ${tc.name}(${argStr})${brief}`;
+                    }).join("\n");
+                    const activityLog = toolActivity ? `
+
+Tool activity so far:
+${toolActivity}` : "";
                     const isCodeSearcher = this.promptType === "code-searcher";
-                    const lastIterMessage = isCodeSearcher ? `\u26A0\uFE0F LAST ITERATION \u2014 you are out of tool calls. Output your JSON response NOW with whatever files you have verified so far. Set confidence to "low" if your search was incomplete. Include the "searches" array listing all search queries you made with their paths and outcomes.${searchSummary}` : `\u26A0\uFE0F LAST ITERATION \u2014 you are out of tool calls. Provide your BEST answer NOW with the information gathered so far. If you could not find what was requested, explain exactly what you searched for and why it did not work, so the caller can try a different approach.${searchSummary}`;
+                    const lastIterMessage = isCodeSearcher ? `\u26A0\uFE0F LAST ITERATION \u2014 you are out of tool calls. Output your JSON response NOW with whatever files you have verified so far. Set confidence to "low" if your search was incomplete. Include the "searches" array listing all search queries you made with their paths and outcomes.${activityLog}` : `\u26A0\uFE0F ITERATION LIMIT REACHED \u2014 you have no more tool calls. You MUST now produce a detailed PROGRESS REPORT so that a follow-up agent can continue your work without starting over.
+
+Structure your response as follows:
+
+## Task
+What was the original request / goal.
+
+## Completed Work
+What you successfully accomplished \u2014 include ALL findings, code snippets, file paths, data, and conclusions gathered. Be specific and include actual content, not just descriptions.
+
+## Key Findings
+Concrete facts, answers, or data points you discovered. Include file paths with line numbers, code snippets, configuration values, etc.
+
+## Attempted but Inconclusive
+What you tried that did not yield clear results \u2014 include the approach and why it was inconclusive, so the next agent does not repeat it.
+
+## Not Started / Remaining
+What parts of the task you did not get to, and any recommendations for how to approach them.
+
+## Suggested Next Steps
+Specific, actionable steps for a follow-up agent to continue this work efficiently.
+
+IMPORTANT: Include ALL useful data you gathered inline \u2014 do not just say "I found X", actually include X. The next agent will only see this report, not your tool call history.${activityLog}`;
                     return {
                       toolChoice: "none",
                       userMessage: lastIterMessage
@@ -104384,10 +104662,27 @@ Double-check your response based on the criteria above. If everything looks good
                   currentIteration++;
                   toolContext.currentIteration = currentIteration;
                   if (toolCalls?.length > 0) {
-                    for (const tc of toolCalls) {
-                      _toolCallLog.push({ name: tc.toolName, args: tc.args || {} });
+                    for (let i = 0; i < toolCalls.length; i++) {
+                      const tc = toolCalls[i];
+                      const tr = toolResults?.[i];
+                      let resultBrief = "";
+                      if (tr) {
+                        const raw = typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result);
+                        resultBrief = raw ? raw.substring(0, 500) : "";
+                      }
+                      const tcArgs = tc.args || (typeof tc.input === "string" ? (() => {
+                        try {
+                          return JSON.parse(tc.input);
+                        } catch {
+                          return {};
+                        }
+                      })() : tc.input) || {};
+                      _toolCallLog.push({ name: tc.toolName, args: tcArgs, resultBrief, step: currentIteration });
                     }
                   }
+                  if (text && text.trim()) {
+                    _toolCallLog.push({ name: "_assistant_text", args: {}, resultBrief: text.substring(0, 1e3), step: currentIteration });
+                  }
                   if (this.tracer) {
                     const stepEvent = {
                       "iteration": currentIteration,
@@ -104722,13 +105017,27 @@ Respond with ONLY valid JSON \u2014 no markdown, no explanation, no text outside
 
 IMPORTANT: This is a time budget constraint, NOT a system shutdown or error. The system is working perfectly \u2014 you simply used all your allocated time. Do NOT say things like "the system is shutting down" or "try again later." The user is waiting for your answer RIGHT NOW.
 
-Please provide a DETAILED summary of:
-1. What you were asked to do (the original task)
-2. What you accomplished \u2014 include ALL findings, code snippets, data, and conclusions you gathered
-3. What was still in progress or not yet started
-4. Any partial results or recommendations you can offer based on what you found so far${taskContext}${schemaContext}
+You MUST produce a detailed PROGRESS REPORT so that a follow-up agent can continue your work without starting over. Structure your response with these sections:
+
+## Task
+What was the original request / goal.
+
+## Completed Work
+What you successfully accomplished \u2014 include ALL findings, code snippets, file paths, data, and conclusions gathered. Be specific and include actual content, not just descriptions.
+
+## Key Findings
+Concrete facts, answers, or data points you discovered. Include file paths with line numbers, code snippets, configuration values, etc.
 
-Be thorough \u2014 this is the user's only response. Include all useful information you collected.`;
+## Attempted but Inconclusive
+What you tried that did not yield clear results \u2014 include the approach and why it was inconclusive, so the next agent does not repeat it.
+
+## Not Started / Remaining
+What parts of the task you did not get to, and any recommendations for how to approach them.
+
+## Suggested Next Steps
+Specific, actionable steps for a follow-up agent to continue this work efficiently.${taskContext}${schemaContext}
+
+IMPORTANT: Include ALL useful data you gathered inline \u2014 do not just say "I found X", actually include X. The next agent will only see this report, not your tool call history.`;
                   const summaryMessages = [
                     ...currentMessages,
                     { role: "user", content: summaryPrompt }
@@ -104841,18 +105150,24 @@ Be thorough \u2014 this is the user's only response. Include all useful informat
                 const searchQueries = [];
                 const searchDetails = [];
                 const toolCounts = {};
+                const toolTimeline = [];
                 for (const tc of _toolCallLog) {
+                  if (tc.name === "_assistant_text") continue;
                   toolCounts[tc.name] = (toolCounts[tc.name] || 0) + 1;
                   if (tc.name === "search") {
                     const q = tc.args.query || "";
                     const p = tc.args.path || ".";
                     const exact = tc.args.exact ? " (exact)" : "";
                     searchQueries.push(`"${q}"${exact}`);
-                    searchDetails.push({ query: q, path: p, had_results: false });
+                    searchDetails.push({ query: q, path: p, had_results: !!(tc.resultBrief && tc.resultBrief.trim()) });
                   }
+                  const argStr = tc.name === "search" ? `query="${tc.args.query || ""}"${tc.args.exact ? " exact" : ""}` : JSON.stringify(tc.args || {}).substring(0, 150);
+                  const brief = tc.resultBrief ? ` \u2192 ${tc.resultBrief.substring(0, 200)}` : " \u2192 (no result)";
+                  toolTimeline.push(`  [step ${tc.step}] ${tc.name}(${argStr})${brief}`);
                 }
                 const toolBreakdown = Object.entries(toolCounts).map(([name15, count]) => `${name15}: ${count}x`).join(", ");
                 const uniqueSearches = [...new Set(searchQueries)];
+                const assistantTexts = _toolCallLog.filter((tc) => tc.name === "_assistant_text" && tc.resultBrief).map((tc) => tc.resultBrief);
                 if (this.promptType === "code-searcher") {
                   finalResult = JSON.stringify({
                     confidence: "low",
@@ -104861,17 +105176,33 @@ Be thorough \u2014 this is the user's only response. Include all useful informat
                     searches: searchDetails
                   });
                 } else {
-                  let summary = `I was unable to complete your request after ${currentIteration} tool iterations.
+                  let summary = `## Progress Report (iteration limit reached after ${currentIteration} steps)
 
 `;
-                  summary += `Tool calls made: ${toolBreakdown || "none"}
+                  summary += `### Tool Usage Summary
+${toolBreakdown || "none"}
+
 `;
                   if (uniqueSearches.length > 0) {
-                    summary += `Search queries tried: ${uniqueSearches.join(", ")}
+                    summary += `### Search Queries Attempted
+${uniqueSearches.join(", ")}
+
+`;
+                  }
+                  if (toolTimeline.length > 0) {
+                    summary += `### Step-by-Step Activity Log
+${toolTimeline.join("\n")}
+
+`;
+                  }
+                  if (assistantTexts.length > 0) {
+                    summary += `### Partial Findings
+${assistantTexts.join("\n\n")}
+
 `;
                   }
-                  summary += `
-The search approach may be fundamentally wrong for this query. Consider: using exact=true for literal string matching, using bash/grep for pattern-based file searches, or trying a completely different strategy instead of repeating similar searches.`;
+                  summary += `### Recommendation for Follow-Up
+The iteration limit was reached before the task could be completed. A follow-up agent should review the activity log above to avoid repeating the same searches, and consider alternative approaches such as: using exact=true for literal string matching, using bash/grep for pattern-based file searches, or trying a different strategy.`;
                   finalResult = summary;
                 }
               } catch {