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

package/dist/index.js

@@ -46981,9 +46981,56 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
        *  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 cached2 = this.aggregateMeshStatusCache.get(meshId);
+        if (!cached2?.snapshot || cached2.snapshot.success !== true || !Array.isArray(cached2.snapshot.nodes)) return null;
+        const snapshot = this.cloneJsonValue(cached2.snapshot);
+        const ageMs = Math.max(0, Date.now() - cached2.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(cached2.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);
@@ -47023,6 +47070,9 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         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);
@@ -47030,6 +47080,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         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;
@@ -47038,6 +47089,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         mesh.nodes.splice(idx, 1);
         mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
         this.inlineMeshCache.set(meshId, mesh);
+        this.invalidateAggregateMeshStatus(meshId);
         return true;
       }
       normalizeMeshSessionCleanupMode(value) {
@@ -48079,6 +48131,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               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 };
@@ -48514,6 +48567,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               } 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 {
@@ -48592,6 +48646,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                   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) {
@@ -48976,6 +49031,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);
@@ -49199,13 +49260,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,
@@ -49227,6 +49288,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 };
             }