@adhdev/daemon-core 0.9.82-rc.22 → 0.9.82-rc.24

package/dist/mesh/mesh-events.d.ts

@@ -9,12 +9,12 @@ export interface PendingMeshCoordinatorEvent {
     queuedAt: number;
 }
 export declare function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEvent): boolean;
-/** Drain and return all pending coordinator events, clearing the queue. */
-export declare function drainPendingMeshCoordinatorEvents(): PendingMeshCoordinatorEvent[];
+/** Drain and return all pending coordinator events for meshId, removing them from disk. */
+export declare function drainPendingMeshCoordinatorEvents(meshId?: string): PendingMeshCoordinatorEvent[];
 /** Peek at pending coordinator events without draining (non-destructive). */
-export declare function getPendingMeshCoordinatorEvents(): readonly PendingMeshCoordinatorEvent[];
-/** Explicitly clear all pending coordinator events. */
-export declare function clearPendingMeshCoordinatorEvents(): void;
+export declare function getPendingMeshCoordinatorEvents(meshId?: string): readonly PendingMeshCoordinatorEvent[];
+/** Explicitly clear all pending coordinator events for a mesh. */
+export declare function clearPendingMeshCoordinatorEvents(meshId?: string): void;
 export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
 /**
  * Triggers a queue check for all nodes in the mesh.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.22",
+  "version": "0.9.82-rc.24",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/router.ts

@@ -447,6 +447,23 @@ function summarizeMeshSessionRecord(record: any): Record<string, unknown> {
     };
 }
 
+function liveSessionRecordMatchesMeshNode(record: any, meshId: string, nodeId: string): boolean {
+    const recordNodeId = readStringValue(record?.meta?.meshNodeId);
+    if (!recordNodeId || recordNodeId !== nodeId) return false;
+    const recordMeshId = readStringValue(record?.meta?.meshNodeFor);
+    return !recordMeshId || recordMeshId === meshId;
+}
+
+function liveSessionRecordMatchesMeshWorkspace(record: any, meshId: string, workspace: string): boolean {
+    const recordWorkspace = readStringValue(record?.workspace);
+    if (!recordWorkspace || !workspace || recordWorkspace !== workspace) return false;
+
+    const recordMeshId = readStringValue(record?.meta?.meshNodeFor);
+    if (recordMeshId) return recordMeshId === meshId;
+
+    return record?.meta?.launchedByCoordinator === true || !!readStringValue(record?.meta?.meshNodeId);
+}
+
 function readLiveMeshNodeWorkspace(args: {
     meshId: string;
     nodeId: string;
@@ -454,7 +471,7 @@ function readLiveMeshNodeWorkspace(args: {
     allowCoordinatorSession?: boolean;
 }): string {
     const directNodeWorkspace = args.liveSessionRecords.find((record) => (
-        readStringValue(record?.meta?.meshNodeId) === args.nodeId
+        liveSessionRecordMatchesMeshNode(record, args.meshId, args.nodeId)
         && readStringValue(record?.workspace)
     ));
     if (directNodeWorkspace) {
@@ -482,10 +499,9 @@ function collectLiveMeshSessionRecords(args: {
     allowCoordinatorSession?: boolean;
 }): any[] {
     const matches = args.liveSessionRecords.filter((record) => {
-        if (readStringValue(record?.meta?.meshNodeId) === args.nodeId) return true;
-        const recordWorkspace = readStringValue(record?.workspace);
         const nodeWorkspace = readStringValue(args.node?.workspace);
-        return !!recordWorkspace && !!nodeWorkspace && recordWorkspace === nodeWorkspace;
+        if (liveSessionRecordMatchesMeshNode(record, args.meshId, args.nodeId)) return true;
+        return !!nodeWorkspace && liveSessionRecordMatchesMeshWorkspace(record, args.meshId, nodeWorkspace);
     });
 
     if (args.allowCoordinatorSession) {
@@ -948,6 +964,8 @@ export interface CommandRouterDeps {
     sessionHostControl?: SessionHostControlPlane | null;
     /** Selected-coordinator mesh peer telemetry surface for target daemons, when supported by the runtime. */
     getMeshPeerConnectionStatus?: (daemonId: string) => Record<string, unknown> | null;
