@adhdev/daemon-core 0.9.82-rc.17 → 0.9.82-rc.19

package/package.json

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

package/src/commands/router.ts

@@ -328,6 +328,59 @@ function summarizeMeshSessionRecord(record: any): Record<string, unknown> {
     };
 }
 
+function readLiveMeshNodeWorkspace(args: {
+    meshId: string;
+    nodeId: string;
+    liveSessionRecords: any[];
+    allowCoordinatorSession?: boolean;
+}): string {
+    const directNodeWorkspace = args.liveSessionRecords.find((record) => (
+        readStringValue(record?.meta?.meshNodeId) === args.nodeId
+        && readStringValue(record?.workspace)
+    ));
+    if (directNodeWorkspace) {
+        return readStringValue(directNodeWorkspace.workspace) || '';
+    }
+
+    if (args.allowCoordinatorSession) {
+        const coordinatorWorkspace = args.liveSessionRecords.find((record) => (
+            readStringValue(record?.meta?.meshCoordinatorFor) === args.meshId
+            && readStringValue(record?.workspace)
+        ));
+        if (coordinatorWorkspace) {
+            return readStringValue(coordinatorWorkspace.workspace) || '';
+        }
+    }
+
+    return '';
+}
+
+function collectLiveMeshSessionRecords(args: {
+    meshId: string;
+    node: any;
+    nodeId: string;
+    liveSessionRecords: any[];
+    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 (args.allowCoordinatorSession) {
+        for (const record of args.liveSessionRecords) {
+            if (readStringValue(record?.meta?.meshCoordinatorFor) !== args.meshId) continue;
+            const sessionId = readStringValue(record?.sessionId);
+            if (sessionId && matches.some((entry) => readStringValue(entry?.sessionId) === sessionId)) continue;
+            matches.push(record);
+        }
+    }
+
+    return matches;
+}
+
 function applyCachedInlineMeshNodeStatus(status: Record<string, unknown>, node: any): boolean {
     const cachedStatus = readObjectRecord(node?.cachedStatus);
     const git = buildCachedInlineMeshGitStatus(node);
@@ -900,29 +953,40 @@ export class DaemonCommandRouter {
 
     public getCachedInlineMesh(meshId: string, inlineMesh?: unknown): any | undefined {
         if (inlineMesh && typeof inlineMesh === 'object') {
-            this.inlineMeshCache.set(meshId, inlineMesh as any);
-            return inlineMesh as any;
+            return this.warmInlineMeshCache(meshId, inlineMesh);
         }
         return this.inlineMeshCache.get(meshId);
     }
 
+    private warmInlineMeshCache(meshId: string, inlineMesh?: unknown): any | undefined {
+        if (!inlineMesh || typeof inlineMesh !== 'object') return undefined;
+        const cached = this.inlineMeshCache.get(meshId);
+        if (cached) return cached;
+        this.inlineMeshCache.set(meshId, inlineMesh as any);
+        return inlineMesh as any;
+    }
+
     private async getMeshForCommand(
         meshId: string,
         inlineMesh?: unknown,
         options?: { preferInline?: boolean },
-    ): Promise<{ mesh: any; inline: boolean } | null> {
+    ): Promise<{ mesh: any; inline: boolean; source: 'inline_cache' | 'inline_bootstrap' | 'local_config' } | null> {
         const preferInline = options?.preferInline === true;
         if (preferInline) {
-            const cached = this.getCachedInlineMesh(meshId, inlineMesh);
-            if (cached) return { mesh: cached, inline: true };
+            const cached = this.getCachedInlineMesh(meshId);
+            if (cached) return { mesh: cached, inline: true, source: 'inline_cache' };
+            const warmedInline = this.warmInlineMeshCache(meshId, inlineMesh);
+            if (warmedInline) return { mesh: warmedInline, inline: true, source: 'inline_bootstrap' };
         }
         try {
             const { getMesh } = await import('../config/mesh-config.js');
             const mesh = getMesh(meshId);
-            if (mesh) return { mesh, inline: false };
+            if (mesh) return { mesh, inline: false, source: 'local_config' };
         } catch { /* fall through to inline cache */ }
-        const cached = this.getCachedInlineMesh(meshId, inlineMesh);
-        return cached ? { mesh: cached, inline: true } : null;
+        const cached = this.getCachedInlineMesh(meshId);
+        if (cached) return { mesh: cached, inline: true, source: 'inline_cache' };
+        const warmedInline = this.warmInlineMeshCache(meshId, inlineMesh);
+        return warmedInline ? { mesh: warmedInline, inline: true, source: 'inline_bootstrap' } : null;
     }
 
     private updateInlineMeshNode(meshId: string, mesh: any, node: any): void {
@@ -1219,6 +1283,7 @@ export class DaemonCommandRouter {
         const deletedSessionIds: string[] = [];
         const skippedSessionIds: string[] = [];
         const skippedLiveSessionIds: string[] = [];
+        const skippedCoordinatorSessionIds: string[] = [];
         const deleteUnsupportedSessionIds: string[] = [];
         const recordsRemainSessionIds: string[] = [];
         const errors: Array<{ sessionId: string; error: string }> = [];
@@ -1253,6 +1318,12 @@ export class DaemonCommandRouter {
             const completed = this.isCompletedHostedSession(record);
             const surfaceKind = getSessionHostSurfaceKind(record);
             const liveRuntime = surfaceKind === 'live_runtime';
+            const coordinatorSession = readStringValue(record?.meta?.meshCoordinatorFor) === args.meshId;
+            if (!hasExplicitSessionIds && coordinatorSession) {
+                skippedSessionIds.push(sessionId);
+                skippedCoordinatorSessionIds.push(sessionId);
+                continue;
+            }
             if (!hasExplicitSessionIds && liveRuntime) {
                 skippedSessionIds.push(sessionId);
                 skippedLiveSessionIds.push(sessionId);
@@ -1322,6 +1393,7 @@ export class DaemonCommandRouter {
             deletedSessionIds,
             skippedSessionIds,
             skippedLiveSessionIds,
+            skippedCoordinatorSessionIds,
             ...(deleteUnsupported ? {
                 deleteUnsupported: true,
                 effectiveCleanup: args.mode === 'stop_and_delete'
@@ -2669,7 +2741,16 @@ export class DaemonCommandRouter {
                             cliType,
                         };
                     }
-                    const workspace = typeof coordinatorNode.workspace === 'string' ? coordinatorNode.workspace.trim() : '';
+                    const sessionHostRecords = this.deps.sessionHostControl?.listSessions
+                        ? await this.deps.sessionHostControl.listSessions().catch(() => [])
+                        : [];
+                    const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
+                    const workspace = readLiveMeshNodeWorkspace({
+                        meshId,
+                        nodeId: String(coordinatorNode.id || coordinatorNode.nodeId || preferredCoordinatorNodeId || ''),
+                        liveSessionRecords: liveMeshSessions,
+                        allowCoordinatorSession: true,
+                    }) || (typeof coordinatorNode.workspace === 'string' ? coordinatorNode.workspace.trim() : '');
                     if (!workspace) return { success: false, error: 'Coordinator node workspace required', meshId, cliType };
                     if (!cliType) {
                         const resolved = await resolveProviderTypeFromPriority({
@@ -3028,8 +3109,13 @@ export class DaemonCommandRouter {
                     const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
 
                     const localMachineId = loadConfig().machineId || '';
+                    const selectedCoordinatorNodeId = readStringValue(
+                        mesh.coordinator?.preferredNodeId,
+                        (mesh.nodes?.[0] as any)?.id,
+                        (mesh.nodes?.[0] as any)?.nodeId,
+                    );
                     const inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes)
-                        ? readStringValue((mesh.nodes[0] as any)?.id, (mesh.nodes[0] as any)?.nodeId)
+                        ? selectedCoordinatorNodeId
                         : undefined;
                     const refreshedAt = new Date().toISOString();
                     const nodeStatuses = [];
@@ -3089,8 +3175,20 @@ export class DaemonCommandRouter {
                                 reason: 'Node has no daemon id, so mesh transport cannot be reported from the selected coordinator.',
                             };
                         }
-                        const matchedLiveSessionRecords = liveMeshSessions
-                            .filter((record) => this.sessionMatchesMeshNode(record, node, nodeId));
+                        const matchedLiveSessionRecords = collectLiveMeshSessionRecords({
+                            meshId,
+                            node,
+                            nodeId,
+                            liveSessionRecords: liveMeshSessions,
+                            allowCoordinatorSession: nodeId === selectedCoordinatorNodeId,
+                        });
+                        const workspace = readLiveMeshNodeWorkspace({
+                            meshId,
+                            nodeId,
+                            liveSessionRecords: matchedLiveSessionRecords,
+                            allowCoordinatorSession: nodeId === selectedCoordinatorNodeId,
+                        }) || (typeof node.workspace === 'string' ? node.workspace : '');
+                        status.workspace = workspace || node.workspace;
                         if (matchedLiveSessionRecords.length > 0) {
                             const sessionIds = matchedLiveSessionRecords
                                 .map((record: any) => typeof record?.sessionId === 'string' ? record.sessionId : '')
@@ -3104,14 +3202,14 @@ export class DaemonCommandRouter {
                                 status.providers = Array.from(new Set([...(Array.isArray(status.providers) ? status.providers as string[] : []), ...providerTypes]));
                             }
                         }
-                        if (node.workspace && typeof node.workspace === 'string') {
-                            if (!fs.existsSync(node.workspace as string) && applyCachedInlineMeshNodeStatus(status, node)) {
+                        if (workspace) {
+                            if (!fs.existsSync(workspace) && applyCachedInlineMeshNodeStatus(status, node)) {
                                 status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === 'online' || isSelfNode);
                                 nodeStatuses.push(status);
                                 continue;
                             }
                             try {
-                                const gitStatus = await getGitRepoStatus(node.workspace as string, { timeoutMs: 10_000, refreshUpstream: true });
+                                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>);
@@ -3138,6 +3236,15 @@ export class DaemonCommandRouter {
                         repoIdentity: mesh.repoIdentity,
                         defaultBranch: mesh.defaultBranch,
                         refreshedAt: new Date().toISOString(),
+                        sourceOfTruth: {
+                            membership: meshRecord?.source === 'inline_cache'
+                                ? 'coordinator_inline_mesh_cache'
+                                : meshRecord?.source === 'local_config'
+                                    ? 'local_mesh_config'
+                                    : 'inline_bootstrap_snapshot',
+                            coordinatorOwnsLiveTruth: meshRecord?.source !== 'inline_bootstrap',
+                            historicalEvidenceOnly: ['recoveryHints', 'ledger.summary', 'queue.summary'],
+                        },
                         nodes: nodeStatuses,
                         queue: { tasks: queue, summary: queueSummary },
                         ledger: { entries: ledgerEntries, summary: ledgerSummary },