@adhdev/daemon-core 0.9.82-rc.461 → 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 ? "ed8842e811aa362a2b4cc530498bc1fc7e1a7e4a" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "ed8842e8" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.461" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-04T15:00:03.344Z" : 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;
 }
@@ -11479,6 +11479,37 @@ var init_mesh_events_utils = __esm({
 function normalizeCoordinatorDaemonIds(coordinatorDaemonId) {
   return expandDaemonIdForms(coordinatorDaemonId);
 }
+function isMeshProtocolV2EnforceEnabled() {
+  const raw = readNonEmptyString2(process.env.MESH_PROTOCOL_V2_ENFORCE);
+  if (!raw) return false;
+  const v = raw.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "on" || v === "yes";
+}
+function ledgerRecordQuarantinedEvent(event, reason) {
+  try {
+    const finalSummary = readMeshCompletionSummary(event.metadataEvent || {});
+    appendLedgerEntry(event.meshId, {
+      kind: "event_held",
+      ...event.nodeId ? { nodeId: event.nodeId } : {},
+      payload: {
+        event: event.event,
+        reason,
+        recoverable: true,
+        nodeLabel: event.nodeLabel,
+        ...event.workspace ? { workspace: event.workspace } : {},
+        targetCoordinatorDaemonId: event.targetCoordinatorDaemonId ?? null,
+        ...readNonEmptyString2(event.eventId) ? { eventId: event.eventId } : {},
+        queuedAt: event.queuedAt,
+        ...finalSummary ? { finalSummary } : {}
+      }
+    });
+  } catch (e) {
+    LOG.warn("MeshEventsV2", `Failed to ledger-record v2-quarantined ${event.event} for mesh ${event.meshId}: ${e?.message || e}`);
+  }
+}
+function getMeshV2DrainCounters() {
+  return { ...meshV2DrainCounters };
+}
 function warnV2Once(key2, message) {
   if (warnedV2Violations.has(key2)) return;
   warnedV2Violations.add(key2);
@@ -11510,12 +11541,22 @@ function identityDeliversTo(intendedFor, drainer) {
 }
 function routeV2EventsForDrainer(events, drainer, ctx) {
   if (!drainer) return events;
+  const enforce = isMeshProtocolV2EnforceEnabled();
   const bump = (k) => {
     if (ctx.countMetrics) meshV2DrainCounters[k]++;
   };
   const kept = [];
   for (const event of events) {
     if (!isV2Event(event)) {
+      if (enforce) {
+        bump("v1UnversionedQuarantined");
+        if (ctx.countMetrics) ledgerRecordQuarantinedEvent(event, "v2_enforce_unversioned_quarantined");
+        warnV2Once(
+          `${event.meshId}::${event.eventId ?? event.event}::v1-quarantined`,
+          `v2 ENFORCE: unversioned ${event.event} on mesh ${event.meshId} QUARANTINED (no v2 envelope \u2014 held back, not delivered; ledger-recorded recoverable). A producer path still emits v1.`
+        );
+        continue;
+      }
       bump("v1BroadcastAccepted");
       kept.push(event);
       continue;
@@ -11524,6 +11565,15 @@ function routeV2EventsForDrainer(events, drainer, ctx) {
     try {
       validated = assertPendingMeshCoordinatorEventV2(event);
     } catch (e) {
+      if (enforce) {
+        bump("v2ValidationFailedQuarantined");
+        if (ctx.countMetrics) ledgerRecordQuarantinedEvent(event, "v2_enforce_validation_failed_quarantined");
+        warnV2Once(
+          `${event.meshId}::${event.eventId ?? event.event}::invalid-quarantined`,
+          `v2 ENFORCE: envelope validation failed for ${event.event} on mesh ${event.meshId} \u2014 QUARANTINED (held back, not delivered; ledger-recorded recoverable): ${e?.message || e}`
+        );
+        continue;
+      }
       bump("v2ValidationFailedAccepted");
       warnV2Once(
         `${event.meshId}::${event.eventId ?? event.event}::invalid`,
@@ -12108,7 +12158,15 @@ var init_mesh_events_pending = __esm({
        *  coordinatorRunId change orphaned them). */
       v2ReattributedToDrainer: 0,
       /** v1 (unversioned) events passed through as broadcast (rollout baseline). */
-      v1BroadcastAccepted: 0
+      v1BroadcastAccepted: 0,
+      /** T6 enforce: v2 events that FAILED validation and were QUARANTINED (held back
+       *  from delivery, not dropped). Non-zero here means a producer is still emitting a
+       *  malformed envelope after enforce was turned on. */
+      v2ValidationFailedQuarantined: 0,
+      /** T6 enforce: v1 (unversioned) events QUARANTINED because no v2 envelope could be
+       *  derived at emit time. Non-zero here means a producer path still emits v1 after
+       *  enforce — it should reach 0 once every node is on a v2-stamping build. */
+      v1UnversionedQuarantined: 0
     };
     warnedV2Violations = /* @__PURE__ */ new Set();
     TERMINAL_COMPLETION_EVENTS = /* @__PURE__ */ new Set(["agent:generating_completed", "agent:stopped"]);
@@ -18312,6 +18370,21 @@ function resolveAckedDeathDeadlineMs() {
 function resolveAckedTranscriptFastTrackGraceMs() {
   return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_TRANSCRIPT_FASTTRACK_GRACE_MS", 4e4, 0, 5 * 6e4);
 }
+function getMeshV2BackstopCounters() {
+  return { ...meshV2BackstopCounters };
+}
+function meshProtocolV2EnforceOn() {
+  const raw = process.env.MESH_PROTOCOL_V2_ENFORCE;
+  if (typeof raw !== "string") return false;
+  const v = raw.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "on" || v === "yes";
+}
+function recordBackstopFire(kind, detail) {
+  meshV2BackstopCounters[kind]++;
+  if (meshProtocolV2EnforceOn()) {
+    LOG.warn("MeshReconcileV2", `v2 ENFORCE last-resort backstop fired (${kind}): ${detail}. Under a healthy v2 completion contract this should be 0 \u2014 a worker's real terminal emit was lost/late.`);
+  }
+}
 function inFlightSynthKey(meshId, taskId) {
   return `${meshId}::${taskId}`;
 }
@@ -19226,6 +19299,7 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
     };
     const synthKey = inFlightSynthKey(mesh.id, taskId);
     const isAcked = dispatch.status === "acked";
+    let backstopKind;
     let payload = null;
     let readFailed = false;
     try {
@@ -19290,6 +19364,7 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
         const idleHeldMs = nowMs - idleSinceMs;
         if (idleHeldMs >= fastTrackGraceMs) {
           fastTrackReady = true;
+          backstopKind = "ackedHoldFastTrackFired";
           LOG.info("MeshReconcile", `Acked-hold transcript fast-track: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read idle WITH a final assistant message for ${Math.round(idleHeldMs / 1e3)}s continuous (grace ${Math.round(fastTrackGraceMs / 1e3)}s) \u2014 promoting the synth ahead of the ${Math.round(deathDeadlineMs / 1e3)}s death backstop; the worker's real emit was lost/late and a later one no-ops idempotently.`);
         }
       } else if (holdState?.transcriptIdleSinceMs !== void 0) {
@@ -19300,6 +19375,7 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
         continue;
       }
       if (!fastTrackReady) {
+        backstopKind = "ackedHoldDeathDeadlineFired";
         LOG.warn("MeshReconcile", `Acked-hold death deadline reached: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) still idle ${Math.round(sinceAckMs / 1e3)}s after the ack (deadline ${Math.round(deathDeadlineMs / 1e3)}s) \u2014 synthesizing the missing completion as a notification-loss net (a real emit, if it ever lands, no-ops idempotently).`);
       }
     }
@@ -19344,6 +19420,7 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
         source: "daemon_reconcile_transcript_completion"
       });
       if (result.reconciled) {
+        recordBackstopFire(backstopKind ?? "phase4SynthesisFired", `task ${taskId} on node ${nodeId} (mesh ${mesh.id}), kind=${result.kind}`);
         LOG.info("MeshReconcile", `Synthesized missing completion (${result.kind}) for task ${taskId} on node ${nodeId} (mesh ${mesh.id})`);
       }
     } catch (e) {
@@ -19473,7 +19550,7 @@ function setupMeshReconcileLoop(components) {
     }
   };
 }
-var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS, ACKED_DEATH_CONSECUTIVE_READ_FAILURES, inFlightAckedHoldState, rehydratedHoldMeshes, coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, RECLAIM_UNKNOWN_GRACE_TICKS, deliveredNoTurnUnknownStreak, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
+var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS, ACKED_DEATH_CONSECUTIVE_READ_FAILURES, inFlightAckedHoldState, rehydratedHoldMeshes, meshV2BackstopCounters, coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, RECLAIM_UNKNOWN_GRACE_TICKS, deliveredNoTurnUnknownStreak, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
 var init_mesh_reconcile_loop = __esm({
   "src/mesh/mesh-reconcile-loop.ts"() {
     "use strict";
@@ -19501,6 +19578,14 @@ var init_mesh_reconcile_loop = __esm({
     ACKED_DEATH_CONSECUTIVE_READ_FAILURES = 3;
     inFlightAckedHoldState = /* @__PURE__ */ new Map();
     rehydratedHoldMeshes = /* @__PURE__ */ new Set();
+    meshV2BackstopCounters = {
+      /** PHASE-4 transcript synthesis actually reconciled a missing completion. */
+      phase4SynthesisFired: 0,
+      /** Acked-hold transcript fast-track promoted a synth ahead of the death deadline. */
+      ackedHoldFastTrackFired: 0,
+      /** Acked-hold death-deadline backstop released a held synth (the 8-min net). */
+      ackedHoldDeathDeadlineFired: 0
+    };
     coordinatorModalParkState = /* @__PURE__ */ new Map();
     heldEventLedgerRecorded = /* @__PURE__ */ new Set();
     ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
@@ -19520,9 +19605,12 @@ __export(mesh_events_exports, {
   __resetMeshWorkspaceCacheForTests: () => __resetMeshWorkspaceCacheForTests,
   clearPendingMeshCoordinatorEvents: () => clearPendingMeshCoordinatorEvents,
   drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
+  getMeshV2BackstopCounters: () => getMeshV2BackstopCounters,
+  getMeshV2DrainCounters: () => getMeshV2DrainCounters,
   getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
   handleMeshForwardEvent: () => handleMeshForwardEvent,
   isMeshCoordinatorEvent: () => isMeshCoordinatorEvent,
+  isMeshProtocolV2EnforceEnabled: () => isMeshProtocolV2EnforceEnabled,
   isSessionActivelyGenerating: () => isSessionActivelyGenerating,
   queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
   readV2EnvelopeFromWire: () => readV2EnvelopeFromWire,
@@ -40601,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;
@@ -40666,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;
@@ -43290,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;
@@ -43310,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") {
@@ -43835,10 +43973,10 @@ var CliProviderInstance = class _CliProviderInstance {
     if (buttonIndex < 0 || !hasReliableConsentAnchor) {
       return autoApproveActive;
     }
+    const affirmativeAnchor = normalizeApprovalLabel(buttonLabel);
     const modalSignature = [
       typeof modal?.message === "string" ? modal.message.trim() : "",
-      buttons.join("|"),
-      buttonIndex
+      affirmativeAnchor
     ].join("::");
     const approvalEntrySeq = typeof adapterStatus?.approvalEntrySeq === "number" ? adapterStatus.approvalEntrySeq : 0;
     const busySignature = `${approvalEntrySeq}::${modalSignature}`;
@@ -48882,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);
@@ -53445,7 +53613,12 @@ var meshEventsHandlers = {
       return { success: true, events: [], heldForBusyLocalCoordinator: true, hasLiveCliCoordinator };
     }
     const events = drainPendingMeshCoordinatorEvents(meshId || void 0, coordinatorDaemonId);
-    return { success: true, events, hasLiveCliCoordinator, ...selfCoordinatorInboxRead ? { surfacedForSelfCoordinator: true } : {} };
+    const meshProtocolV2Counters = {
+      enforce: isMeshProtocolV2EnforceEnabled(),
+      drain: { ...getMeshV2DrainCounters() },
+      backstop: { ...getMeshV2BackstopCounters() }
+    };
+    return { success: true, events, hasLiveCliCoordinator, meshProtocolV2Counters, ...selfCoordinatorInboxRead ? { surfacedForSelfCoordinator: true } : {} };
   },
   interactive_prompt_response: async (ctx, args) => {
     const sessionId = typeof args?.targetSessionId === "string" && args.targetSessionId.trim() ? args.targetSessionId.trim() : typeof args?.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : "";
@@ -54471,6 +54644,11 @@ var meshStatusHandlers = {
       const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : ctx.deps.statusInstanceId || void 0;
       const pendingCoordinatorEvents = getPendingMeshCoordinatorEvents(meshId, callerCoordinatorDaemonId);
       const unroutableDeliveries = getRecentUnroutableDeliveries();
+      const meshProtocolV2Counters = {
+        enforce: isMeshProtocolV2EnforceEnabled(),
+        drain: { ...getMeshV2DrainCounters() },
+        backstop: { ...getMeshV2BackstopCounters() }
+      };
       const previewFreshness = (() => {
         const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs27.existsSync(candidate));
         return localRepoRoot ? buildPreviewFreshness(localRepoRoot) : void 0;
@@ -54560,6 +54738,7 @@ var meshStatusHandlers = {
         ...historicalSessions ? { historicalSessions } : {},
         ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {},
         ...unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {},
+        meshProtocolV2Counters,
         activeRefineJobs: Array.from(ctx.runningRefineJobs.values()).filter((job) => job.meshId === meshId).map((job) => ({
           jobId: job.jobId,
           nodeId: job.targetNodeId,
@@ -54569,12 +54748,13 @@ var meshStatusHandlers = {
           targetCoordinatorDaemonId: job.targetCoordinatorDaemonId
         }))
       };
-      const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, ...cacheableStatusResult } = statusResult;
+      const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, meshProtocolV2Counters: _meshProtocolV2Counters, ...cacheableStatusResult } = statusResult;
       const rememberedStatus = verboseMissions ? cacheableStatusResult : ctx.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
       const returnedStatus = {
         ...rememberedStatus,
         ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {},
-        ...unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {}
+        ...unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {},
+        meshProtocolV2Counters
       };
       logRepoMeshStatusDebug("return_live", {
         meshId,
@@ -54817,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
@@ -59211,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"));
@@ -59379,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
@@ -59401,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 = [];
@@ -59540,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") {