+    /** Dispatch a command to a remote mesh node via P2P/relay. Injected by cloud runtime; absent in standalone. */
+    dispatchMeshCommand?: (daemonId: string, cmd: string, args: Record<string, unknown>) => Promise<unknown>;
 }
 
 export interface CommandRouterResult {
@@ -1672,7 +1690,8 @@ export class DaemonCommandRouter {
             }
 
             case 'get_pending_mesh_events': {
-                const events = drainPendingMeshCoordinatorEvents();
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                const events = drainPendingMeshCoordinatorEvents(meshId || undefined);
                 return { success: true, events };
             }
 
@@ -3328,29 +3347,52 @@ export class DaemonCommandRouter {
                         }
                         if (workspace) {
                             if (!fs.existsSync(workspace)) {
-                                if (applyCachedInlineMeshNodeStatus(status, node)) {
-                                    status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === 'online' || isSelfNode);
-                                    nodeStatuses.push(status);
-                                    continue;
-                                }
-                                if (meshRecord?.source === 'inline_cache' && !isSelfNode) {
-                                    status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === 'online' || isSelfNode);
-                                    nodeStatuses.push(status);
-                                    continue;
+                                // Workspace not local — attempt a P2P git probe for remote nodes.
+                                let remoteProbeApplied = false;
+                                if (!isSelfNode && daemonId && this.deps.dispatchMeshCommand) {
+                                    try {
+                                        const remoteResult = await Promise.race([
+                                            this.deps.dispatchMeshCommand(daemonId, 'git_status', { workspace }),
+                                            new Promise<never>((_, reject) => setTimeout(() => reject(new Error('timeout')), 8000)),
+                                        ]) as any;
+                                        const remoteGit = remoteResult?.status ?? remoteResult?.git ?? remoteResult;
+                                        if (remoteGit && typeof remoteGit === 'object' && typeof remoteGit.isGitRepo === 'boolean') {
+                                            status.git = remoteGit;
+                                            status.health = remoteGit.isGitRepo
+                                                ? deriveMeshNodeHealthFromGit(remoteGit as unknown as Record<string, unknown>)
+                                                : 'degraded';
+                                            remoteProbeApplied = true;
+                                        }
+                                    } catch {
+                                        // Probe timed out or P2P unavailable — fall back to cached status
+                                    }
                                 }
-                            }
-                            try {
-                                const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 10_000, refreshUpstream: true });
-                                status.git = gitStatus;
-                                if (gitStatus.isGitRepo) {
-                                    status.health = deriveMeshNodeHealthFromGit(gitStatus as unknown as Record<string, unknown>);
-                                } else {
-                                    status.health = 'degraded';
-                                    if (gitStatus.error && !status.error) status.error = gitStatus.error;
+                                if (!remoteProbeApplied) {
+                                    if (applyCachedInlineMeshNodeStatus(status, node)) {
+                                        status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === 'online' || isSelfNode);
+                                        nodeStatuses.push(status);
+                                        continue;
+                                    }
+                                    if (meshRecord?.source === 'inline_cache' && !isSelfNode) {
+                                        status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === 'online' || isSelfNode);
+                                        nodeStatuses.push(status);
+                                        continue;
+                                    }
                                 }
