@agenticmail/enterprise 0.5.209 → 0.5.211

package/src/engine/task-queue-routes.ts

@@ -49,6 +49,28 @@ export function createTaskQueueRoutes(taskQueue: TaskQueueManager) {
     return c.json({ task });
   });
 
+  // GET /task-pipeline/chain/:chainId — full task chain (delegation flow)
+  router.get('/chain/:chainId', (c) => {
+    const chain = taskQueue.getTaskChain(c.req.param('chainId'));
+    if (!chain.length) return c.json({ error: 'Chain not found' }, 404);
+    return c.json({ chain });
+  });
+
+  // POST /task-pipeline/:id/delegate — delegate task to another agent
+  router.post('/:id/delegate', async (c) => {
+    const body = await c.req.json();
+    const task = await taskQueue.delegateTask(c.req.param('id'), {
+      toAgent: body.toAgent,
+      toAgentName: body.toAgentName || body.toAgent,
+      delegationType: body.delegationType || 'delegation',
+      title: body.title,
+      description: body.description,
+      priority: body.priority,
+    });
+    if (!task) return c.json({ error: 'Task not found' }, 404);
+    return c.json({ task }, 201);
+  });
+
   // POST /task-pipeline — create task manually
   router.post('/', async (c) => {
     const body = await c.req.json();

package/src/engine/task-queue.ts

@@ -58,6 +58,32 @@ export interface TaskRecord {
   modelUsed: string | null;      // actual model that executed
   tokensUsed: number;
   costUsd: number;
+
+  // Task chain (multi-agent delegation tracking)
+  chainId: string | null;        // shared ID across all tasks in a delegation chain
+  chainSeq: number;              // sequence number within chain (0 = origin)
+  delegatedFrom: string | null;  // task ID this was delegated from
+  delegatedTo: string | null;    // task ID this was delegated to
+  delegationType: string | null; // 'delegation' | 'review' | 'revision' | 'escalation' | 'return'
+
+  // Customer context (for support/external-facing tasks)
+  customerContext: {
+    name: string;
+    email: string;
+    phone: string;
+    company: string;
+    channel: string;            // 'email' | 'chat' | 'phone' | 'whatsapp' | 'ticket'
+    isNew: boolean;
+    metadata: Record<string, unknown>;
+  } | null;
+
+  // Activity log (micro-events within a task)
+  activityLog: Array<{
+    ts: string;
+    type: string;                // 'created' | 'assigned' | 'started' | 'delegated' | 'returned' | 'progress' | 'completed' | 'failed' | 'note'
+    agent: string;
+    detail: string;
+  }>;
 }
 
 type TaskListener = (event: TaskEvent) => void;
@@ -113,12 +139,29 @@ export class TaskQueueManager {
           fallback_model TEXT,
           model_used TEXT,
           tokens_used INTEGER NOT NULL DEFAULT 0,
-          cost_usd REAL NOT NULL DEFAULT 0
+          cost_usd REAL NOT NULL DEFAULT 0,
+          chain_id TEXT,
+          chain_seq INTEGER NOT NULL DEFAULT 0,
+          delegated_from TEXT,
+          delegated_to TEXT,
+          delegation_type TEXT,
+          customer_context TEXT,
+          activity_log TEXT NOT NULL DEFAULT '[]'
         )`);
         await this.db.run(`CREATE INDEX IF NOT EXISTS idx_task_pipeline_org ON task_pipeline(org_id)`);
         await this.db.run(`CREATE INDEX IF NOT EXISTS idx_task_pipeline_agent ON task_pipeline(assigned_to)`);
         await this.db.run(`CREATE INDEX IF NOT EXISTS idx_task_pipeline_status ON task_pipeline(status)`);
         await this.db.run(`CREATE INDEX IF NOT EXISTS idx_task_pipeline_created ON task_pipeline(created_at)`);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_task_pipeline_chain ON task_pipeline(chain_id)`);
+
+        // Add new columns to existing tables (safe — IF NOT EXISTS not available for columns, so catch errors)
+        for (const col of [
+          ['chain_id', 'TEXT'], ['chain_seq', 'INTEGER DEFAULT 0'], ['delegated_from', 'TEXT'],
+          ['delegated_to', 'TEXT'], ['delegation_type', 'TEXT'], ['customer_context', 'TEXT'],
+          ['activity_log', 'TEXT DEFAULT \'[]\'']
+        ]) {
+          try { await this.db.run(`ALTER TABLE task_pipeline ADD COLUMN ${col[0]} ${col[1]}`); } catch { /* already exists */ }
+        }
 
         // Load recent tasks into memory
         const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
@@ -152,6 +195,11 @@ export class TaskQueueManager {
     model?: string;
     fallbackModel?: string;
     estimatedDurationMs?: number;
+    chainId?: string;
+    chainSeq?: number;
+    delegatedFrom?: string;
+    delegationType?: string;
+    customerContext?: TaskRecord['customerContext'];
   }): Promise<TaskRecord> {
     await this.init();
     const now = new Date().toISOString();
@@ -185,6 +233,13 @@ export class TaskQueueManager {
       modelUsed: null,
       tokensUsed: 0,
       costUsd: 0,
+      chainId: opts.chainId || randomUUID(),
+      chainSeq: opts.chainSeq || 0,
+      delegatedFrom: opts.delegatedFrom || null,
+      delegatedTo: null,
+      delegationType: opts.delegationType || null,
+      customerContext: opts.customerContext || null,
+      activityLog: [{ ts: now, type: 'created', agent: opts.createdBy || 'system', detail: 'Task created' }],
     };
     this.tasks.set(task.id, task);
     await this.persist(task);
@@ -192,6 +247,63 @@ export class TaskQueueManager {
     return task;
   }
 
+  /**
+   * Delegate a task from one agent to another, creating a new linked task in the chain.
+   */
+  async delegateTask(taskId: string, opts: {
+    toAgent: string;
+    toAgentName: string;
+    delegationType?: string;
+    title?: string;
+    description?: string;
+    priority?: TaskPriority;
+  }): Promise<TaskRecord | null> {
+    const source = this.tasks.get(taskId);
+    if (!source) return null;
+
+    const now = new Date().toISOString();
+    source.activityLog.push({ ts: now, type: 'delegated', agent: source.assignedTo, detail: `Delegated to ${opts.toAgentName} (${opts.delegationType || 'delegation'})` });
+
+    // Create the new delegated task
+    const delegated = await this.createTask({
+      orgId: source.orgId,
+      assignedTo: opts.toAgent,
+      assignedToName: opts.toAgentName,
+      createdBy: source.assignedTo,
+      createdByName: source.assignedToName,
+      title: opts.title || source.title,
+      description: opts.description || source.description,
+      category: source.category,
+      tags: [...source.tags],
+      priority: opts.priority || source.priority,
+      parentTaskId: source.parentTaskId,
+      relatedAgentIds: [...new Set([...source.relatedAgentIds, source.assignedTo])],
+      chainId: source.chainId || undefined,
+      chainSeq: (source.chainSeq || 0) + 1,
+      delegatedFrom: source.id,
+      delegationType: opts.delegationType || 'delegation',
+      customerContext: source.customerContext,
+    });
+
+    // Update source to point to delegated task
+    source.delegatedTo = delegated.id;
+    await this.persist(source);
+    this.emit({ type: 'task_updated', task: source, timestamp: now });
+
+    return delegated;
+  }
+
+  /**
+   * Get full task chain by chainId — all tasks in a delegation flow.
+   */
+  getTaskChain(chainId: string): TaskRecord[] {
+    const chain: TaskRecord[] = [];
+    for (const t of this.tasks.values()) {
+      if (t.chainId === chainId) chain.push(t);
+    }
+    return chain.sort((a, b) => (a.chainSeq || 0) - (b.chainSeq || 0));
+  }
+
   async updateTask(taskId: string, updates: Partial<Pick<TaskRecord, 'status' | 'progress' | 'result' | 'error' | 'modelUsed' | 'tokensUsed' | 'costUsd' | 'sessionId' | 'title' | 'description' | 'priority'>>): Promise<TaskRecord | null> {
     await this.init();
     const task = this.tasks.get(taskId);
@@ -199,8 +311,9 @@ export class TaskQueueManager {
 
     const now = new Date().toISOString();
 
-    if (updates.status === 'assigned' && !task.assignedAt) task.assignedAt = now;
-    if (updates.status === 'in_progress' && !task.startedAt) task.startedAt = now;
+    if (updates.status === 'assigned' && !task.assignedAt) { task.assignedAt = now; task.activityLog.push({ ts: now, type: 'assigned', agent: task.assignedTo, detail: 'Task assigned' }); }
+    if (updates.status === 'in_progress' && !task.startedAt) { task.startedAt = now; task.activityLog.push({ ts: now, type: 'started', agent: task.assignedTo, detail: 'Work started' }); }
+    if (updates.progress !== undefined && updates.progress !== task.progress) { task.activityLog.push({ ts: now, type: 'progress', agent: task.assignedTo, detail: `Progress: ${updates.progress}%` }); }
     if (updates.status === 'completed' || updates.status === 'failed' || updates.status === 'cancelled') {
       task.completedAt = now;
       if (task.startedAt) task.actualDurationMs = new Date(now).getTime() - new Date(task.startedAt).getTime();
@@ -272,8 +385,21 @@ export class TaskQueueManager {
     return this.getAllTasks(orgId, limit);
   }
 
-  getPipelineStats(orgId?: string): { created: number; assigned: number; inProgress: number; completed: number; failed: number; cancelled: number; total: number } {
-    const stats = { created: 0, assigned: 0, inProgress: 0, completed: 0, failed: 0, cancelled: 0, total: 0 };
+  getPipelineStats(orgId?: string): {
+    created: number; assigned: number; inProgress: number; completed: number; failed: number; cancelled: number; total: number;
+    todayCompleted: number; todayFailed: number; todayCreated: number; avgDurationMs: number; totalCost: number; totalTokens: number;
+    topAgents: Array<{ agent: string; name: string; completed: number; active: number }>;
+  } {
+    const stats = {
+      created: 0, assigned: 0, inProgress: 0, completed: 0, failed: 0, cancelled: 0, total: 0,
+      todayCompleted: 0, todayFailed: 0, todayCreated: 0, avgDurationMs: 0, totalCost: 0, totalTokens: 0,
+      topAgents: [] as Array<{ agent: string; name: string; completed: number; active: number }>,
+    };
+    const todayStart = new Date(); todayStart.setHours(0, 0, 0, 0);
+    const todayMs = todayStart.getTime();
+    let durationSum = 0; let durationCount = 0;
+    const agentMap = new Map<string, { name: string; completed: number; active: number }>();
+
     for (const t of this.tasks.values()) {
       if (orgId && t.orgId !== orgId) continue;
       stats.total++;
@@ -283,7 +409,31 @@ export class TaskQueueManager {
       else if (t.status === 'completed') stats.completed++;
       else if (t.status === 'failed') stats.failed++;
       else if (t.status === 'cancelled') stats.cancelled++;
+
+      // Today metrics
+      const createdMs = new Date(t.createdAt).getTime();
+      if (createdMs >= todayMs) stats.todayCreated++;
+      if (t.completedAt && new Date(t.completedAt).getTime() >= todayMs) {
+        if (t.status === 'completed') stats.todayCompleted++;
+        if (t.status === 'failed') stats.todayFailed++;
+      }
+      if (t.actualDurationMs) { durationSum += t.actualDurationMs; durationCount++; }
+      stats.totalCost += t.costUsd || 0;
+      stats.totalTokens += t.tokensUsed || 0;
+
+      // Per-agent
+      if (t.assignedTo) {
+        if (!agentMap.has(t.assignedTo)) agentMap.set(t.assignedTo, { name: t.assignedToName || t.assignedTo, completed: 0, active: 0 });
+        const a = agentMap.get(t.assignedTo)!;
+        if (t.status === 'completed') a.completed++;
+        if (t.status === 'in_progress' || t.status === 'assigned') a.active++;
+      }
     }
+    stats.avgDurationMs = durationCount > 0 ? Math.round(durationSum / durationCount) : 0;
+    stats.topAgents = Array.from(agentMap.entries())
+      .map(([agent, d]) => ({ agent, ...d }))
+      .sort((a, b) => (b.completed + b.active) - (a.completed + a.active))
+      .slice(0, 5);
     return stats;
   }
 
@@ -311,14 +461,17 @@ export class TaskQueueManager {
         created_at, assigned_at, started_at, completed_at,
         estimated_duration_ms, actual_duration_ms, result, error,
         parent_task_id, related_agent_ids, session_id,
-        model, fallback_model, model_used, tokens_used, cost_usd
-      ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+        model, fallback_model, model_used, tokens_used, cost_usd,
+        chain_id, chain_seq, delegated_from, delegated_to, delegation_type,
+        customer_context, activity_log
+      ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
         ON CONFLICT (id) DO UPDATE SET
           status=EXCLUDED.status, priority=EXCLUDED.priority, progress=EXCLUDED.progress,
           assigned_at=EXCLUDED.assigned_at, started_at=EXCLUDED.started_at, completed_at=EXCLUDED.completed_at,
           actual_duration_ms=EXCLUDED.actual_duration_ms, result=EXCLUDED.result, error=EXCLUDED.error,
           model_used=EXCLUDED.model_used, tokens_used=EXCLUDED.tokens_used, cost_usd=EXCLUDED.cost_usd,
-          session_id=EXCLUDED.session_id, title=EXCLUDED.title, description=EXCLUDED.description`, [
+          session_id=EXCLUDED.session_id, title=EXCLUDED.title, description=EXCLUDED.description,
+          delegated_to=EXCLUDED.delegated_to, activity_log=EXCLUDED.activity_log`, [
         task.id, task.orgId, task.assignedTo, task.assignedToName,
         task.createdBy, task.createdByName,
         task.title, task.description, task.category, JSON.stringify(task.tags),
@@ -329,6 +482,9 @@ export class TaskQueueManager {
         task.error,
         task.parentTaskId, JSON.stringify(task.relatedAgentIds), task.sessionId,
         task.model, task.fallbackModel, task.modelUsed, task.tokensUsed, task.costUsd,
+        task.chainId, task.chainSeq, task.delegatedFrom, task.delegatedTo, task.delegationType,
+        task.customerContext ? JSON.stringify(task.customerContext) : null,
+        JSON.stringify(task.activityLog || []),
       ]);
     } catch (e: any) {
       console.error('[TaskQueue] persist error:', e.message);
@@ -366,6 +522,13 @@ export class TaskQueueManager {
       modelUsed: row.model_used || null,
       tokensUsed: row.tokens_used || 0,
       costUsd: row.cost_usd || 0,
+      chainId: row.chain_id || null,
+      chainSeq: row.chain_seq || 0,
+      delegatedFrom: row.delegated_from || null,
+      delegatedTo: row.delegated_to || null,
+      delegationType: row.delegation_type || null,
+      customerContext: safeJson(row.customer_context, null),
+      activityLog: safeJson(row.activity_log, []),
     };
   }
 }