@adhdev/daemon-core 0.9.82-rc.39 → 0.9.82-rc.40

package/dist/commands/router.d.ts

@@ -87,10 +87,16 @@ export declare class DaemonCommandRouter {
      *  Allows the MCP server to query mesh data via get_mesh even when
      *  the mesh doesn't exist in the local meshes.json file. */
     private inlineMeshCache;
+    /** Coordinator-owned whole-mesh aggregate status snapshots. Browser callers read this by default. */
+    private aggregateMeshStatusCache;
     constructor(deps: CommandRouterDeps);
+    private cloneJsonValue;
+    private getCachedAggregateMeshStatus;
+    private rememberAggregateMeshStatus;
     getCachedInlineMesh(meshId: string, inlineMesh?: unknown): any | undefined;
     private warmInlineMeshCache;
     private getMeshForCommand;
+    private invalidateAggregateMeshStatus;
     private updateInlineMeshNode;
     private removeInlineMeshNode;
     private normalizeMeshSessionCleanupMode;

package/dist/index.js

@@ -25001,9 +25001,56 @@ var DaemonCommandRouter = class {
    *  Allows the MCP server to query mesh data via get_mesh even when
    *  the mesh doesn't exist in the local meshes.json file. */
   inlineMeshCache = /* @__PURE__ */ new Map();
+  /** Coordinator-owned whole-mesh aggregate status snapshots. Browser callers read this by default. */
+  aggregateMeshStatusCache = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.deps = deps;
   }
+  cloneJsonValue(value) {
+    if (typeof structuredClone === "function") return structuredClone(value);
+    return JSON.parse(JSON.stringify(value));
+  }
+  getCachedAggregateMeshStatus(meshId) {
+    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);
+    const ageMs = Math.max(0, Date.now() - cached.builtAt);
+    const sourceOfTruth = snapshot.sourceOfTruth && typeof snapshot.sourceOfTruth === "object" ? snapshot.sourceOfTruth : {};
+    snapshot.sourceOfTruth = {
+      ...sourceOfTruth,
+      aggregateSnapshot: {
+        ...sourceOfTruth.aggregateSnapshot && typeof sourceOfTruth.aggregateSnapshot === "object" ? sourceOfTruth.aggregateSnapshot : {},
+        owner: "coordinator_daemon_memory",
+        cached: true,
+        source: "memory",
+        refreshReason: "memory_cache_hit",
+        ageMs,
+        cachedAt: new Date(cached.builtAt).toISOString(),
+        returnedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+    return snapshot;
+  }
+  rememberAggregateMeshStatus(meshId, snapshot, refreshReason) {
+    if (!snapshot || typeof snapshot !== "object" || snapshot.success !== true || !Array.isArray(snapshot.nodes)) return snapshot;
+    const builtAt = Date.now();
+    const next = this.cloneJsonValue(snapshot);
+    const sourceOfTruth = next.sourceOfTruth && typeof next.sourceOfTruth === "object" ? next.sourceOfTruth : {};
+    next.sourceOfTruth = {
+      ...sourceOfTruth,
+      aggregateSnapshot: {
+        owner: "coordinator_daemon_memory",
+        cached: false,
+        source: "live_refresh",
+        refreshReason,
+        ageMs: 0,
+        cachedAt: new Date(builtAt).toISOString(),
+        returnedAt: new Date(builtAt).toISOString()
+      }
+    };
+    this.aggregateMeshStatusCache.set(meshId, { builtAt, snapshot: this.cloneJsonValue(next) });
+    return next;
+  }
   getCachedInlineMesh(meshId, inlineMesh) {
     if (inlineMesh && typeof inlineMesh === "object") {
       return this.warmInlineMeshCache(meshId, inlineMesh);
@@ -25043,6 +25090,9 @@ var DaemonCommandRouter = class {
     const warmedInline = this.warmInlineMeshCache(meshId, inlineMesh);
     return warmedInline ? { mesh: warmedInline, inline: true, source: "inline_bootstrap" } : null;
   }
+  invalidateAggregateMeshStatus(meshId) {
+    this.aggregateMeshStatusCache.delete(meshId);
+  }
   updateInlineMeshNode(meshId, mesh, node) {
     if (!mesh || !Array.isArray(mesh.nodes) || !node?.id) return;
     const idx = mesh.nodes.findIndex((entry) => entry?.id === node.id || entry?.nodeId === node.id);
@@ -25050,6 +25100,7 @@ var DaemonCommandRouter = class {
     else mesh.nodes.push(node);
     mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.inlineMeshCache.set(meshId, mesh);
+    this.invalidateAggregateMeshStatus(meshId);
   }
   removeInlineMeshNode(meshId, mesh, nodeId) {
     if (!mesh || !Array.isArray(mesh.nodes)) return false;
@@ -25058,6 +25109,7 @@ var DaemonCommandRouter = class {
     mesh.nodes.splice(idx, 1);
     mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.inlineMeshCache.set(meshId, mesh);
+    this.invalidateAggregateMeshStatus(meshId);
     return true;
   }
   normalizeMeshSessionCleanupMode(value) {
@@ -26099,6 +26151,7 @@ var DaemonCommandRouter = class {
           const mesh = updateMesh2(meshId, patch);
           if (!mesh) return { success: false, error: "Mesh not found" };
           this.inlineMeshCache.set(meshId, mesh);
+          this.invalidateAggregateMeshStatus(meshId);
           return { success: true, mesh };
         } catch (e) {
           return { success: false, error: e.message };
@@ -26534,6 +26587,7 @@ var DaemonCommandRouter = class {
           } else {
             const { removeNode: removeNode3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
             removed = removeNode3(meshId, nodeId);
+            if (removed) this.invalidateAggregateMeshStatus(meshId);
           }
           if (removed) {
             try {
@@ -26612,6 +26666,7 @@ var DaemonCommandRouter = class {
               policy: { ...sourceNode.policy || {} }
             });
             if (!node) return { success: false, error: "Failed to register worktree node" };
+            this.invalidateAggregateMeshStatus(meshId);
           }
           const initSubmodules = sourceNode.policy?.initSubmodulesOnClone !== false;
           if (initSubmodules) {
@@ -26996,6 +27051,12 @@ ${block}`);
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
           const mesh = meshRecord?.mesh;
           if (!mesh) return { success: false, error: "Mesh not found" };
+          const refreshRequested = args?.refresh === true || args?.forceRefresh === true;
+          if (!refreshRequested) {
+            const cachedStatus = this.getCachedAggregateMeshStatus(meshId);
+            if (cachedStatus) return cachedStatus;
+          }
+          const refreshReason = refreshRequested ? "explicit_refresh" : "cold_cache_miss";
           const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
           const queue = getQueue2(meshId);
           const queueSummary = getMeshQueueStats2(meshId);
@@ -27219,13 +27280,13 @@ ${block}`);
             finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
             nodeStatuses.push(status);
           }
-          return {
+          const statusResult = {
             success: true,
             meshId: mesh.id,
             meshName: mesh.name,
             repoIdentity: mesh.repoIdentity,
             defaultBranch: mesh.defaultBranch,
-            refreshedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            refreshedAt,
             sourceOfTruth: {
               membership: meshRecord?.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord?.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
               coordinatorOwnsLiveTruth: directTruthSatisfied,
@@ -27247,6 +27308,7 @@ ${block}`);
             queue: { tasks: queue, summary: queueSummary },
             ledger: { entries: ledgerEntries, summary: ledgerSummary }
           };
+          return this.rememberAggregateMeshStatus(meshId, statusResult, refreshReason);
         } catch (e) {
           return { success: false, error: e.message };
         }