-                            } catch {
-                                if (!applyCachedInlineMeshNodeStatus(status, node)) {
-                                    status.health = 'degraded';
+                            } else {
+                                try {
+                                    const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 10_000, refreshUpstream: true });
+                                    status.git = gitStatus;
+                                    if (gitStatus.isGitRepo) {
+                                        status.health = deriveMeshNodeHealthFromGit(gitStatus as unknown as Record<string, unknown>);
+                                    } else {
+                                        status.health = 'degraded';
+                                        if (gitStatus.error && !status.error) status.error = gitStatus.error;
+                                    }
+                                } catch {
+                                    if (!applyCachedInlineMeshNodeStatus(status, node)) {
+                                        status.health = 'degraded';
+                                    }
                                 }
                             }
                         } else {

package/src/mesh/mesh-events.ts

@@ -1,31 +1,47 @@
+import { appendFileSync, existsSync, readFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 import { loadConfig } from '../config/config.js';
 import { getMesh, getMeshByRepo } from '../config/mesh-config.js';
 import { detectCLI } from '../detection/cli-detector.js';
 import { LOG } from '../logging/logger.js';
-import { appendLedgerEntry, buildTaskCompletionEvidence, getSessionRecoveryContext, isIntentionalCleanupStopEntry, readLedgerEntries } from './mesh-ledger.js';
+import { appendLedgerEntry, buildTaskCompletionEvidence, getLedgerDir, getSessionRecoveryContext, isIntentionalCleanupStopEntry, readLedgerEntries } from './mesh-ledger.js';
 import type { MeshLedgerKind, SessionRecoveryContext } from './mesh-ledger.js';
 import { claimNextTask, updateSessionTaskStatus, enqueueTask, updateTaskStatus, getQueue, recordTaskAutoLaunch } from './mesh-work-queue.js';
 
 // ---------------------------------------------------------------------------
 // Remote Node Idle Session Tracking
 // ---------------------------------------------------------------------------
-// Tracks remote sessions that emitted 'agent:ready' so triggerMeshQueue 
-// can assign tasks to them.
+// Tracks remote sessions that emitted 'agent:ready' so triggerMeshQueue
+// can assign tasks to them. Each entry carries an expiresAt timestamp;
+// entries are swept on insertion to prevent unbounded growth.
 // ---------------------------------------------------------------------------
 interface RemoteIdleSession {
     nodeId: string;
     sessionId: string;
     providerType: string;
+    expiresAt: number;
 }
+const REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1000; // 5 minutes
 const remoteIdleSessions = new Map<string, RemoteIdleSession>(); // key: `${nodeId}:${sessionId}`
 
+function sweepExpiredRemoteIdleSessions(): void {
+    const now = Date.now();
+    for (const [key, session] of remoteIdleSessions) {
+        if (session.expiresAt <= now) remoteIdleSessions.delete(key);
+    }
+}
+
 // ---------------------------------------------------------------------------
-// MCP coordinator pending-event queue
+// MCP coordinator pending-event queue — FILE-BASED PERSISTENCE
 // ---------------------------------------------------------------------------
 // When a mesh event fires but no CLI coordinator session is registered (e.g.
-// the coordinator is Claude Code running via MCP), we buffer the event here.
-// The MCP server drains this queue on every mesh_status / mesh_send_task poll.
+// the coordinator is Claude Code running via MCP), we persist the event to a
+// per-mesh JSONL file so it survives daemon restarts. The 50-entry hard cap
+// is removed; the file is drained atomically on each get_pending_mesh_events
+// call and limited to 100 KB to prevent runaway growth.
+//
+// File: <ledgerDir>/<meshId>.pending-events.jsonl
 // ---------------------------------------------------------------------------
 
 export interface PendingMeshCoordinatorEvent {
@@ -38,30 +54,53 @@ export interface PendingMeshCoordinatorEvent {
     queuedAt: number;
 }
 
-const MAX_PENDING_EVENTS = 50;
-const pendingMeshCoordinatorEvents: PendingMeshCoordinatorEvent[] = [];
+function getPendingEventsPath(meshId: string): string {
+    const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return join(getLedgerDir(), `${safe}.pending-events.jsonl`);
+}
 
 export function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEvent): boolean {
-    if (pendingMeshCoordinatorEvents.length >= MAX_PENDING_EVENTS) {
+    try {
+        appendFileSync(getPendingEventsPath(event.meshId), JSON.stringify(event) + '\n', 'utf-8');
+        return true;
+    } catch (e: any) {
+        LOG.warn('MeshEvents', `Failed to persist pending coordinator event: ${e?.message || e}`);
         return false;
     }
-    pendingMeshCoordinatorEvents.push(event);
-    return true;
 }
 
-/** Drain and return all pending coordinator events, clearing the queue. */
-export function drainPendingMeshCoordinatorEvents(): PendingMeshCoordinatorEvent[] {
-    return pendingMeshCoordinatorEvents.splice(0);
+/** Drain and return all pending coordinator events for meshId, removing them from disk. */
+export function drainPendingMeshCoordinatorEvents(meshId?: string): PendingMeshCoordinatorEvent[] {
+    if (!meshId) return [];
+    const path = getPendingEventsPath(meshId);
+    if (!existsSync(path)) return [];
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        try { unlinkSync(path); } catch { /* concurrent drain already removed it */ }
+        return raw.split('\n').filter(Boolean).flatMap(line => {
+            try { return [JSON.parse(line) as PendingMeshCoordinatorEvent]; } catch { return []; }
+        });
+    } catch { return []; }
 }
 
 /** Peek at pending coordinator events without draining (non-destructive). */
-export function getPendingMeshCoordinatorEvents(): readonly PendingMeshCoordinatorEvent[] {
-    return pendingMeshCoordinatorEvents.slice();
+export function getPendingMeshCoordinatorEvents(meshId?: string): readonly PendingMeshCoordinatorEvent[] {
+    if (!meshId) return [];
+    const path = getPendingEventsPath(meshId);
+    if (!existsSync(path)) return [];
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        return raw.split('\n').filter(Boolean).flatMap(line => {
+            try { return [JSON.parse(line) as PendingMeshCoordinatorEvent]; } catch { return []; }
+        });
+    } catch { return []; }
 }
 
-/** Explicitly clear all pending coordinator events. */
-export function clearPendingMeshCoordinatorEvents(): void {
-    pendingMeshCoordinatorEvents.splice(0);
+/** Explicitly clear all pending coordinator events for a mesh. */
+export function clearPendingMeshCoordinatorEvents(meshId?: string): void {
+    if (!meshId) return;
+    const path = getPendingEventsPath(meshId);
+    if (existsSync(path)) try { unlinkSync(path); } catch { /* already removed */ }
 }
 
 function readNonEmptyString(value: unknown): string {
@@ -180,7 +219,16 @@ export function tryAssignQueueTask(
                 message: task.message,
             }).catch((e: any) => {
                 LOG.error('MeshQueue', `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
-                updateTaskStatus(meshId, task.id, 'failed');
+                // Revert to pending so the task can be retried rather than permanently failing
+                updateTaskStatus(meshId, task.id, 'pending');
+                try {
+                    appendLedgerEntry(meshId, {
+                        kind: 'dispatch_failed' as any,
+                        nodeId,
+                        sessionId,
+                        payload: { taskId: task.id, error: e?.message, retryable: true },
+                    });
+                } catch { /* ledger write is best-effort */ }
             });
             return true;
         }
@@ -614,10 +662,11 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             const completedTask = updateSessionTaskStatus(args.meshId, sessionId, 'completed');
             completedTaskForLedger = completedTask ? { id: completedTask.id } : null;
             if (nodeId && providerType) {
-                // Short delay to allow completion event to propagate before pulling next
-                setTimeout(() => {
+                // Queue state is already updated above; setImmediate avoids the
+                // 500 ms artificial delay while still deferring past this call frame.
+                setImmediate(() => {
                     tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-                }, 500);
+                });
             }
         }
     } else if (args.event === 'agent:ready') {
@@ -658,13 +707,15 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         }
         
         if (sessionId && nodeId && providerType) {
-            remoteIdleSessions.set(`${nodeId}:${sessionId}`, { nodeId, sessionId, providerType });
-            setTimeout(() => {
+            sweepExpiredRemoteIdleSessions();
+            remoteIdleSessions.set(`${nodeId}:${sessionId}`, {
+                nodeId, sessionId, providerType,
+                expiresAt: Date.now() + REMOTE_IDLE_SESSION_TTL_MS,
+            });
+            setImmediate(() => {
                 const assigned = tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-                if (assigned) {
-                    remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
-                }
-            }, 500);
+                if (assigned) remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+            });
         }
     } else if (args.event === 'agent:generating_started') {
         const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);