@probelabs/probe 0.6.0-rc312 → 0.6.0-rc313

package/build/agent/ProbeAgent.js

@@ -350,6 +350,7 @@ export class ProbeAgent {
     // Task management configuration
     this.enableTasks = !!options.enableTasks;
     this.taskManager = null; // Initialized per-request in answer()
+    this.delegationTask = options.delegationTask || null; // Task description when this is a subagent
 
     // Per-instance delegation manager for concurrent delegation limits
     // Each ProbeAgent instance has its own limits, not shared globally
@@ -3350,14 +3351,19 @@ Follow these instructions carefully:
             this.toolImplementations.task = createTaskTool({
               taskManager: this.taskManager,
               tracer: this.tracer,
-              debug: this.debug
+              debug: this.debug,
+              delegationTask: this.delegationTask
             });
           }
 
           // Record telemetry for task initialization
           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',
             });
           }
 

package/build/agent/simpleTelemetry.js

@@ -136,9 +136,28 @@ export class SimpleTelemetry {
  * Simple tracer for application-level tracing
  */
 export class SimpleAppTracer {
-  constructor(telemetry, sessionId = null) {
+  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() {

package/build/agent/tasks/TaskManager.js

@@ -500,13 +500,28 @@ export class TaskManager {
 
       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;
     });
 
-    return `<task_status>\n${taskLines.join('\n')}\n</task_status>`;
+    // Add a brief status line so the AI can quickly assess progress
+    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>\n${statusLine}\n${taskLines.join('\n')}\n</task_status>`;
   }
 
   /**

package/build/agent/tasks/taskTool.js

@@ -42,50 +42,150 @@ export const taskToolDefinition = '';
 /**
  * Task system prompt addition - guidance for AI on when and how to use tasks
  */
-export const taskSystemPrompt = `[Task Management]
+export const taskSystemPrompt = `<task_management_system>
 
-Use the task tool to track progress on complex requests with multiple distinct goals.
+<purpose>
+Track progress on requests with multiple distinct goals using the task tool.
+Tasks are visible to the user in real time — keeping them accurate is critical.
+</purpose>
 
-## When to Use Tasks
-
-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" → two tasks
 - "Investigate auth, payments, AND notifications" → three tasks
-- "Implement X, then add tests, then update docs" → three sequential tasks
+- "Implement X, then add tests, then update docs" → three sequential tasks with dependencies
 
-SKIP tasks for single-goal requests, even complex ones:
-- "How does ranking work?" — just investigate and answer
-- "Explain the authentication flow" — just trace and explain
+DO NOT create tasks for single-goal requests, even complex ones:
+- "How does ranking work?" → just investigate and answer
+- "Explain the authentication flow" → just trace and explain
 Multiple internal steps (search, read, analyze) for one goal ≠ 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" → ONE task (same fix repeated)
 - "Update API + tests + docs" → THREE tasks (different work types)
-- Max 3–4 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 → implement → 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 — Create the new task depending on the predecessor:
+  action: "create", id: "review", title: "Code review", dependencies: ["implement"], after: "implement"
+Step 2 — Update the successor to depend on the new task:
+  action: "update", id: "test", dependencies: ["review"]
+Original: design → implement → test
+Result:   design → implement → review → 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 — 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 — 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 — 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 — stale status is misleading
+</system_enforcement>
+
+</task_management_system>
 `;
 
 /**
  * Task guidance to inject at start of request
  */
-export const taskGuidancePrompt = `Does this request have MULTIPLE DISTINCT GOALS?
+export const taskGuidancePrompt = `<task_decision>
+Does this request have MULTIPLE DISTINCT GOALS?
 - "Do A AND B AND C" (multiple goals) → Create tasks for each goal
+- "Do X, then Y, then Z" (sequential goals) → Create tasks with dependencies: Y depends on X, Z depends on Y
 - "Investigate/explain/find X" (single goal) → Skip tasks, just answer directly
 Multiple internal steps for ONE goal = NO tasks needed.
-If creating tasks, use the task tool with action="create" first.`;
+If creating tasks: call the task tool with action="create" and a tasks array FIRST, using dependencies for ordering.
+CRITICAL: Complete each task IMMEDIATELY when its work is done — do not defer completions.
+</task_decision>`;
 
 /**
  * Create task completion blocked message
@@ -93,40 +193,129 @@ If creating tasks, use the task tool with action="create" first.`;
  * @returns {string} Formatted message
  */
 export 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 → action="complete", id="<task-id>"
+- Work is NOT needed → action="update", id="<task-id>", status="cancelled"
+- Work is BLOCKED → complete its dependencies first, then return to it
+- Work is NOT started → set to "in_progress" and do the work, then complete it
+</required_actions>
+
+You will continue to be blocked until every task is completed or cancelled.
+</task_completion_blocked>`;
+}
+
+/**
+ * Monotonic event sequence counter for deterministic replay ordering.
+ * Shared across all task tool instances within the same process.
+ * Node.js is single-threaded so no race condition is possible.
+ * Resets at Number.MAX_SAFE_INTEGER to prevent overflow.
+ */
+let _globalSequence = 0;
+
+/** @internal Reset the global sequence counter (for testing only). */
+export function _resetSequence() { _globalSequence = 0; }
 
-After all tasks are resolved, provide your final answer.`;
+/**
+ * Safe JSON.stringify wrapper that returns '[]' on failure.
+ * @param {*} value - Value to serialize
+ * @returns {string} JSON string or fallback
+ */
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return '[]';
+  }
+}
+
+/**
+ * Serialize a task object into a flat telemetry-friendly payload.
+ * @param {Object} task - Task from TaskManager
+ * @param {number} index - Position in the task list (0-based)
+ * @returns {Object} Flat task payload
+ */
+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,
+  };
 }
 
 /**
  * Create task tool instance
  * @param {Object} options - Configuration options
  * @param {import('./TaskManager.js').TaskManager} options.taskManager - TaskManager instance
- * @param {Object} [options.tracer] - Optional tracer for telemetry
+ * @param {Object} [options.tracer] - Optional tracer for telemetry (SimpleAppTracer with session hierarchy)
  * @param {boolean} [options.debug=false] - Enable debug logging
+ * @param {string} [options.delegationTask] - Description of the delegated task (if this is a subagent)
  * @returns {Object} Tool instance with execute function
  */
 export 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');
   }
 
   /**
-   * Record task telemetry event
+   * Build the agent scope fields from the tracer's session hierarchy.
+   * These fields are included in every emitted task event so consumers
+   * can group events by agent/subagent without relying on span ancestry.
+   * @returns {Object} Agent scope attributes
+   */
+  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 } : {}),
+    };
+  };
+
+  /**
+   * Build global task-list context fields (total count, incomplete remaining).
+   * @param {Array} [allTasks] - Pre-fetched task list to avoid redundant calls
+   * @returns {Object}
+   */
+  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,
+    };
+  };
+
+  /**
+   * Record task telemetry event with agent scope and monotonic sequence.
    * @param {string} eventType - Event type (created, updated, completed, deleted, listed, error)
    * @param {Object} data - Event data
    */
   const recordTaskEvent = (eventType, data = {}) => {
     if (tracer && typeof tracer.recordTaskEvent === 'function') {
-      tracer.recordTaskEvent(eventType, data);
+      if (_globalSequence >= Number.MAX_SAFE_INTEGER) _globalSequence = 0;
+      try {
+        tracer.recordTaskEvent(eventType, {
+          'task.sequence': ++_globalSequence,
+          ...getAgentScope(),
+          ...data
+        });
+      } catch (err) {
+        if (debug) console.error('[TaskTool] Failed to record telemetry event:', err);
+      }
     }
   };
 
