@adhdev/daemon-core 0.9.77-rc.5 → 0.9.77-rc.51

package/src/mesh/mesh-work-queue.ts

@@ -3,7 +3,12 @@ import { join } from 'path';
 import { randomUUID } from 'crypto';
 import { getLedgerDir } from './mesh-ledger.js';
 
-export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed';
+export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
+export type MeshActiveTaskStatus = Extract<MeshTaskStatus, 'pending' | 'assigned'>;
+export type MeshHistoricalTaskStatus = Extract<MeshTaskStatus, 'completed' | 'failed' | 'cancelled'>;
+
+export const ACTIVE_MESH_QUEUE_STATUSES: MeshActiveTaskStatus[] = ['pending', 'assigned'];
+export const HISTORICAL_MESH_QUEUE_STATUSES: MeshHistoricalTaskStatus[] = ['completed', 'failed', 'cancelled'];
 
 export interface MeshWorkQueueEntry {
     id: string;
@@ -12,10 +17,30 @@ export interface MeshWorkQueueEntry {
     status: MeshTaskStatus;
     /** If specified, only this node can claim the task (used by legacy mesh_send_task) */
     targetNodeId?: string;
+    /** If specified, only this runtime session can claim the task */
+    targetSessionId?: string;
     /** The node that actually claimed and is executing the task */
     assignedNodeId?: string;
     /** The session currently executing the task */
     assignedSessionId?: string;
+    /** Human/operator reason for terminal cancellation. */
+    cancelReason?: string;
+    cancelledAt?: string;
+    /** Human/operator reason for manually requeueing a task. */
+    requeueReason?: string;
+    requeuedAt?: string;
+    requeueCount?: number;
+    /** Last automatic queue session spin-up attempt, for mesh_view_queue/debug visibility. */
+    autoLaunch?: {
+        status: 'skipped' | 'started' | 'failed' | 'completed';
+        reason?: string;
+        nodeId?: string;
+        providerType?: string;
+        sessionId?: string;
+        updatedAt: string;
+    };
+    /** ISO timestamp when the task was dispatched (assigned) to a node/session. Used for precise matching on completion. */
+    dispatchTimestamp?: string;
     createdAt: string;
     updatedAt: string;
 }
@@ -47,7 +72,7 @@ function writeQueue(meshId: string, queue: MeshWorkQueueEntry[]): void {
 export function enqueueTask(
     meshId: string,
     message: string,
-    opts?: { targetNodeId?: string }
+    opts?: { targetNodeId?: string; targetSessionId?: string }
 ): MeshWorkQueueEntry {
     const queue = readQueue(meshId);
     const entry: MeshWorkQueueEntry = {
@@ -56,6 +81,7 @@ export function enqueueTask(
         message,
         status: 'pending',
         targetNodeId: opts?.targetNodeId,
+        targetSessionId: opts?.targetSessionId,
         createdAt: new Date().toISOString(),
         updatedAt: new Date().toISOString(),
     };
@@ -81,13 +107,25 @@ export function getQueue(meshId: string, opts?: { status?: MeshTaskStatus[] }):
  */
 export function claimNextTask(meshId: string, nodeId: string, sessionId: string): MeshWorkQueueEntry | null {
     const queue = readQueue(meshId);
+
+    // A worker must finish or fail its current queued assignment before it can
+    // claim another one. maxParallelTasks limits total mesh concurrency; it is
+    // not permission for one node/session to accumulate multiple assigned items.
+    const hasActiveAssignment = queue.some(q => q.status === 'assigned' && (
+        q.assignedSessionId === sessionId || q.assignedNodeId === nodeId
+    ));
+    if (hasActiveAssignment) return null;
     
     // Find highest priority task:
-    // 1. Pending tasks explicitly targeted at this node
-    // 2. Pending tasks with no target node
-    let targetIdx = queue.findIndex(q => q.status === 'pending' && q.targetNodeId === nodeId);
+    // 1. Pending tasks explicitly targeted at this runtime session
+    // 2. Pending tasks explicitly targeted at this node (but not another session)
+    // 3. Pending tasks with no target node/session
+    let targetIdx = queue.findIndex(q => q.status === 'pending' && q.targetSessionId === sessionId);
     if (targetIdx === -1) {
-        targetIdx = queue.findIndex(q => q.status === 'pending' && !q.targetNodeId);
+        targetIdx = queue.findIndex(q => q.status === 'pending' && q.targetNodeId === nodeId && !q.targetSessionId);
+    }
+    if (targetIdx === -1) {
+        targetIdx = queue.findIndex(q => q.status === 'pending' && !q.targetNodeId && !q.targetSessionId);
     }
 
     if (targetIdx === -1) return null;
@@ -96,6 +134,7 @@ export function claimNextTask(meshId: string, nodeId: string, sessionId: string)
     entry.status = 'assigned';
     entry.assignedNodeId = nodeId;
     entry.assignedSessionId = sessionId;
+    entry.dispatchTimestamp = new Date().toISOString();
     entry.updatedAt = new Date().toISOString();
 
     writeQueue(meshId, queue);
@@ -121,6 +160,83 @@ export function updateTaskStatus(
     return queue[idx];
 }
 
+export function recordTaskAutoLaunch(
+    meshId: string,
+    taskId: string,
+    autoLaunch: Omit<NonNullable<MeshWorkQueueEntry['autoLaunch']>, 'updatedAt'>,
+): MeshWorkQueueEntry | null {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex(q => q.id === taskId);
+    if (idx === -1) return null;
+    const now = new Date().toISOString();
+    queue[idx].autoLaunch = {
+        ...autoLaunch,
+        updatedAt: now,
+    };
+    queue[idx].updatedAt = now;
+    writeQueue(meshId, queue);
+    return queue[idx];
+}
+
+/**
+ * Mark a queue task as manually cancelled without deleting audit history.
+ */
+export function cancelTask(
+    meshId: string,
+    taskId: string,
+    opts?: { reason?: string },
+): MeshWorkQueueEntry | null {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex(q => q.id === taskId);
+    if (idx === -1) return null;
+
+    const now = new Date().toISOString();
+    queue[idx].status = 'cancelled';
+    queue[idx].updatedAt = now;
+    queue[idx].cancelledAt = now;
+    if (opts?.reason) queue[idx].cancelReason = opts.reason;
+    writeQueue(meshId, queue);
+    return queue[idx];
+}
+
+/**
+ * Return a queue task to pending for retry. By default, dead session targeting
+ * and assigned ownership are cleared so stale assignments do not strand again.
+ */
+export function requeueTask(
+    meshId: string,
+    taskId: string,
+    opts?: {
+        reason?: string;
+        targetNodeId?: string;
+        targetSessionId?: string;
+        clearTargetNode?: boolean;
+        clearTargetSession?: boolean;
+    },
+): MeshWorkQueueEntry | null {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex(q => q.id === taskId);
+    if (idx === -1) return null;
+
+    const entry = queue[idx];
+    const now = new Date().toISOString();
+    entry.status = 'pending';
+    delete entry.assignedNodeId;
+    delete entry.assignedSessionId;
+    delete entry.cancelledAt;
+    delete entry.cancelReason;
+    if (opts?.clearTargetNode) delete entry.targetNodeId;
+    if (typeof opts?.targetNodeId === 'string') entry.targetNodeId = opts.targetNodeId;
+    if (opts?.clearTargetSession !== false) delete entry.targetSessionId;
+    if (typeof opts?.targetSessionId === 'string') entry.targetSessionId = opts.targetSessionId;
+    entry.updatedAt = now;
+    entry.requeuedAt = now;
+    entry.requeueCount = (entry.requeueCount || 0) + 1;
+    if (opts?.reason) entry.requeueReason = opts.reason;
+    writeQueue(meshId, queue);
+    return entry;
+}
+
 /**
  * Update the status of the task currently assigned to a specific session.
  */
@@ -130,24 +246,48 @@ export function updateSessionTaskStatus(
     status: MeshTaskStatus,
 ): MeshWorkQueueEntry | null {
     const queue = readQueue(meshId);
-    // Find the most recently assigned task for this session that isn't already terminal
-    // (In case multiple tasks were assigned to the same session over time, though rare)
+    // Collect all assigned tasks for this session, then pick the one with the
+    // most recent dispatchTimestamp (or updatedAt fallback for legacy entries).
+    // This prevents completing the wrong task when multiple tasks were assigned
+    // to the same session in rapid succession.
+    let bestIdx = -1;
+    let bestTime = 0;
     for (let i = queue.length - 1; i >= 0; i--) {
         if (queue[i].assignedSessionId === sessionId && queue[i].status === 'assigned') {
-            queue[i].status = status;
-            queue[i].updatedAt = new Date().toISOString();
-            writeQueue(meshId, queue);
-            return queue[i];
+            const time = new Date(queue[i].dispatchTimestamp || queue[i].updatedAt).getTime();
+            if (time > bestTime) {
+                bestTime = time;
+                bestIdx = i;
+            }
         }
     }
-    return null;
+    if (bestIdx === -1) return null;
+
+    queue[bestIdx].status = status;
+    queue[bestIdx].updatedAt = new Date().toISOString();
+    writeQueue(meshId, queue);
+    return queue[bestIdx];
 }
 
 export interface MeshWorkQueueStats {
+    total: number;
+    active: number;
+    historical: number;
     pending: number;
     assigned: number;
     completed: number;
     failed: number;
+    cancelled: number;
+    /** Source-of-truth active queue counters; only pending/assigned are live work. */
+    activeCounts: Record<MeshActiveTaskStatus, number>;
+    /** Terminal ledger records kept for audit/history; never count as active work. */
+    historicalCounts: Record<MeshHistoricalTaskStatus, number>;
+    activeAssignments: Array<{
+        id: string;
+        nodeId?: string;
+        sessionId?: string;
+        message: string;
+    }>;
 }
 
 /**
@@ -155,10 +295,36 @@ export interface MeshWorkQueueStats {
  */
 export function getMeshQueueStats(meshId: string): MeshWorkQueueStats {
     const queue = readQueue(meshId);
+    const pending = queue.filter(q => q.status === 'pending').length;
+    const assigned = queue.filter(q => q.status === 'assigned').length;
+    const completed = queue.filter(q => q.status === 'completed').length;
+    const failed = queue.filter(q => q.status === 'failed').length;
+    const cancelled = queue.filter(q => q.status === 'cancelled').length;
     return {
-        pending: queue.filter(q => q.status === 'pending').length,
-        assigned: queue.filter(q => q.status === 'assigned').length,
-        completed: queue.filter(q => q.status === 'completed').length,
-        failed: queue.filter(q => q.status === 'failed').length,
+        total: queue.length,
+        active: pending + assigned,
+        historical: completed + failed + cancelled,
+        pending,
+        assigned,
+        completed,
+        failed,
+        cancelled,
+        activeCounts: {
+            pending,
+            assigned,
+        },
+        historicalCounts: {
+            completed,
+            failed,
+            cancelled,
+        },
+        activeAssignments: queue
+            .filter(q => q.status === 'assigned')
+            .map(q => ({
+                id: q.id,
+                nodeId: q.assignedNodeId,
+                sessionId: q.assignedSessionId,
+                message: q.message,
+            })),
     };
 }

package/src/mesh/p2p-relay-failure.ts

@@ -0,0 +1,152 @@
+export type P2pRelayFailureCode =
+  | 'p2p_unavailable'
+  | 'p2p_timeout'
+  | 'p2p_not_connected'
+  | 'p2p_datachannel_closed'
+  | 'p2p_no_route'
+  | 'p2p_daemon_offline'
+  | 'mesh_logic_or_provider_failure';
+
+export interface P2pRelayFailureContext {
+  command?: string;
+  targetDaemonId?: string;
+}
+
+export interface P2pRelayFailureClassification {
+  code: P2pRelayFailureCode;
+  reason: string;
+  transport: 'p2p' | 'unknown';
+  recoverable: boolean;
+  retryRecommended: boolean;
+  nextAction: string;
+  noFallbackReason: string;
+}
+
+export interface P2pRelayFailurePayload extends P2pRelayFailureClassification {
+  success: false;
+  error: string;
+  command?: string;
+  targetDaemonId?: string;
+}
+
+const NO_FALLBACK_REASON = 'Repo Mesh command/data-plane is P2P-only; WS/REST command fallback is intentionally disabled to preserve the transport boundary.';
+const P2P_NEXT_ACTION = 'Check daemon/P2P health, wait briefly for connection establishment, then do one bounded retry or requeue the mesh task after clearing stale target session metadata.';
+const NON_P2P_NEXT_ACTION = 'Inspect the provider/command error and fix the underlying logic or configuration before retrying.';
+
+function messageFromError(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  if (typeof error === 'string') return error;
+  if (error && typeof error === 'object') {
+    const candidate = (error as any).error ?? (error as any).message ?? (error as any).reason;
+    if (typeof candidate === 'string') return candidate;
+  }
+  return String(error || 'mesh relay command failed');
+}
+
+export function classifyP2pRelayFailure(error: unknown, _context: P2pRelayFailureContext = {}): P2pRelayFailureClassification {
+  const message = messageFromError(error);
+  const lower = message.toLowerCase();
+
+  const hasP2pSignal = /p2p|datachannel|node-datachannel|webrtc|ice|mesh_relay_command|daemon_mesh_p2p_transport/i.test(message);
+  const hasFailureSignal = /unavailable|missing|failed|failure|timeout|timed out|not connected|closed|disconnected|offline|no route|route unavailable|cannot send|cannot establish/i.test(message);
+
+  // Validation errors that merely mention mesh_relay_command are not transport failures.
+  if (/requires targetdaemonid and command|providerpriority|no inference provider|permission denied|read-only|not a member/i.test(message)) {
+    return {
+      code: 'mesh_logic_or_provider_failure',
+      reason: 'mesh_logic_or_provider_failure',
+      transport: 'unknown',
+      recoverable: false,
+      retryRecommended: false,
+      nextAction: NON_P2P_NEXT_ACTION,
+      noFallbackReason: NO_FALLBACK_REASON,
+    };
+  }
+
+  let code: P2pRelayFailureCode | null = null;
+  let reason = '';
+
+  if (/timeout|timed out/i.test(message) && (hasP2pSignal || /mesh transport/i.test(message))) {
+    code = 'p2p_timeout';
+    reason = 'daemon_mesh_p2p_timeout';
+  } else if (/no route|route unavailable/i.test(message)) {
+    code = 'p2p_no_route';
+    reason = 'daemon_mesh_p2p_no_route';
+  } else if (/offline|not owned|not found|not connected to server/i.test(message) && /daemon|peer|target/i.test(message)) {
+    code = 'p2p_daemon_offline';
+    reason = 'daemon_mesh_target_offline';
+  } else if (/closed|disconnected/i.test(message) && (hasP2pSignal || /state changed/i.test(message))) {
+    code = 'p2p_datachannel_closed';
+    reason = 'daemon_mesh_p2p_datachannel_closed';
+  } else if (/not connected|cannot send|cannot establish/i.test(message) && hasP2pSignal) {
+    code = 'p2p_not_connected';
+    reason = 'daemon_mesh_p2p_not_connected';
+  } else if (hasP2pSignal && hasFailureSignal) {
+    code = 'p2p_unavailable';
+    reason = 'daemon_mesh_p2p_transport_unavailable';
+  }
+
+  if (!code) {
+    return {
+      code: 'mesh_logic_or_provider_failure',
+      reason: 'mesh_logic_or_provider_failure',
+      transport: 'unknown',
+      recoverable: false,
+      retryRecommended: false,
+      nextAction: NON_P2P_NEXT_ACTION,
+      noFallbackReason: NO_FALLBACK_REASON,
+    };
+  }
+
+  return {
+    code,
+    reason,
+    transport: 'p2p',
+    recoverable: true,
+    retryRecommended: true,
+    nextAction: P2P_NEXT_ACTION,
+    noFallbackReason: NO_FALLBACK_REASON,
+  };
+}
+
+export function isP2pRelayTransportFailure(error: unknown): boolean {
+  return classifyP2pRelayFailure(error).recoverable === true;
+}
+
+export function buildP2pRelayFailurePayload(error: unknown, context: P2pRelayFailureContext = {}): P2pRelayFailurePayload {
+  const classification = classifyP2pRelayFailure(error, context);
+  return {
+    success: false,
+    ...classification,
+    error: messageFromError(error),
+    ...(context.command ? { command: context.command } : {}),
+    ...(context.targetDaemonId ? { targetDaemonId: context.targetDaemonId } : {}),
+  };
+}
+
+export class P2pRelayFailureError extends Error {
+  code: P2pRelayFailureCode;
+  reason: string;
+  transport: 'p2p' | 'unknown';
+  recoverable: boolean;
+  retryRecommended: boolean;
+  nextAction: string;
+  noFallbackReason: string;
+  command?: string;
+  targetDaemonId?: string;
+
+  constructor(message: string, context: P2pRelayFailureContext = {}) {
+    super(message);
+    this.name = 'P2pRelayFailureError';
+    const payload = buildP2pRelayFailurePayload(message, context);
+    this.code = payload.code;
+    this.reason = payload.reason;
+    this.transport = payload.transport;
+    this.recoverable = payload.recoverable;
+    this.retryRecommended = payload.retryRecommended;
+    this.nextAction = payload.nextAction;
+    this.noFallbackReason = payload.noFallbackReason;
+    this.command = context.command;
+    this.targetDaemonId = context.targetDaemonId;
+  }
+}

package/src/providers/acp-provider-instance.ts

@@ -61,6 +61,7 @@ import {
     buildToolChatMessage,
     buildUserChatMessage,
     normalizeChatMessages,
+    extractFinalSummaryFromMessages,
 } from './chat-message-normalization.js';
 import { LOG } from '../logging/logger.js';
 import type { ChatMessage } from '../types.js';
@@ -1507,7 +1508,7 @@ export class AcpProviderInstance implements ProviderInstance {
                 });
             } else if (newStatus === 'idle' && (this.lastStatus === 'generating' || this.lastStatus === 'waiting_approval')) {
                 const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1000) : 0;
-                this.pushEvent({ event: 'agent:generating_completed', chatTitle, duration, timestamp: now });
+                this.pushEvent({ event: 'agent:generating_completed', chatTitle, duration, timestamp: now, finalSummary: extractFinalSummaryFromMessages(this.messages) });
                 this.generatingStartedAt = 0;
             } else if (newStatus === 'stopped') {
                 this.pushEvent({ event: 'agent:stopped', chatTitle, timestamp: now });

package/src/providers/chat-message-normalization.ts

@@ -1,4 +1,36 @@
 import type { ChatMessage } from '../types.js';
+import { flattenContent } from './contracts.js';
+
+export function extractFinalSummaryFromMessages(
+  messages: ChatMessage[] | null | undefined,
+  maxChars: number = 500,
+): string {
+  if (!Array.isArray(messages) || messages.length === 0) return '';
+
+  // Find last user-facing assistant message
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg) continue;
+    const classification = classifyChatMessageVisibility(msg);
+    if (classification.isUserFacing && (msg.role === 'assistant' || msg.role === 'model')) {
+      const text = flattenContent(msg.content).trim();
+      if (text) return text.slice(0, maxChars);
+    }
+  }
+
+  // Fallback: last user-facing message of any role
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg) continue;
+    const classification = classifyChatMessageVisibility(msg);
+    if (classification.isUserFacing) {
+      const text = flattenContent(msg.content).trim();
+      if (text) return text.slice(0, maxChars);
+    }
+  }
+
+  return '';
+}
 
 export const BUILTIN_CHAT_MESSAGE_KINDS = ['standard', 'thought', 'tool', 'terminal', 'system'] as const;