@adhdev/daemon-core 0.9.76 → 0.9.77-rc.10

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

@@ -0,0 +1,164 @@
+import { existsSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+import { getLedgerDir } from './mesh-ledger.js';
+
+export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed';
+
+export interface MeshWorkQueueEntry {
+    id: string;
+    meshId: string;
+    message: string;
+    status: MeshTaskStatus;
+    /** If specified, only this node can claim the task (used by legacy mesh_send_task) */
+    targetNodeId?: string;
+    /** The node that actually claimed and is executing the task */
+    assignedNodeId?: string;
+    /** The session currently executing the task */
+    assignedSessionId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+
+function getQueuePath(meshId: string): string {
+    const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return join(getLedgerDir(), `${safe}.queue.json`);
+}
+
+function readQueue(meshId: string): MeshWorkQueueEntry[] {
+    const path = getQueuePath(meshId);
+    if (!existsSync(path)) return [];
+    try {
+        const content = readFileSync(path, 'utf-8');
+        return JSON.parse(content) as MeshWorkQueueEntry[];
+    } catch {
+        return [];
+    }
+}
+
+function writeQueue(meshId: string, queue: MeshWorkQueueEntry[]): void {
+    const path = getQueuePath(meshId);
+    writeFileSync(path, JSON.stringify(queue, null, 2), 'utf-8');
+}
+
+/**
+ * Add a new task to the mesh queue.
+ */
+export function enqueueTask(
+    meshId: string,
+    message: string,
+    opts?: { targetNodeId?: string }
+): MeshWorkQueueEntry {
+    const queue = readQueue(meshId);
+    const entry: MeshWorkQueueEntry = {
+        id: randomUUID(),
+        meshId,
+        message,
+        status: 'pending',
+        targetNodeId: opts?.targetNodeId,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    };
+    queue.push(entry);
+    writeQueue(meshId, queue);
+    return entry;
+}
+
+/**
+ * Get all tasks in the queue, optionally filtered by status.
+ */
+export function getQueue(meshId: string, opts?: { status?: MeshTaskStatus[] }): MeshWorkQueueEntry[] {
+    let queue = readQueue(meshId);
+    if (opts?.status?.length) {
+        const statuses = new Set(opts.status);
+        queue = queue.filter(q => statuses.has(q.status));
+    }
+    return queue;
+}
+
+/**
+ * Find the next pending task that this node is allowed to claim, and mark it as assigned.
+ */
+export function claimNextTask(meshId: string, nodeId: string, sessionId: string): MeshWorkQueueEntry | null {
+    const queue = readQueue(meshId);
+    
+    // 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);
+    if (targetIdx === -1) {
+        targetIdx = queue.findIndex(q => q.status === 'pending' && !q.targetNodeId);
+    }
+
+    if (targetIdx === -1) return null;
+
+    const entry = queue[targetIdx];
+    entry.status = 'assigned';
+    entry.assignedNodeId = nodeId;
+    entry.assignedSessionId = sessionId;
+    entry.updatedAt = new Date().toISOString();
+
+    writeQueue(meshId, queue);
+    return entry;
+}
+
+/**
+ * Update the status of a specific task.
+ * Used when a session completes, fails, or stalls.
+ */
+export function updateTaskStatus(
+    meshId: string,
+    taskId: string,
+    status: MeshTaskStatus,
+): MeshWorkQueueEntry | null {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex(q => q.id === taskId);
+    if (idx === -1) return null;
+
+    queue[idx].status = status;
+    queue[idx].updatedAt = new Date().toISOString();
+    writeQueue(meshId, queue);
+    return queue[idx];
+}
+
+/**
+ * Update the status of the task currently assigned to a specific session.
+ */
+export function updateSessionTaskStatus(
+    meshId: string,
+    sessionId: string,
+    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)
+    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];
+        }
+    }
+    return null;
+}
+
+export interface MeshWorkQueueStats {
+    pending: number;
+    assigned: number;
+    completed: number;
+    failed: number;
+}
+
+/**
+ * Return aggregate queue statistics for the given mesh.
+ */
+export function getMeshQueueStats(meshId: string): MeshWorkQueueStats {
+    const queue = readQueue(meshId);
+    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,
+    };
+}

package/src/repo-mesh-types.ts

