@adhdev/daemon-core 0.9.82-rc.462 → 0.9.82-rc.463

package/dist/index.js

@@ -409,10 +409,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "1481e2078cc0eceea283a2370cccb4cd9102e4ff" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "1481e207" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.462" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-04T16:50:21.874Z" : void 0);
+  const commit = readInjected(true ? "3441855fe9c04e158a4dc94eed196b7bcba1647e" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "3441855f" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.463" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-05T02:56:26.902Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -40689,15 +40689,37 @@ function executeSqlite(src, input) {
   }
   try {
     const requested = input.providerSessionId || "";
-    const resolveMessagesFor = (sessionId2) => {
-      if (!sessionId2) return null;
-      let rows;
-      try {
-        rows = db.prepare(src.message_query).all(sessionId2);
-      } catch {
-        return null;
+    const resolveClusterIds = (anchorId) => {
+      const ids = /* @__PURE__ */ new Set();
+      if (anchorId) ids.add(anchorId);
+      if (src.session_cluster_query && anchorId) {
+        try {
+          const rows = db.prepare(src.session_cluster_query).all(anchorId);
+          for (const row of rows) {
+            const idRaw = Object.values(row)[0];
+            if (idRaw != null && String(idRaw)) ids.add(String(idRaw));
+          }
+        } catch {
+        }
       }
-      return rows && rows.length > 0 ? rows : null;
+      return Array.from(ids);
+    };
+    const resolveMessagesFor = (anchorId) => {
+      if (!anchorId) return null;
+      const clusterIds = resolveClusterIds(anchorId);
+      const merged = [];
+      for (const id of clusterIds) {
+        let rows;
+        try {
+          rows = db.prepare(src.message_query).all(id);
+        } catch {
+          continue;
+        }
+        if (rows && rows.length > 0) merged.push(...rows);
+      }
+      if (merged.length === 0) return null;
+      if (clusterIds.length > 1) sortRowsByMappedTimestamp(merged, src.message_map);
+      return merged;
     };
     const resolveNewestSessionId = () => {
       let sessionRow;
@@ -40754,6 +40776,20 @@ function executeSqlite(src, input) {
     }
   }
 }
+function sortRowsByMappedTimestamp(rows, map) {
+  if (!map.timestamp_ms) return;
+  const keyed = rows.map((row, index) => {
+    const parsed = parseTimestamp(jsonPathGet(row, map.timestamp_ms));
+    return { row, index, ts: parsed == null ? Number.NaN : parsed };
+  });
+  keyed.sort((a, b) => {
+    const aHas = !Number.isNaN(a.ts);
+    const bHas = !Number.isNaN(b.ts);
+    if (aHas && bHas && a.ts !== b.ts) return a.ts - b.ts;
+    return a.index - b.index;
+  });
+  for (let i = 0; i < keyed.length; i += 1) rows[i] = keyed[i].row;
+}
 function expandPath2(template, input, opts) {
   if (!template) return null;
   let out = template;
@@ -43378,6 +43414,19 @@ var CliProviderInstance = class _CliProviderInstance {
     }
     return probe;
   }
+  /**
+   * The spawned CLI's env overrides (e.g. the mesh coordinator points hermes
+   * at a per-coordinator HERMES_HOME so its state.db lives in a tmpdir instead
+   * of ~/.hermes). The native-history executor expands `${HERMES_HOME:-~/.hermes}`
+   * from this map, so the completion gate MUST pass it through — otherwise the
+   * gate reads ~/.hermes, finds no coordinator-session transcript, and
+   * false-fires missing_final_assistant on every coordinator turn.
+   */
+  spawnedEnvOverrides() {
+    const meta = typeof this.adapter?.getRuntimeMetadata === "function" ? this.adapter.getRuntimeMetadata() : void 0;
+    const env = meta && typeof meta === "object" ? meta.spawnedEnv : void 0;
+    return env && typeof env === "object" ? env : void 0;
+  }
   readExternalCompletionMessages() {
     const adapterOwnsMessagesElsewhere = this.adapter?.chatMessagesOwnedExternally === true;
     if (!adapterOwnsMessagesElsewhere) return null;
@@ -43398,6 +43447,7 @@ var CliProviderInstance = class _CliProviderInstance {
       historyBehavior: this.provider.historyBehavior,
       scripts: this.provider.scripts,
       sessionStartedAtMs: this.startedAt,
+      envOverrides: this.spawnedEnvOverrides(),
       forceRefresh: true
     });
     if (restoredHistory.source !== "provider-native") {
@@ -48970,14 +49020,44 @@ function openDb() {
     return null;
   }
 }
+function resolveClusterSessionIds(db, anchorId) {
+  if (!anchorId) return [];
+  try {
+    const rows = db.prepare(
+      `WITH RECURSIVE
+               up(id) AS (
+                 SELECT id FROM sessions WHERE id = ?
+                 UNION
+                 SELECT s.parent_session_id FROM sessions s JOIN up ON s.id = up.id
+                   WHERE s.parent_session_id IS NOT NULL
+               ),
+               cluster(id) AS (
+                 SELECT id FROM up
+                 UNION
+                 SELECT s.id FROM sessions s JOIN cluster ON s.parent_session_id = cluster.id
+               )
+             SELECT id FROM cluster`
+    ).all(anchorId);
+    const ids = /* @__PURE__ */ new Set([anchorId]);
+    for (const r of rows) {
+      if (r && r.id != null && String(r.id)) ids.add(String(r.id));
+    }
+    return Array.from(ids);
+  } catch {
+    return [anchorId];
+  }
+}
 function loadMessagesForSession(db, sessionId) {
+  const clusterIds = resolveClusterSessionIds(db, sessionId);
+  if (clusterIds.length === 0) return [];
+  const placeholders = clusterIds.map(() => "?").join(", ");
   const rows = db.prepare(
     `SELECT id, role, COALESCE(NULLIF(content, ''), tool_calls) AS content, timestamp
          FROM messages
-         WHERE session_id = ?
+         WHERE session_id IN (${placeholders})
            AND ((content IS NOT NULL AND content != '') OR (tool_calls IS NOT NULL AND tool_calls != ''))
          ORDER BY timestamp ASC, id ASC`
-  ).all(sessionId);
+  ).all(...clusterIds);
   const out = [];
   for (const r of rows) {
     const role = normalizeHermesRole(r.role);
@@ -54917,7 +54997,6 @@ cleanOldFiles();
 // src/commands/router.ts
 init_debug_trace();
 init_mesh_host_ownership();
-init_mesh_work_queue();
 var fs33 = __toESM(require("fs"));
 
 // src/mesh/mesh-node-identity.ts
@@ -59311,6 +59390,177 @@ async function cleanupMeshSessions(self, args) {
   };
 }
 
+// src/commands/router-aggregate-status.ts
+init_dist();
+init_mesh_work_queue();
+function cloneJsonValue(value) {
+  if (typeof structuredClone === "function") return structuredClone(value);
+  return JSON.parse(JSON.stringify(value));
+}
+function hydrateCachedAggregateMeshStatusFromInline(self, snapshot, mesh, options) {
+  if (!mesh || typeof mesh !== "object" || !Array.isArray(mesh.nodes) || !Array.isArray(snapshot?.nodes)) return snapshot;
+  const inlineNodesById = /* @__PURE__ */ new Map();
+  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 = /* @__PURE__ */ new Set();
+  const sourceOfTruth = readObjectRecord(snapshot.sourceOfTruth);
+  const directPeerTruth = readObjectRecord(sourceOfTruth.directPeerTruth);
+  const deadNodeIds = /* @__PURE__ */ new Set();
+  for (const node of mesh.nodes) {
+    if (!isDeadLocalWorktreeNode(node)) continue;
+    const deadId = readInlineMeshNodeId(node);
+    if (deadId) deadNodeIds.add(deadId);
+  }
+  let droppedDeadUnavailable = false;
+  for (const entry of Array.isArray(directPeerTruth.unavailableNodeIds) ? directPeerTruth.unavailableNodeIds : []) {
+    const nodeId = readStringValue(entry);
+    if (!nodeId) continue;
+    if (deadNodeIds.has(nodeId)) {
+      droppedDeadUnavailable = true;
+      continue;
+    }
+    unavailableNodeIds.add(nodeId);
+  }
+  if (droppedDeadUnavailable) changed = true;
+  const nodes = snapshot.nodes.map((statusNode) => {
+    const nodeId = normalizeMeshNodeId(statusNode);
+    const inlineNode = nodeId ? inlineNodesById.get(nodeId) : void 0;
+    if (!inlineNode) return statusNode;
+    const liveGit = buildInlineMeshTransitGitStatus(inlineNode);
+    if (!liveGit) return statusNode;
+    const nextStatus = { ...statusNode };
+    nextStatus.git = liveGit;
+    nextStatus.health = deriveMeshNodeHealthFromGit(liveGit);
+    applyInlineMeshBranchConvergence(mesh, inlineNode, nextStatus);
+    nextStatus.launchReady = readBooleanValue(nextStatus.launchReady) ?? true;
+    const connection = readObjectRecord(nextStatus.connection);
+    const connectionState = readStringValue(connection.state);
+    const connectionReported = readBooleanValue(connection.reported) ?? false;
+    if (!connectionReported || connectionState === "unknown") {
+      nextStatus.connection = buildLivePeerGitConnection(connection);
+    }
+    delete nextStatus.gitProbePending;
+    const error = readStringValue(nextStatus.error);
+    if (error && /pending_git|git probe|live peer git snapshot|no peer git snapshot/i.test(error)) delete nextStatus.error;
+    if (!readStringValue(nextStatus.machineStatus)) nextStatus.machineStatus = "online";
+    if (nodeId) unavailableNodeIds.delete(nodeId);
+    changed = true;
+    return nextStatus;
+  });
+  const aggregateDirectTruthSatisfied = sourceOfTruth.coordinatorOwnsLiveTruth === true || directPeerTruth.satisfied === true;
+  if (!changed && !(options?.requireDirectPeerTruth && unavailableNodeIds.size > 0 && !aggregateDirectTruthSatisfied)) return snapshot;
+  const nextSourceOfTruth = {
+    ...sourceOfTruth,
+    ...Object.keys(directPeerTruth).length ? {
+      directPeerTruth: {
+        ...directPeerTruth,
+        satisfied: options?.requireDirectPeerTruth === true ? aggregateDirectTruthSatisfied || unavailableNodeIds.size === 0 : directPeerTruth.satisfied,
+        unavailableNodeIds: [...unavailableNodeIds]
+      },
+      ...options?.requireDirectPeerTruth === true ? {
+        coordinatorOwnsLiveTruth: aggregateDirectTruthSatisfied || unavailableNodeIds.size === 0,
+        currentStatus: aggregateDirectTruthSatisfied || unavailableNodeIds.size === 0 ? "live_git_and_session_probes" : "direct_peer_truth_unavailable"
+      } : {}
+    } : {}
+  };
+  return {
+    ...snapshot,
+    ...options?.requireDirectPeerTruth === true && unavailableNodeIds.size > 0 && !aggregateDirectTruthSatisfied ? {
+      success: false,
+      code: "mesh_direct_peer_truth_unavailable",
+      error: "Selected coordinator could not confirm direct mesh truth for every remote node yet."
+    } : {},
+    sourceOfTruth: nextSourceOfTruth,
+    branchConvergenceSummary: summarizeInlineMeshBranchConvergence(nodes),
+    nodes
+  };
+}
+function getCachedAggregateMeshStatus(self, meshId, mesh, options) {
+  const cached3 = self.aggregateMeshStatusCache.get(meshId);
+  if (!cached3?.snapshot || cached3.snapshot.success !== true || !Array.isArray(cached3.snapshot.nodes)) return null;
+  if (cached3.queueRevision !== getMeshQueueRevision(meshId)) return null;
+  let snapshot = cloneJsonValue(cached3.snapshot);
+  snapshot = hydrateCachedAggregateMeshStatusFromInline(self, snapshot, mesh, options);
+  if (!options?.allowStalePending && shouldRefreshStalePendingAggregate(snapshot, options)) return null;
+  const ageMs = Math.max(0, Date.now() - cached3.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(cached3.builtAt).toISOString(),
+      returnedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  return snapshot;
+}
+function rememberAggregateMeshStatus(self, meshId, snapshot, refreshReason) {
+  if (!snapshot || typeof snapshot !== "object" || snapshot.success !== true || !Array.isArray(snapshot.nodes)) return snapshot;
+  const builtAt = Date.now();
+  const next = 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()
+    }
+  };
+  self.aggregateMeshStatusCache.set(meshId, { builtAt, snapshot: cloneJsonValue(next), queueRevision: getMeshQueueRevision(meshId) });
+  return next;
+}
+
+// src/commands/router-mesh-session-owner.ts
+init_dist();
+function resolveRemoteMeshSessionOwnerDaemonId(self, sessionId, ownerNodeIdHint) {
+  const trimmed = typeof sessionId === "string" ? sessionId.trim() : "";
+  const nodeHint = typeof ownerNodeIdHint === "string" ? ownerNodeIdHint.trim() : "";
+  if (!trimmed && !nodeHint) return void 0;
+  const selfDaemonId = self.deps.statusInstanceId;
+  const candidates = collectMeshSessionOwnerCandidateNodes(self);
+  if (trimmed) {
+    for (const node of candidates) {
+      if (!collectMeshNodeHostedSessionIds(node).has(trimmed)) continue;
+      const nodeDaemonId = readMeshNodeDaemonId(readObjectRecord(node));
+      if (!nodeDaemonId) continue;
+      if (selfDaemonId && daemonIdsEquivalent(nodeDaemonId, selfDaemonId)) return void 0;
+      return nodeDaemonId;
+    }
+  }
+  if (nodeHint) {
+    for (const node of candidates) {
+      if (!meshNodeIdMatches(node, nodeHint)) continue;
+      const nodeDaemonId = readMeshNodeDaemonId(readObjectRecord(node));
+      if (!nodeDaemonId) continue;
+      if (selfDaemonId && daemonIdsEquivalent(nodeDaemonId, selfDaemonId)) return void 0;
+      return nodeDaemonId;
+    }
+  }
+  return void 0;
+}
+function collectMeshSessionOwnerCandidateNodes(self) {
+  const nodes = self.getCachedInlineMeshNodes();
+  for (const cached3 of self.aggregateMeshStatusCache.values()) {
+    const snapshotNodes = cached3?.snapshot?.nodes;
+    if (Array.isArray(snapshotNodes)) nodes.push(...snapshotNodes);
+  }
+  return nodes;
+}
+
 // src/mesh/mesh-coordinator-config.ts
 init_logger();
 var yaml5 = __toESM(require("js-yaml"));
@@ -59479,7 +59729,8 @@ var DaemonCommandRouter = class {
    *  on disk) clears the tombstone and merges normally, preserving clone
    *  worktree visibility and legitimate node re-creation. */
   removedInlineMeshNodeIds = /* @__PURE__ */ new Map();
-  /** Coordinator-owned whole-mesh aggregate status snapshots. Browser callers read this by default. */
+  /** Coordinator-owned whole-mesh aggregate status snapshots. Browser callers read this by default.
+   *  Public (not private) so the extracted ./router-aggregate-status.ts orchestration can reach it via `self`. */
   aggregateMeshStatusCache = /* @__PURE__ */ new Map();
   /** Shared per-peer git_status probe dedup + recently-probed reuse gate.
    *  Spans separate mesh_status/get_mesh calls so the dashboard auto-retry
@@ -59501,135 +59752,19 @@ var DaemonCommandRouter = class {
   constructor(deps) {
     this.deps = deps;
   }
-  cloneJsonValue(value) {
-    if (typeof structuredClone === "function") return structuredClone(value);
-    return JSON.parse(JSON.stringify(value));
-  }
+  // ─── Aggregate mesh-status cache ────────────────────────────────────
+  // Implementation lives in ./router-aggregate-status.ts (behavior-preserving
+  // code move). Kept here as thin delegators: getCachedAggregateMeshStatus /
+  // rememberAggregateMeshStatus are bound into HighFamilyContext, so callers
+  // reach these via `self.` for correct instance dispatch.
   hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options) {
-    if (!mesh || typeof mesh !== "object" || !Array.isArray(mesh.nodes) || !Array.isArray(snapshot?.nodes)) return snapshot;
-    const inlineNodesById = /* @__PURE__ */ new Map();
-    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 = /* @__PURE__ */ new Set();
-    const sourceOfTruth = readObjectRecord(snapshot.sourceOfTruth);
-    const directPeerTruth = readObjectRecord(sourceOfTruth.directPeerTruth);
-    const deadNodeIds = /* @__PURE__ */ new Set();
-    for (const node of mesh.nodes) {
-      if (!isDeadLocalWorktreeNode(node)) continue;
-      const deadId = readInlineMeshNodeId(node);
-      if (deadId) deadNodeIds.add(deadId);
-    }
-    let droppedDeadUnavailable = false;
-    for (const entry of Array.isArray(directPeerTruth.unavailableNodeIds) ? directPeerTruth.unavailableNodeIds : []) {
-      const nodeId = readStringValue(entry);
-      if (!nodeId) continue;
-      if (deadNodeIds.has(nodeId)) {
-        droppedDeadUnavailable = true;
-        continue;
-      }
-      unavailableNodeIds.add(nodeId);
-    }
-    if (droppedDeadUnavailable) changed = true;
-    const nodes = snapshot.nodes.map((statusNode) => {
-      const nodeId = normalizeMeshNodeId(statusNode);
-      const inlineNode = nodeId ? inlineNodesById.get(nodeId) : void 0;
-      if (!inlineNode) return statusNode;
-      const liveGit = buildInlineMeshTransitGitStatus(inlineNode);
-      if (!liveGit) return statusNode;
-      const nextStatus = { ...statusNode };
-      nextStatus.git = liveGit;
-      nextStatus.health = deriveMeshNodeHealthFromGit(liveGit);
-      applyInlineMeshBranchConvergence(mesh, inlineNode, nextStatus);
-      nextStatus.launchReady = readBooleanValue(nextStatus.launchReady) ?? true;
-      const connection = readObjectRecord(nextStatus.connection);
-      const connectionState = readStringValue(connection.state);
-      const connectionReported = readBooleanValue(connection.reported) ?? false;
-      if (!connectionReported || connectionState === "unknown") {
-        nextStatus.connection = buildLivePeerGitConnection(connection);
-      }
-      delete nextStatus.gitProbePending;
-      const error = readStringValue(nextStatus.error);
-      if (error && /pending_git|git probe|live peer git snapshot|no peer git snapshot/i.test(error)) delete nextStatus.error;
-      if (!readStringValue(nextStatus.machineStatus)) nextStatus.machineStatus = "online";
-      if (nodeId) unavailableNodeIds.delete(nodeId);
-      changed = true;
-      return nextStatus;
-    });
-    const aggregateDirectTruthSatisfied = sourceOfTruth.coordinatorOwnsLiveTruth === true || directPeerTruth.satisfied === true;
-    if (!changed && !(options?.requireDirectPeerTruth && unavailableNodeIds.size > 0 && !aggregateDirectTruthSatisfied)) return snapshot;
-    const nextSourceOfTruth = {
-      ...sourceOfTruth,
-      ...Object.keys(directPeerTruth).length ? {
-        directPeerTruth: {
-          ...directPeerTruth,
-          satisfied: options?.requireDirectPeerTruth === true ? aggregateDirectTruthSatisfied || unavailableNodeIds.size === 0 : directPeerTruth.satisfied,
-          unavailableNodeIds: [...unavailableNodeIds]
-        },
-        ...options?.requireDirectPeerTruth === true ? {
-          coordinatorOwnsLiveTruth: aggregateDirectTruthSatisfied || unavailableNodeIds.size === 0,
-          currentStatus: aggregateDirectTruthSatisfied || unavailableNodeIds.size === 0 ? "live_git_and_session_probes" : "direct_peer_truth_unavailable"
-        } : {}
-      } : {}
-    };
-    return {
-      ...snapshot,
-      ...options?.requireDirectPeerTruth === true && unavailableNodeIds.size > 0 && !aggregateDirectTruthSatisfied ? {
-        success: false,
-        code: "mesh_direct_peer_truth_unavailable",
-        error: "Selected coordinator could not confirm direct mesh truth for every remote node yet."
-      } : {},
-      sourceOfTruth: nextSourceOfTruth,
-      branchConvergenceSummary: summarizeInlineMeshBranchConvergence(nodes),
-      nodes
-    };
+    return hydrateCachedAggregateMeshStatusFromInline(this, snapshot, mesh, options);
   }
   getCachedAggregateMeshStatus(meshId, mesh, options) {
-    const cached3 = this.aggregateMeshStatusCache.get(meshId);
-    if (!cached3?.snapshot || cached3.snapshot.success !== true || !Array.isArray(cached3.snapshot.nodes)) return null;
-    if (cached3.queueRevision !== getMeshQueueRevision(meshId)) return null;
-    let snapshot = this.cloneJsonValue(cached3.snapshot);
-    snapshot = this.hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options);
-    if (!options?.allowStalePending && shouldRefreshStalePendingAggregate(snapshot, options)) return null;
-    const ageMs = Math.max(0, Date.now() - cached3.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(cached3.builtAt).toISOString(),
-        returnedAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-    return snapshot;
+    return getCachedAggregateMeshStatus(this, meshId, mesh, options);
   }
   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), queueRevision: getMeshQueueRevision(meshId) });
