@adhdev/daemon-core 0.9.82-rc.43 → 0.9.82-rc.45

package/package.json

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

package/src/commands/router.ts

@@ -114,6 +114,75 @@ function readBooleanValue(...values: unknown[]): boolean | undefined {
     return undefined;
 }
 
+function summarizeRepoMeshDebugGit(git: unknown): Record<string, unknown> | null {
+    const record = readObjectRecord(git);
+    if (!Object.keys(record).length) return null;
+    const submodules = Array.isArray(record.submodules)
+        ? record.submodules.map((entry: any) => ({
+            path: readStringValue(entry?.path) ?? null,
+            commit: readStringValue(entry?.commit)?.slice(0, 12) ?? null,
+            dirty: readBooleanValue(entry?.dirty) ?? false,
+            outOfSync: readBooleanValue(entry?.outOfSync, entry?.out_of_sync) ?? false,
+        }))
+        : [];
+    return {
+        isGitRepo: readBooleanValue(record.isGitRepo),
+        workspace: readStringValue(record.workspace) ?? null,
+        repoRoot: readStringValue(record.repoRoot, record.repo_root) ?? null,
+        branch: readStringValue(record.branch) ?? null,
+        upstream: readStringValue(record.upstream) ?? null,
+        upstreamStatus: readStringValue(record.upstreamStatus, record.upstream_status) ?? null,
+        headCommit: readStringValue(record.headCommit, record.head_commit)?.slice(0, 12) ?? null,
+        ahead: readNumberValue(record.ahead) ?? null,
+        behind: readNumberValue(record.behind) ?? null,
+        dirtyCounts: {
+            staged: readNumberValue(record.staged) ?? 0,
+            modified: readNumberValue(record.modified) ?? 0,
+            untracked: readNumberValue(record.untracked) ?? 0,
+            deleted: readNumberValue(record.deleted) ?? 0,
+            renamed: readNumberValue(record.renamed) ?? 0,
+        },
+        lastCheckedAt: readNumberValue(record.lastCheckedAt, record.last_checked_at) ?? null,
+        submoduleCount: submodules.length,
+        submodules,
+    };
+}
+
+function summarizeRepoMeshStatusDebug(status: any): Record<string, unknown> {
+    const nodes = Array.isArray(status?.nodes) ? status.nodes : [];
+    return {
+        success: status?.success,
+        meshId: readStringValue(status?.meshId, status?.mesh_id) ?? null,
+        refreshedAt: readStringValue(status?.refreshedAt, status?.refreshed_at) ?? null,
+        sourceOfTruth: status?.sourceOfTruth ?? null,
+        nodeCount: nodes.length,
+        nodes: nodes.map((node: any) => ({
+            nodeId: readStringValue(node?.nodeId, node?.id) ?? null,
+            daemonId: readStringValue(node?.daemonId, node?.daemon_id) ?? null,
+            workspace: readStringValue(node?.workspace, node?.git?.workspace) ?? null,
+            health: readStringValue(node?.health) ?? null,
+            machineStatus: readStringValue(node?.machineStatus, node?.machine_status) ?? null,
+            connection: node?.connection && typeof node.connection === 'object' ? {
+                state: readStringValue(node.connection.state) ?? null,
+                transport: readStringValue(node.connection.transport) ?? null,
+                source: readStringValue(node.connection.source) ?? null,
+                reported: readBooleanValue(node.connection.reported) ?? null,
+            } : null,
+            gitProbePending: node?.gitProbePending === true,
+            launchReady: node?.launchReady === true,
+            git: summarizeRepoMeshDebugGit(node?.git),
+        })),
+    };
+}
+
+function logRepoMeshStatusDebug(event: string, fields: Record<string, unknown>): void {
+    try {
+        LOG.info('MeshStatusDebug', `[RepoMeshStatusDebug] ${JSON.stringify({ event, ...fields })}`);
+    } catch {
+        LOG.info('MeshStatusDebug', `[RepoMeshStatusDebug] ${event}`);
+    }
+}
+
 function joinRepoPath(root: string | undefined, relativePath: string | undefined): string | undefined {
     const normalizedRoot = typeof root === 'string' ? root.trim().replace(/[\\/]+$/, '') : '';
     const normalizedPath = typeof relativePath === 'string' ? relativePath.trim() : '';
@@ -194,16 +263,12 @@ function buildInlineMeshTransitGitStatus(node: any): Record<string, unknown> | u
     const probeGitResult = readObjectRecord(probeGit.result);
     const probeDirectStatus = readObjectRecord(probeGit.status);
     const probeNestedStatus = readObjectRecord(probeGitResult.status);
-    const status = Object.keys(directStatus).length
-        ? directStatus
-        : Object.keys(nestedStatus).length
-            ? nestedStatus
-            : Object.keys(probeDirectStatus).length
-                ? probeDirectStatus
-                : Object.keys(probeNestedStatus).length
-                    ? probeNestedStatus
-                    : {};
-    return normalizeInlineMeshGitStatus(status, node, { lastCheckedAt: Date.now() });
+    const candidates = [directStatus, nestedStatus, probeDirectStatus, probeNestedStatus];
+    for (const status of candidates) {
+        const normalized = normalizeInlineMeshGitStatus(status, node, { lastCheckedAt: Date.now() });
+        if (normalized) return normalized;
+    }
+    return undefined;
 }
 
 function recordInlineMeshDirectGitTruth(
@@ -1376,10 +1441,73 @@ export class DaemonCommandRouter {
         return JSON.parse(JSON.stringify(value)) as T;
     }
 
-    private getCachedAggregateMeshStatus(meshId: string): any | null {
+    private hydrateCachedAggregateMeshStatusFromInline(snapshot: any, mesh: any, options?: { requireDirectPeerTruth?: boolean }): any {
+        if (!mesh || typeof mesh !== 'object' || !Array.isArray(mesh.nodes) || !Array.isArray(snapshot?.nodes)) return snapshot;
+        const inlineNodesById = new Map<string, any>();
+        for (const node of mesh.nodes) {
+            const nodeId = readInlineMeshNodeId(node);
+            if (nodeId) inlineNodesById.set(nodeId, node);
+        }
+        if (!inlineNodesById.size) return snapshot;
+
+        let changed = false;
+        const unavailableNodeIds = new Set<string>();
+        const sourceOfTruth = readObjectRecord(snapshot.sourceOfTruth);
+        const directPeerTruth = readObjectRecord(sourceOfTruth.directPeerTruth);
+        for (const entry of Array.isArray(directPeerTruth.unavailableNodeIds) ? directPeerTruth.unavailableNodeIds : []) {
+            const nodeId = readStringValue(entry);
+            if (nodeId) unavailableNodeIds.add(nodeId);
+        }
+
+        const nodes = snapshot.nodes.map((statusNode: any) => {
+            const nodeId = readStringValue(statusNode?.nodeId, statusNode?.id);
+            const inlineNode = nodeId ? inlineNodesById.get(nodeId) : undefined;
+            if (!inlineNode) return statusNode;
+            const liveGit = buildInlineMeshTransitGitStatus(inlineNode);
+            if (!liveGit) return statusNode;
+            const nextStatus = { ...statusNode };
+            nextStatus.git = liveGit;
+            nextStatus.health = deriveMeshNodeHealthFromGit(liveGit);
+            delete nextStatus.gitProbePending;
+            if (readStringValue(nextStatus.error) === 'waiting for live peer git snapshot') delete nextStatus.error;
+            if (!readStringValue(nextStatus.machineStatus)) nextStatus.machineStatus = 'online';
+            if (nodeId) unavailableNodeIds.delete(nodeId);
+            changed = true;
+            return nextStatus;
+        });
+
+        if (!changed && !(options?.requireDirectPeerTruth && unavailableNodeIds.size > 0)) return snapshot;
+        const nextSourceOfTruth = {
+            ...sourceOfTruth,
+            ...(Object.keys(directPeerTruth).length ? {
+                directPeerTruth: {
+                    ...directPeerTruth,
+                    satisfied: options?.requireDirectPeerTruth === true ? unavailableNodeIds.size === 0 : directPeerTruth.satisfied,
+                    unavailableNodeIds: [...unavailableNodeIds],
+                },
+                ...(options?.requireDirectPeerTruth === true ? {
+                    coordinatorOwnsLiveTruth: unavailableNodeIds.size === 0,
+                    currentStatus: unavailableNodeIds.size === 0 ? 'live_git_and_session_probes' : 'direct_peer_truth_unavailable',
+                } : {}),
+            } : {}),
+        };
+        return {
+            ...snapshot,
+            ...(options?.requireDirectPeerTruth === true && unavailableNodeIds.size > 0 ? {
+                success: false,
+                code: 'mesh_direct_peer_truth_unavailable',
+                error: 'Selected coordinator could not confirm direct mesh truth for every remote node yet.',
+            } : {}),
+            sourceOfTruth: nextSourceOfTruth,
+            nodes,
+        };
+    }
+
+    private getCachedAggregateMeshStatus(meshId: string, mesh?: any, options?: { requireDirectPeerTruth?: boolean }): any | null {
         const cached = this.aggregateMeshStatusCache.get(meshId);
         if (!cached?.snapshot || cached.snapshot.success !== true || !Array.isArray(cached.snapshot.nodes)) return null;
-        const snapshot = this.cloneJsonValue(cached.snapshot);
+        let snapshot = this.cloneJsonValue(cached.snapshot);
+        snapshot = this.hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options);
         const ageMs = Math.max(0, Date.now() - cached.builtAt);
         const sourceOfTruth = snapshot.sourceOfTruth && typeof snapshot.sourceOfTruth === 'object'
             ? snapshot.sourceOfTruth
@@ -1453,7 +1581,14 @@ export class DaemonCommandRouter {
         const preferInline = options?.preferInline === true;
         if (preferInline) {
             const cached = this.getCachedInlineMesh(meshId);
-            if (cached) return { mesh: cached, inline: true, source: 'inline_cache' };
+            if (cached) {
+                if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
+                    const merged = reconcileInlineMeshCache(cached, inlineMesh as any);
+                    this.inlineMeshCache.set(meshId, sanitizeInlineMesh(merged));
+                    return { mesh: merged, inline: true, source: 'inline_cache' };
+                }
+                return { mesh: cached, inline: true, source: 'inline_cache' };
+            }
             if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
                 this.warmInlineMeshCache(meshId, inlineMesh);
                 return { mesh: inlineMesh, inline: true, source: 'inline_bootstrap' };
@@ -3725,8 +3860,16 @@ export class DaemonCommandRouter {
 
                     const refreshRequested = args?.refresh === true || args?.forceRefresh === true;
                     if (!refreshRequested) {
-                        const cachedStatus = this.getCachedAggregateMeshStatus(meshId);
-                        if (cachedStatus) return cachedStatus;
+                        const cachedStatus = this.getCachedAggregateMeshStatus(meshId, mesh, { requireDirectPeerTruth: args?.requireDirectPeerTruth === true });
+                        if (cachedStatus) {
+                            logRepoMeshStatusDebug('return_cached', {
+                                meshId,
+                                command: 'mesh_status',
+                                refreshRequested,
+                                summary: summarizeRepoMeshStatusDebug(cachedStatus),
+                            });
+                            return cachedStatus;
+                        }
                     }
                     const refreshReason = refreshRequested ? 'explicit_refresh' : 'cold_cache_miss';
 
@@ -3759,9 +3902,10 @@ export class DaemonCommandRouter {
                             peerConfirmedCount: 0,
                             unavailableNodeIds: [] as string[],
                         };
-                    const directTruthSatisfied = meshRecord.source !== 'inline_bootstrap' || directTruth.directEvidenceCount > 0;
+                    const directTruthSatisfied = !requireDirectPeerTruth
+                        || (directTruth.directEvidenceCount > 0 && directTruth.unavailableNodeIds.length === 0);
                     if (requireDirectPeerTruth && !directTruthSatisfied) {
-                        return {
+                        const failureResult = {
                             success: false,
                             code: 'mesh_direct_peer_truth_unavailable',
                             error: 'Selected coordinator could not confirm direct mesh truth yet. Bootstrap inventory stays unavailable until direct mesh_status probes succeed.',
@@ -3784,6 +3928,14 @@ export class DaemonCommandRouter {
                                 },
                             },
                         };
+                        logRepoMeshStatusDebug('direct_truth_unavailable', {
+                            meshId,
+                            command: 'mesh_status',
+                            refreshRequested,
+                            meshSource: meshRecord.source,
+                            directTruth,
+                        });
+                        return failureResult;
                     }
                     const directTruthUnavailableNodeIds = new Set(directTruth.unavailableNodeIds);
                     const selectedCoordinatorNodeId = readStringValue(
@@ -4019,7 +4171,17 @@ export class DaemonCommandRouter {
                         queue: { tasks: queue, summary: queueSummary },
                         ledger: { entries: ledgerEntries, summary: ledgerSummary },
                     };
-                    return this.rememberAggregateMeshStatus(meshId, statusResult, refreshReason);
+                    const rememberedStatus = this.rememberAggregateMeshStatus(meshId, statusResult, refreshReason);
+                    logRepoMeshStatusDebug('return_live', {
+                        meshId,
+                        command: 'mesh_status',
+                        refreshRequested,
+                        refreshReason,
+                        meshSource: meshRecord.source,
+                        directTruth,
+                        summary: summarizeRepoMeshStatusDebug(rememberedStatus),
+                    });
+                    return rememberedStatus;
                 } catch (e: any) {
                     return { success: false, error: e.message };
                 }