@@ -78,6 +78,12 @@ export interface RepoMeshPolicy {
      * runtimes are never stopped/deleted unless the mesh owner opts in.
      */
     sessionCleanupOnNodeRemove?: RepoMeshSessionCleanupMode;
+    /**
+     * Maximum number of automatic retry recommendations for a failed task on the
+     * same node before the daemon advises the coordinator to escalate or reassign.
+     * Defaults to 1 (allow one retry). Set to 0 to disable auto-recovery advice.
+     */
+    maxTaskRetries?: number;
 }
 
 export interface RepoMeshRelatedRepo {
@@ -110,6 +116,7 @@ export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
     maxParallelTasks: 2,
     spawnedSessionVisibility: 'visible',
     sessionCleanupOnNodeRemove: 'preserve',
+    maxTaskRetries: 1,
 };
 
 // ─── Capabilities ───────────────────────────────

package/src/shared-types.ts

@@ -389,6 +389,12 @@ export interface SessionEntry {
     seenCompletionMarker?: string;
     surfaceHidden?: boolean;
     settings?: Record<string, any>;
+    meshQueueStats?: {
+        pending: number;
+        assigned: number;
+        completed: number;
+        failed: number;
+    };
 }
 
 /**
@@ -428,6 +434,12 @@ export interface CompactSessionEntry {
     providerControls?: ProviderControlSchema[];
     summaryMetadata?: ProviderSummaryMetadata;
     settings?: Record<string, any>;
+    meshQueueStats?: {
+        pending: number;
+        assigned: number;
+        completed: number;
+        failed: number;
+    };
 }
 
 export type VersionUpdateReason =

package/src/status/builders.ts

@@ -24,6 +24,7 @@ import {
     normalizeManagedStatus,
     type NormalizeActiveChatOptions,
 } from './normalize.js';
+import { getMeshQueueStats } from '../mesh/mesh-work-queue.js';
 import { normalizeProviderStateControlValues } from '../providers/provider-patch-state.js';
 import { normalizeProviderSummaryMetadata } from '../providers/summary-metadata.js';
 import {
@@ -177,6 +178,8 @@ function buildIdeWorkspaceSession(
     const workspace = state.workspace || null;
     const git = getGitSummaryForWorkspace(workspace, options);
     const title = activeChat?.title || state.name;
+    const meshCoordinatorFor = state.settings?.meshCoordinatorFor as string | undefined;
+    const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : undefined;
     return {
         id: state.instanceId || state.type,
         parentId: null,
@@ -200,6 +203,7 @@ function buildIdeWorkspaceSession(
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
         settings: state.settings,
+        ...(meshQueueStats && { meshQueueStats }),
     };
 }
 
@@ -216,6 +220,8 @@ function buildExtensionAgentSession(
     const includeSessionControls = shouldIncludeSessionControls(profile);
     const workspace = parent.workspace || null;
     const git = getGitSummaryForWorkspace(workspace, options);
+    const meshCoordinatorFor = ext.settings?.meshCoordinatorFor as string | undefined;
+    const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : undefined;
     return {
         id: ext.instanceId || `${parent.instanceId}:${ext.type}`,
         parentId: parent.instanceId || parent.type,
@@ -239,6 +245,7 @@ function buildExtensionAgentSession(
         errorReason: ext.errorReason,
         lastUpdated: ext.lastUpdated,
         settings: ext.settings,
+        ...(meshQueueStats && { meshQueueStats }),
     };
 }
 
@@ -279,6 +286,8 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
     const includeSessionControls = shouldIncludeSessionControls(profile);
     const workspace = state.workspace || null;
     const git = getGitSummaryForWorkspace(workspace, options);
+    const meshCoordinatorFor = state.settings?.meshCoordinatorFor as string | undefined;
+    const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : undefined;
     return {
         id: state.instanceId,
         parentId: null,
@@ -318,6 +327,7 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
         settings: state.settings,
+        ...(meshQueueStats && { meshQueueStats }),
     };
 }
 
@@ -330,6 +340,8 @@ function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOpti
     const includeSessionControls = shouldIncludeSessionControls(profile);
     const workspace = state.workspace || null;
     const git = getGitSummaryForWorkspace(workspace, options);
+    const meshCoordinatorFor = state.settings?.meshCoordinatorFor as string | undefined;
+    const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : undefined;
     return {
         id: state.instanceId,
         parentId: null,
@@ -352,6 +364,7 @@ function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOpti
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
         settings: state.settings,
+        ...(meshQueueStats && { meshQueueStats }),
     };
 }