-    return next;
+    return rememberAggregateMeshStatus(this, meshId, snapshot, refreshReason);
   }
   getCachedInlineMeshNodes() {
     const nodes = [];
@@ -59640,82 +59775,13 @@ var DaemonCommandRouter = class {
     }
     return nodes;
   }
-  /**
-   * Resolve the REMOTE worker daemonId that owns a given session, when the session
-   * belongs to a mesh node hosted on a DIFFERENT daemon than this coordinator.
-   *
-   * The coordinator does not host remote-worker session instances in its own
-   * instanceManager/sessionRegistry — only their cached mesh-node metadata. A
-   * dashboard-issued session-scoped command (invoke_provider_script / resolve_action /
-   * set_mode / …) lands on the coordinator with a targetSessionId the coordinator can't
-   * find locally, and without forwarding it dies as "Live session not found". send_chat
-   * happens to survive (its target resolves to the worker by another route), but the
-   * controlbar commands do not — so the controlbar buttons appear to do nothing.
-   *
-   * Mirror the existing node-level remote-forward pattern (fast_forward_mesh_node etc.):
-   * scan the candidate mesh nodes for the one hosting the targetSessionId, and return its
-   * daemonId when that daemonId is a remote daemon (i.e. not this coordinator's own
-   * statusInstanceId). Returns undefined for a locally-hosted session (no forward — execute
-   * locally as before) or when ownership can't be resolved.
-   *
-   * The candidate set spans BOTH the cached inline-mesh nodes and the live aggregate
-   * mesh-status snapshots. The inline cache reliably carries only each node's single primary
-   * session (cachedStatus.activeSession), so a worker hosting more than one session exposes its
-   * non-primary sessions only on the aggregate snapshot nodes (status.activeSessions /
-   * activeSessionDetails, built from live session records). collectMeshNodeHostedSessionIds does
-   * the wider plural-shape scan so a controlbar/modal command targeting a non-primary remote
-   * session still resolves its owner — the singular readCachedInlineMeshActiveSessions semantics
-   * other consumers depend on stay untouched.
-   *
-   * CANCEL-STOP-RELAY: the session-id cache scan above only matches when the coordinator's
-   * cached status snapshot already lists the worker's session id in a recognized active-sessions
-   * shape. A worktree-clone worker session whose id form/timing differs from the cached snapshot
-   * (or is simply not yet reflected) misses the scan, so a stop that carries the authoritative
-   * owning nodeId (mesh_queue_cancel knows assignedNodeId) used to silently fail to forward.
-   * `ownerNodeIdHint` adds a deterministic fallback: when the session-id scan misses, resolve the
-   * owner daemonId by matching the node by id (meshNodeIdMatches — same form-tolerant compare the
-   * rest of the router uses, no new raw compare). The same self-loopback guard applies to both
-   * paths, so a coordinator-hosted node is still never force-forwarded to a remote form of itself.
-   */
+  // ─── Remote mesh-session owner resolution ───────────────────────────
+  // Implementation lives in ./router-mesh-session-owner.ts (behavior-preserving
+  // code move). resolveRemoteMeshSessionOwnerDaemonId stays public (the [Z]
+  // session-scoped forward in executeDaemonCommand and a unit test call it), so
+  // it's kept here as a thin delegator.
   resolveRemoteMeshSessionOwnerDaemonId(sessionId, ownerNodeIdHint) {
-    const trimmed = typeof sessionId === "string" ? sessionId.trim() : "";
-    const nodeHint = typeof ownerNodeIdHint === "string" ? ownerNodeIdHint.trim() : "";
-    if (!trimmed && !nodeHint) return void 0;
-    const selfDaemonId = this.deps.statusInstanceId;
-    const candidates = this.collectMeshSessionOwnerCandidateNodes();
-    if (trimmed) {
-      for (const node of candidates) {
-        if (!collectMeshNodeHostedSessionIds(node).has(trimmed)) continue;
-        const nodeDaemonId = readMeshNodeDaemonId(readObjectRecord(node));
-        if (!nodeDaemonId) continue;
-        if (selfDaemonId && daemonIdsEquivalent(nodeDaemonId, selfDaemonId)) return void 0;
-        return nodeDaemonId;
-      }
-    }
-    if (nodeHint) {
-      for (const node of candidates) {
-        if (!meshNodeIdMatches(node, nodeHint)) continue;
-        const nodeDaemonId = readMeshNodeDaemonId(readObjectRecord(node));
-        if (!nodeDaemonId) continue;
-        if (selfDaemonId && daemonIdsEquivalent(nodeDaemonId, selfDaemonId)) return void 0;
-        return nodeDaemonId;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Candidate nodes for remote-session owner resolution: the cached inline-mesh nodes (which
-   * carry each node's primary session) plus the nodes from every cached aggregate mesh-status
-   * snapshot (which carry each node's full live session list). getCachedInlineMeshNodes()
-   * returns a fresh array, so appending the aggregate nodes never mutates cached state.
-   */
-  collectMeshSessionOwnerCandidateNodes() {
-    const nodes = this.getCachedInlineMeshNodes();
-    for (const cached3 of this.aggregateMeshStatusCache.values()) {
-      const snapshotNodes = cached3?.snapshot?.nodes;
-      if (Array.isArray(snapshotNodes)) nodes.push(...snapshotNodes);
-    }
-    return nodes;
+    return resolveRemoteMeshSessionOwnerDaemonId(this, sessionId, ownerNodeIdHint);
   }
   getCachedInlineMesh(meshId, inlineMesh) {
     if (inlineMesh && typeof inlineMesh === "object") {