@@ -167,25 +356,30 @@ export function createTaskTool(options = {}) {
             if (tasks && Array.isArray(tasks)) {
               // Batch create
               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}\n\n${taskManager.formatTasksForPrompt()}`;
+              return `Created ${created.length} tasks: ${created.map(t => t.id).join(', ')}\n\n${taskManager.formatTasksForPrompt()}`;
             } else if (title) {
               // Single create
               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}\n\n${taskManager.formatTasksForPrompt()}`;
             } else {
@@ -197,13 +391,15 @@ export function createTaskTool(options = {}) {
             if (tasks && Array.isArray(tasks)) {
               // Batch update
               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}\n\n${taskManager.formatTasksForPrompt()}`;
+              return `Updated ${updated.length} tasks: ${updated.map(t => t.id).join(', ')}\n\n${taskManager.formatTasksForPrompt()}`;
             } else if (id) {
               // Single update
               const updates = {};
@@ -214,11 +410,18 @@ export function createTaskTool(options = {}) {
               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}\n\n${taskManager.formatTasksForPrompt()}`;
             } else {
@@ -235,21 +438,29 @@ export function createTaskTool(options = {}) {
                 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\n\n${taskManager.formatTasksForPrompt()}`;
             } else if (id) {
               // Single complete
               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}\n\n${taskManager.formatTasksForPrompt()}`;
             } else {
@@ -265,21 +476,26 @@ export function createTaskTool(options = {}) {
                 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`);
               });
+              // Capture task data before deletion for the event
+              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(', ')}\n\n${taskManager.formatTasksForPrompt()}`;
             } else if (id) {
-              // Single delete
+              // Capture task data before deletion
+              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}\n\n${taskManager.formatTasksForPrompt()}`;
             } else {
@@ -289,12 +505,13 @@ export function createTaskTool(options = {}) {
 
           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();
           }

package/build/delegate.js

@@ -484,7 +484,10 @@ export async function delegate({
 			disableJsonValidation: true,     // 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 — events will not be scoped to subagent'), tracer),
+			delegationTask: task,
 			path,       // Workspace root (from delegateTool)
 			allowedFolders, // Inherit allowed folders to keep architecture context root consistent
 			cwd: path,  // Explicitly set cwd to workspace root to prevent path doubling