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

package/dist/commands/router.d.ts

@@ -87,6 +87,7 @@ export declare class DaemonCommandRouter {
     private inlineMeshCache;
     constructor(deps: CommandRouterDeps);
     getCachedInlineMesh(meshId: string, inlineMesh?: unknown): any | undefined;
+    private warmInlineMeshCache;
     private getMeshForCommand;
     private updateInlineMeshNode;
     private removeInlineMeshNode;

package/dist/index.js

@@ -24098,6 +24098,36 @@ function summarizeMeshSessionRecord(record) {
     isCached: false
   };
 }
+function readLiveMeshNodeWorkspace(args) {
+  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) {
+  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, node) {
   const cachedStatus = readObjectRecord(node?.cachedStatus);
   const git = buildCachedInlineMeshGitStatus(node);
@@ -24522,25 +24552,35 @@ var DaemonCommandRouter = class {
   }
   getCachedInlineMesh(meshId, inlineMesh) {
     if (inlineMesh && typeof inlineMesh === "object") {
-      this.inlineMeshCache.set(meshId, inlineMesh);
-      return inlineMesh;
+      return this.warmInlineMeshCache(meshId, inlineMesh);
     }
     return this.inlineMeshCache.get(meshId);
   }
+  warmInlineMeshCache(meshId, inlineMesh) {
+    if (!inlineMesh || typeof inlineMesh !== "object") return void 0;
+    const cached = this.inlineMeshCache.get(meshId);
+    if (cached) return cached;
+    this.inlineMeshCache.set(meshId, inlineMesh);
+    return inlineMesh;
+  }
   async getMeshForCommand(meshId, inlineMesh, options) {
     const preferInline = options?.preferInline === true;
     if (preferInline) {
-      const cached2 = this.getCachedInlineMesh(meshId, inlineMesh);
-      if (cached2) return { mesh: cached2, inline: true };
+      const cached2 = this.getCachedInlineMesh(meshId);
+      if (cached2) return { mesh: cached2, inline: true, source: "inline_cache" };
+      const warmedInline2 = this.warmInlineMeshCache(meshId, inlineMesh);
+      if (warmedInline2) return { mesh: warmedInline2, inline: true, source: "inline_bootstrap" };
     }
     try {
       const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
       const mesh = getMesh3(meshId);
-      if (mesh) return { mesh, inline: false };
+      if (mesh) return { mesh, inline: false, source: "local_config" };
     } catch {
     }
-    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;
   }
   updateInlineMeshNode(meshId, mesh, node) {
     if (!mesh || !Array.isArray(mesh.nodes) || !node?.id) return;
@@ -24769,6 +24809,7 @@ var DaemonCommandRouter = class {
     const deletedSessionIds = [];
     const skippedSessionIds = [];
     const skippedLiveSessionIds = [];
+    const skippedCoordinatorSessionIds = [];
     const deleteUnsupportedSessionIds = [];
     const recordsRemainSessionIds = [];
     const errors = [];
@@ -24801,6 +24842,12 @@ var DaemonCommandRouter = class {
       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);
@@ -24866,6 +24913,7 @@ var DaemonCommandRouter = class {
       deletedSessionIds,
       skippedSessionIds,
       skippedLiveSessionIds,
+      skippedCoordinatorSessionIds,
       ...deleteUnsupported ? {
         deleteUnsupported: true,
         effectiveCleanup: args.mode === "stop_and_delete" ? "stopped_only_records_remain" : "delete_unsupported_records_remain",
@@ -26050,7 +26098,14 @@ var DaemonCommandRouter = class {
               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({
@@ -26361,7 +26416,12 @@ ${block}`);
           const sessionHostRecords = this.deps.sessionHostControl?.listSessions ? await this.deps.sessionHostControl.listSessions().catch(() => []) : [];
           const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
           const localMachineId = loadConfig().machineId || "";
-          const inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes) ? readStringValue(mesh.nodes[0]?.id, mesh.nodes[0]?.nodeId) : void 0;
+          const selectedCoordinatorNodeId = readStringValue(
+            mesh.coordinator?.preferredNodeId,
+            mesh.nodes?.[0]?.id,
+            mesh.nodes?.[0]?.nodeId
+          );
+          const inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes) ? selectedCoordinatorNodeId : void 0;
           const refreshedAt = (/* @__PURE__ */ new Date()).toISOString();
           const nodeStatuses = [];
           for (const [nodeIndex, node] of (mesh.nodes || []).entries()) {
@@ -26420,7 +26480,20 @@ ${block}`);
                 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) => typeof record?.sessionId === "string" ? record.sessionId : "").filter(Boolean);
               const providerTypes = matchedLiveSessionRecords.map((record) => readStringValue(record?.providerType)).filter(Boolean);
@@ -26430,14 +26503,14 @@ ${block}`);
                 status.providers = Array.from(/* @__PURE__ */ new Set([...Array.isArray(status.providers) ? status.providers : [], ...providerTypes]));
               }
             }
-            if (node.workspace && typeof node.workspace === "string") {
-              if (!fs10.existsSync(node.workspace) && applyCachedInlineMeshNodeStatus(status, node)) {
+            if (workspace) {
+              if (!fs10.existsSync(workspace) && applyCachedInlineMeshNodeStatus(status, node)) {
                 status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
                 nodeStatuses.push(status);
                 continue;
               }
               try {
-                const gitStatus = await getGitRepoStatus(node.workspace, { timeoutMs: 1e4, refreshUpstream: true });
+                const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
                 status.git = gitStatus;
                 if (gitStatus.isGitRepo) {
                   status.health = deriveMeshNodeHealthFromGit(gitStatus);
@@ -26463,6 +26536,11 @@ ${block}`);
             repoIdentity: mesh.repoIdentity,
             defaultBranch: mesh.defaultBranch,
             refreshedAt: (/* @__PURE__ */ 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 }