@adhdev/daemon-core 0.9.77-rc.4 → 0.9.77-rc.41

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

@@ -3,7 +3,7 @@ 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 interface MeshWorkQueueEntry {
     id: string;
@@ -12,10 +12,19 @@ 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;
     createdAt: string;
     updatedAt: string;
 }
@@ -47,7 +56,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 +65,7 @@ export function enqueueTask(
         message,
         status: 'pending',
         targetNodeId: opts?.targetNodeId,
+        targetSessionId: opts?.targetSessionId,
         createdAt: new Date().toISOString(),
         updatedAt: new Date().toISOString(),
     };
@@ -81,13 +91,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 === nodeId && !q.targetSessionId);
+    }
     if (targetIdx === -1) {
-        targetIdx = queue.findIndex(q => q.status === 'pending' && !q.targetNodeId);
+        targetIdx = queue.findIndex(q => q.status === 'pending' && !q.targetNodeId && !q.targetSessionId);
     }
 
     if (targetIdx === -1) return null;
@@ -121,6 +143,65 @@ export function updateTaskStatus(
     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.
  */
@@ -148,6 +229,13 @@ export interface MeshWorkQueueStats {
     assigned: number;
     completed: number;
     failed: number;
+    cancelled: number;
+    activeAssignments: Array<{
+        id: string;
+        nodeId?: string;
+        sessionId?: string;
+        message: string;
+    }>;
 }
 
 /**
@@ -160,5 +248,14 @@ export function getMeshQueueStats(meshId: string): MeshWorkQueueStats {
         assigned: queue.filter(q => q.status === 'assigned').length,
         completed: queue.filter(q => q.status === 'completed').length,
         failed: queue.filter(q => q.status === 'failed').length,
+        cancelled: queue.filter(q => q.status === 'cancelled').length,
+        activeAssignments: queue
+            .filter(q => q.status === 'assigned')
+            .map(q => ({
+                id: q.id,
+                nodeId: q.assignedNodeId,
+                sessionId: q.assignedSessionId,
+                message: q.message,
+            })),
     };
 }

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

@@ -833,6 +833,8 @@ export class CliProviderInstance implements ProviderInstance {
                         this.completedDebounceTimer = null;
                     }, 3000);
                 }
+            } else if (newStatus === 'idle' && this.lastStatus === 'starting') {
+                this.pushEvent({ event: 'agent:ready', chatTitle, timestamp: now });
             } else if (newStatus === 'stopped') {
                 // Cancel any pending debounce
                 if (this.generatingDebounceTimer) { clearTimeout(this.generatingDebounceTimer); this.generatingDebounceTimer = null; }

package/src/shared-types.ts

@@ -394,6 +394,13 @@ export interface SessionEntry {
         assigned: number;
         completed: number;
         failed: number;
+        cancelled?: number;
+        activeAssignments?: Array<{
+            id: string;
+            nodeId?: string;
+            sessionId?: string;
+            message: string;
+        }>;
     };
 }
 
@@ -439,6 +446,13 @@ export interface CompactSessionEntry {
         assigned: number;
         completed: number;
         failed: number;
+        cancelled?: number;
+        activeAssignments?: Array<{
+            id: string;
+            nodeId?: string;
+            sessionId?: string;
+            message: string;
+        }>;
     };
 }