@adhdev/daemon-standalone 0.9.82-rc.371 → 0.9.82-rc.374

package/dist/index.js

@@ -30036,10 +30036,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "0e66043bc2858f114fbdd7b1edeb7774f33bfd2d" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "0e66043b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.371" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-24T12:30:40.845Z" : void 0);
+      const commit = readInjected(true ? "47e042dcb10c9ca07c30ac4bf8e0d5a4153a63c6" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "47e042dc" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.374" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-25T00:33:32.738Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -35318,7 +35318,14 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
                 if (candidate.taskMode === "live_debug_readonly") return true;
                 return !nodeBusy;
               };
-              const entry = candidates.find((candidate) => nodeSatisfiesRequiredTags(candidate.requiredTags, capabilityTags) && dependenciesSatisfied(candidate) && nodeConflictAllows(candidate));
+              const nodeIsWorktree = opts?.nodeIsWorktree === true;
+              const convergenceAllows = (candidate) => candidate.taskMode !== "convergence" || !nodeIsWorktree;
+              const targetMatches = (candidate) => {
+                if (candidate.targetSessionId && candidate.targetSessionId !== sessionId) return false;
+                if (candidate.targetNodeId && candidate.targetNodeId !== nodeId) return false;
+                return true;
+              };
+              const entry = candidates.find((candidate) => nodeSatisfiesRequiredTags(candidate.requiredTags, capabilityTags) && dependenciesSatisfied(candidate) && convergenceAllows(candidate) && targetMatches(candidate) && nodeConflictAllows(candidate));
               if (!entry) return null;
               const now = (/* @__PURE__ */ new Date()).toISOString();
               entry.status = "assigned";
@@ -38520,7 +38527,7 @@ Next step: ${nextStep}`;
       "src/mesh/mesh-events-utils.ts"() {
         "use strict";
         MESH_SURFACED_PREVIEW_MAX_CHARS = 512;
-        MESH_COMPLETION_SURFACE_MAX_CHARS = 4e3;
+        MESH_COMPLETION_SURFACE_MAX_CHARS = 16e3;
       }
     });
     function normalizeCoordinatorDaemonIds(coordinatorDaemonId) {
@@ -39163,6 +39170,22 @@ Next step: ${nextStep}`;
       const diag = readRecord4(payload.completionDiagnostic);
       return diag?.finalAssistantPresent === false || diag?.blockReason === "missing_final_assistant";
     }
+    function findTerminalLedgerEvidenceForTask(args) {
+      const taskId = readNonEmptyString2(args.taskId);
+      if (!taskId) return null;
+      const entries = readLedgerEntries(args.meshId, { tail: args.tail ?? 500 });
+      for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.kind !== "task_completed" && entry.kind !== "task_failed" && entry.kind !== "task_stalled") continue;
+        const terminalTaskId = readNonEmptyString2(entry.payload?.taskId);
+        if (terminalTaskId !== taskId) continue;
+        if (entry.kind === "task_completed" && isWeakCompletionLedgerPayload(entry.payload)) continue;
+        if (args.sessionId && entry.sessionId && entry.sessionId !== args.sessionId) continue;
+        if (!args.sessionId && args.nodeId && entry.nodeId && !meshNodeIdMatches(entry, args.nodeId)) continue;
+        return { id: entry.id, kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
+      }
+      return null;
+    }
     function findDirectDispatchLedgerEntry(args) {
       const entries = readLedgerEntries(args.meshId, { tail: 500 });
       for (let i = entries.length - 1; i >= 0; i--) {
@@ -41301,7 +41324,7 @@ Next step: ${nextStep}`;
       "src/providers/chat-message-normalization.ts"() {
         "use strict";
         init_contracts();
-        DEFAULT_FINAL_SUMMARY_MAX_CHARS = 4e3;
+        DEFAULT_FINAL_SUMMARY_MAX_CHARS = 16e3;
         BUILTIN_CHAT_MESSAGE_KINDS = ["standard", "thought", "tool", "terminal", "system"];
         CHAT_MESSAGE_VISIBILITIES = ["user", "debug", "internal", "hidden"];
         CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES = ["visible", "chat", "user", "debug", "internal", "hidden"];
@@ -42530,6 +42553,31 @@ ${cleanBody}`;
       }
       return "";
     }
+    function resolveForwardEventMeshId(components, payload) {
+      const direct = readNonEmptyString2(payload.meshId);
+      if (direct) return direct;
+      const workspace = readNonEmptyString2(payload.workspace);
+      const byWorkspace = workspace ? readNonEmptyString2(getCachedMeshByWorkspace(workspace)?.id) : "";
+      if (byWorkspace) return byWorkspace;
+      const byNode = recoverMeshIdByNodeId(readNonEmptyString2(payload.nodeId));
+      if (byNode) return byNode;
+      const sessionId = readNonEmptyString2(payload.targetSessionId) || readNonEmptyString2(payload.sessionId) || readNonEmptyString2(payload.instanceId);
+      if (sessionId) {
+        try {
+          const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
+          const settings = state?.settings || {};
+          const meshNodeFor = readNonEmptyString2(settings.meshNodeFor);
+          if (meshNodeFor) return meshNodeFor;
+          const byStamp = recoverMeshIdByNodeId(readNonEmptyString2(settings.meshNodeId));
+          if (byStamp) return byStamp;
+          const sessionWorkspace = readNonEmptyString2(state?.workspace);
+          const bySessionWorkspace = sessionWorkspace ? readNonEmptyString2(getCachedMeshByWorkspace(sessionWorkspace)?.id) : "";
+          if (bySessionWorkspace) return bySessionWorkspace;
+        } catch {
+        }
+      }
+      return "";
+    }
     function __resetIdleAutoFastForwardForTests() {
       idleAutoFastForwardLastAttempt.clear();
     }
@@ -42776,13 +42824,32 @@ ${cleanBody}`;
       }
       const capabilityTags = buildMeshNodeCapabilityTags(node, providerType);
       const providerMaxParallel = resolveProviderMaxParallel(node?.policy, providerType);
+      const nodeIsWorktree = node?.isLocalWorktree === true;
       const task = claimNextTask(meshId, nodeId, sessionId, capabilityTags, {
         providerType,
-        ...providerMaxParallel !== void 0 ? { providerMaxParallel } : {}
+        ...providerMaxParallel !== void 0 ? { providerMaxParallel } : {},
+        nodeIsWorktree
       });
       if (!task) {
         return false;
       }
+      const terminal = findTerminalLedgerEvidenceForTask({
+        meshId,
+        taskId: task.id
+      });
+      if (terminal) {
+        const status = terminal.kind === "task_completed" ? "completed" : "failed";
+        updateTaskStatus(meshId, task.id, status);
+        LOG2.info("MeshQueue", `Skipped dispatch for terminal task ${task.id} on mesh ${meshId}; ${terminal.kind} ledger evidence already exists`);
+        traceMeshEventDrop("dispatch_terminal_ledger", {
+          taskId: task.id,
+          sessionId,
+          nodeId,
+          meshId,
+          event: "agent_command"
+        }, terminal.kind);
+        return false;
+      }
       LOG2.info("MeshQueue", `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
       if (node?.daemonId && components.dispatchMeshCommand) {
         const isLocalNode = components.cliManager.adapters.has(sessionId);
@@ -43122,6 +43189,7 @@ ${cleanBody}`;
         }
         const candidateNodes = Array.isArray(mesh?.nodes) ? mesh.nodes.filter((node) => {
           if (task.targetNodeId && !meshNodeIdMatches(node, task.targetNodeId)) return false;
+          if (task.taskMode === "convergence" && node?.isLocalWorktree === true) return false;
           if (task.requiredTags?.length) {
             const priorities = normalizeProviderPriority(node?.policy);
             const providerCandidates = priorities.length ? priorities : [void 0];
@@ -44105,6 +44173,8 @@ ${cleanBody}`;
         nodeId: readNonEmptyString2(routing.nodeId) || readNonEmptyString2(event.meshNodeId) || void 0,
         workspace: readNonEmptyString2(routing.workspace) || readNonEmptyString2(event.workspace) || void 0
       };
+      const resolvedMeshId = resolveForwardEventMeshId(components, payload);
+      if (resolvedMeshId) payload.meshId = resolvedMeshId;
       const selfDaemonIds = resolveCoordinatorDrainDaemonIds(components);
       if (selfDaemonIds.some((self) => daemonIdsEquivalent(self, coordinatorDaemonId))) {
         try {
@@ -44335,20 +44405,24 @@ ${cleanBody}`;
       if (host.role && host.role !== "host") return false;
       const hostDaemonId = readNonEmptyString2(host.hostDaemonId);
       if (!hostDaemonId) return true;
-      return daemonIds.includes(hostDaemonId);
+      return daemonIdListIncludes(daemonIds, hostDaemonId);
+    }
+    function daemonIdListIncludes(ids, id) {
+      if (!id) return false;
+      return ids.some((candidate) => candidate === id || daemonIdsEquivalent(candidate, id));
     }
     function resolveCoordinatorSelfIds(mesh, drainDaemonIds) {
       const ids = new Set(drainDaemonIds);
       for (const node of mesh.nodes) {
         const nodeDaemonId = readNonEmptyString2(node.daemonId);
         const nodeMachineId = readNonEmptyString2(node.machineId);
-        const isSelf = nodeDaemonId && drainDaemonIds.includes(nodeDaemonId) || nodeMachineId && drainDaemonIds.includes(nodeMachineId);
+        const isSelf = nodeDaemonId && daemonIdListIncludes(drainDaemonIds, nodeDaemonId) || nodeMachineId && daemonIdListIncludes(drainDaemonIds, nodeMachineId);
         if (!isSelf) continue;
         if (nodeDaemonId) ids.add(nodeDaemonId);
         if (nodeMachineId) ids.add(nodeMachineId);
       }
       const hostDaemonId = readNonEmptyString2(mesh.meshHost?.hostDaemonId);
-      if (hostDaemonId && ids.has(hostDaemonId)) ids.add(hostDaemonId);
+      if (hostDaemonId && daemonIdListIncludes([...ids], hostDaemonId)) ids.add(hostDaemonId);
       return [...ids];
     }
     function findLiveCoordinators(components) {
@@ -44426,6 +44500,23 @@ ${cleanBody}`;
         const dispatchedAtMs = Date.parse(row.dispatchTimestamp ?? "");
         if (!Number.isFinite(dispatchedAtMs)) continue;
         if (nowMs - dispatchedAtMs < ASSIGNED_STRANDED_DEADLINE_MS) continue;
+        const terminal = findTerminalLedgerEvidenceForTask({
+          meshId,
+          taskId: row.id
+        });
+        if (terminal) {
+          const status = terminal.kind === "task_completed" ? "completed" : "failed";
+          updateTaskStatus(meshId, row.id, status);
+          LOG2.warn("MeshReconcile", `Skipped stranded reclaim redispatch for terminal task ${row.id} on mesh ${meshId}; ${terminal.kind} ledger evidence already exists`);
+          traceMeshEventDrop("assigned_stranded_terminal_ledger", {
+            taskId: row.id,
+            sessionId: row.assignedSessionId,
+            nodeId: row.assignedNodeId,
+            meshId,
+            event: "agent:generating_completed"
+          }, terminal.kind);
+          continue;
+        }
         if (store.taskHasConfirmedDelivery(meshId, row.id)) continue;
         const reclaimed = reclaimStrandedAssignedTask(meshId, row.id, {
           reason: "assigned_stranded_dispatch_unconfirmed",
@@ -44645,7 +44736,10 @@ ${cleanBody}`;
       if (!dispatchMeshCommand) return;
       expireStaleUnresolvedDelegateForwards();
       const entries = peekUnresolvedDelegateForwards();
-      if (entries.length === 0) return;
+      if (entries.length === 0) {
+        if (unresolvedForwardRejectionCounts.size > 0) unresolvedForwardRejectionCounts.clear();
+        return;
+      }
       const selfIds = resolveCoordinatorDaemonIds(components);
       const isSelfCoordinatorId = (id) => selfIds.some((self) => daemonIdsEquivalent(self, id));
       for (const entry of entries) {
@@ -44664,6 +44758,7 @@ ${cleanBody}`;
             LOG2.warn("MeshReconcile", `Local route of self-addressed forward to ${entry.coordinatorDaemonId} threw: ${e?.message || e} \u2014 draining anyway to break the retry loop`);
           }
           ackUnresolvedDelegateForward(entry.id);
+          unresolvedForwardRejectionCounts.delete(entry.id);
           if (localResult && localResult.success === false) {
             LOG2.warn("MeshReconcile", `Self-addressed unresolved-delegate ${readNonEmptyString2(entry.payload.event)} rejected by local router (${readNonEmptyString2(localResult.error) || "no reason"}) \u2014 drained to break the self-forward retry loop`);
             traceMeshEventDrop("self_forward_local_rejected", entryTraceCtx, readNonEmptyString2(localResult.error) || "no reason");
@@ -44672,21 +44767,40 @@ ${cleanBody}`;
           }
           continue;
         }
+        let pushPayload = entry.payload;
+        if (!readNonEmptyString2(pushPayload.meshId)) {
+          const recoveredMeshId = resolveForwardEventMeshId(components, pushPayload);
+          if (recoveredMeshId) {
+            pushPayload = { ...pushPayload, meshId: recoveredMeshId };
+            traceMeshEventStage("forward_meshid_recovered", entryTraceCtx, `meshId=${recoveredMeshId}`);
+          }
+        }
         let result;
         try {
           traceMeshEventStage("forward_send", entryTraceCtx, `retry \u2192 ${entry.coordinatorDaemonId}`);
-          result = await dispatchMeshCommand(entry.coordinatorDaemonId, "mesh_forward_event", entry.payload);
+          result = await dispatchMeshCommand(entry.coordinatorDaemonId, "mesh_forward_event", pushPayload);
         } catch (e) {
           LOG2.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued`);
           traceMeshEventDrop("retry_forward_failed", entryTraceCtx, e?.message || String(e));
           continue;
         }
         if (result && result.success === false) {
-          LOG2.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected (${readNonEmptyString2(result.error) || "no reason"}) \u2014 left queued`);
-          traceMeshEventDrop("retry_forward_rejected", entryTraceCtx, readNonEmptyString2(result.error) || "no reason");
+          const rejections = (unresolvedForwardRejectionCounts.get(entry.id) || 0) + 1;
+          unresolvedForwardRejectionCounts.set(entry.id, rejections);
+          const reason = readNonEmptyString2(result.error) || "no reason";
+          if (rejections >= MAX_FORWARD_REJECTIONS) {
+            ackUnresolvedDelegateForward(entry.id);
+            unresolvedForwardRejectionCounts.delete(entry.id);
+            LOG2.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected ${rejections}x (${reason}) \u2014 dropping unresolved-delegate ${readNonEmptyString2(entry.payload.event)} (sess=${readNonEmptyString2(entry.payload.targetSessionId) || readNonEmptyString2(entry.payload.sessionId) || "-"}) to stop the retry loop`);
+            traceMeshEventDrop("retry_forward_exhausted", entryTraceCtx, `${reason} (${rejections} rejections)`);
+          } else {
+            LOG2.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected (${reason}) \u2014 left queued (attempt ${rejections}/${MAX_FORWARD_REJECTIONS})`);
+            traceMeshEventDrop("retry_forward_rejected", entryTraceCtx, reason);
+          }
           continue;
         }
         ackUnresolvedDelegateForward(entry.id);
+        unresolvedForwardRejectionCounts.delete(entry.id);
         LOG2.info("MeshReconcile", `Retried+delivered unresolved-delegate ${readNonEmptyString2(entry.payload.event)} to coordinator ${entry.coordinatorDaemonId}`);
       }
     }
@@ -44699,7 +44813,7 @@ ${cleanBody}`;
         const nodeDaemonId = readNonEmptyString2(node.daemonId);
         if (!nodeDaemonId) continue;
         if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) continue;
-        if (candidateDaemonIds.includes(nodeDaemonId)) continue;
+        if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) continue;
         for (const pendingEventArgs of pulls) {
           let events;
           try {
@@ -44755,7 +44869,7 @@ ${cleanBody}`;
         if (!sessionId || !nodeId || !taskId) continue;
         const node = nodeById.get(nodeId);
         const nodeDaemonId = readNonEmptyString2(node?.daemonId);
-        const isLocalNode = !nodeDaemonId || selfIds.includes(nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId) || !!components.instanceManager.getInstance(sessionId);
+        const isLocalNode = !nodeDaemonId || daemonIdListIncludes(selfIds, nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId) || !!components.instanceManager.getInstance(sessionId);
         const providerType = readNonEmptyString2(dispatch.providerType);
         const readArgs = {
           sessionId,
@@ -44830,7 +44944,7 @@ ${cleanBody}`;
       const dispatchMeshCommand = components.dispatchMeshCommand;
       return Promise.all(mesh.nodes.map(async (node) => {
         const nodeDaemonId = readNonEmptyString2(node.daemonId);
-        const isLocalNode = !nodeDaemonId || selfIds.includes(nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId);
+        const isLocalNode = !nodeDaemonId || daemonIdListIncludes(selfIds, nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId);
         let statusResult;
         try {
           if (isLocalNode) {
@@ -44917,6 +45031,8 @@ ${cleanBody}`;
     var heldEventLedgerRecorded;
     var ASSIGNED_STRANDED_DEADLINE_MS;
     var STRICT_SESSION_MATCH_TTL_MS;
+    var unresolvedForwardRejectionCounts;
+    var MAX_FORWARD_REJECTIONS;
     var init_mesh_reconcile_loop = __esm2({
       "src/mesh/mesh-reconcile-loop.ts"() {
         "use strict";
@@ -44941,6 +45057,8 @@ ${cleanBody}`;
         heldEventLedgerRecorded = /* @__PURE__ */ new Set();
         ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
         STRICT_SESSION_MATCH_TTL_MS = 6e4;
+        unresolvedForwardRejectionCounts = /* @__PURE__ */ new Map();
+        MAX_FORWARD_REJECTIONS = 5;
       }
     });
     var mesh_events_exports = {};
@@ -50566,6 +50684,7 @@ ${lastSnapshot}`;
       buildMeshLedgerReplicaEvidence: () => buildMeshLedgerReplicaEvidence,
       buildMeshNodeCapabilityTags: () => buildMeshNodeCapabilityTags,
       buildMeshNodeDataFreshness: () => buildMeshNodeDataFreshness,
+      buildMeshNodeProbeFreshness: () => buildMeshNodeProbeFreshness,
       buildMissionPromptSection: () => buildMissionPromptSection,
       buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
       buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
@@ -64418,6 +64537,27 @@ ${body}
         fs13.closeSync(fd);
       }
     }
+    function splitLogLines(text) {
+      const lines = text.split("\n");
+      if (lines.length && lines[lines.length - 1] === "") lines.pop();
+      return lines;
+    }
+    function takeLastLinesWithinBytes(lines, limitBytes) {
+      if (lines.length === 0) return { kept: [], truncated: false, bytesReturned: 0 };
+      let total = 0;
+      let firstKept = lines.length;
+      for (let i = lines.length - 1; i >= 0; i--) {
+        const lineBytes = Buffer.byteLength(lines[i], "utf-8") + 1;
+        if (firstKept !== lines.length && total + lineBytes > limitBytes) break;
+        total += lineBytes;
+        firstKept = i;
+      }
+      return {
+        kept: lines.slice(firstKept),
+        truncated: firstKept > 0,
+        bytesReturned: total
+      };
+    }
     function parseLineEpochMs(line, fileDate) {
       const m = line.match(/^\[(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?\]/);
       if (!m) {
@@ -64432,47 +64572,97 @@ ${body}
       d.setHours(Number(m[1]), Number(m[2]), Number(m[3]), m[4] ? Number(m[4].padEnd(3, "0")) : 0);
       return d.getTime();
     }
+    function buildGrepPredicate(grepSource) {
+      let re = null;
+      try {
+        re = new RegExp(grepSource, "i");
+      } catch {
+        re = null;
+      }
+      if (re) {
+        const compiled = re;
+        return (line) => compiled.test(line);
+      }
+      const needle = grepSource.toLowerCase();
+      return (line) => line.toLowerCase().includes(needle);
+    }
+    function fileDateFor(date5) {
+      if (date5 instanceof Date) return date5;
+      if (typeof date5 === "string" && date5.trim()) return /* @__PURE__ */ new Date(`${date5.trim()}T00:00:00.000Z`);
+      return /* @__PURE__ */ new Date();
+    }
+    function errorResult(error48, logPath, platform10) {
+      return {
+        success: false,
+        error: error48,
+        lines: [],
+        truncated: false,
+        logPath,
+        platform: platform10,
+        bytesReturned: 0,
+        filtered: false,
+        fullScan: false,
+        scannedBytes: 0,
+        matchedLineCount: 0,
+        excludedByFilter: 0
+      };
+    }
     function readDaemonLogTail(args = {}) {
       const platform10 = process.platform;
       const limitBytes = clampTailBytes(args.tailBytes);
-      let logPath = resolveLogPath(args.date);
-      if (!fs13.existsSync(logPath)) {
-        const backup = logPath.replace(/\.log$/, ".1.log");
-        if (fs13.existsSync(backup)) {
-          logPath = backup;
-        } else {
-          return {
-            success: false,
-            error: `No daemon log file at ${logPath} (dir: ${getDaemonLogDir()})`,
-            lines: [],
-            truncated: false,
-            logPath,
-            platform: platform10,
-            bytesReturned: 0,
-            filtered: false
-          };
-        }
+      const primaryPath = resolveLogPath(args.date);
+      const backupPath = primaryPath.replace(/\.log$/, ".1.log");
+      const primaryExists = fs13.existsSync(primaryPath);
+      const backupExists = fs13.existsSync(backupPath);
+      if (!primaryExists && !backupExists) {
+        return errorResult(
+          `No daemon log file at ${primaryPath} (dir: ${getDaemonLogDir()})`,
+          primaryPath,
+          platform10
+        );
       }
-      let raw;
-      try {
-        raw = readByteBoundedTail(logPath, limitBytes);
-      } catch (e) {
+      const logPath = primaryExists ? primaryPath : backupPath;
+      const hasGrep = typeof args.grep === "string" && args.grep.trim().length > 0;
+      const hasSince = Number.isFinite(args.sinceMs);
+      const filterMode = hasGrep || hasSince;
+      if (!filterMode) {
+        let raw;
+        try {
+          raw = readByteBoundedTail(logPath, limitBytes);
+        } catch (e) {
+          return errorResult(`Failed to read ${logPath}: ${e?.message ?? String(e)}`, logPath, platform10);
+        }
+        const lines2 = splitLogLines(raw.text);
         return {
-          success: false,
-          error: `Failed to read ${logPath}: ${e?.message ?? String(e)}`,
-          lines: [],
-          truncated: false,
+          success: true,
+          lines: lines2,
+          truncated: raw.truncated,
           logPath,
           platform: platform10,
-          bytesReturned: 0,
-          filtered: false
+          bytesReturned: raw.bytesReturned,
+          filtered: false,
+          fullScan: false,
+          scannedBytes: raw.bytesReturned,
+          matchedLineCount: lines2.length,
+          excludedByFilter: 0
         };
       }
-      let lines = raw.text.split("\n");
-      if (lines.length && lines[lines.length - 1] === "") lines.pop();
-      const rawCount = lines.length;
-      if (Number.isFinite(args.sinceMs)) {
-        const fileDate = args.date instanceof Date ? args.date : typeof args.date === "string" && args.date.trim() ? /* @__PURE__ */ new Date(`${args.date.trim()}T00:00:00.000Z`) : /* @__PURE__ */ new Date();
+      let scannedBytes = 0;
+      let allLines = [];
+      try {
+        for (const p of [backupExists ? backupPath : null, primaryExists ? primaryPath : null]) {
+          if (!p) continue;
+          const buf = fs13.readFileSync(p);
+          scannedBytes += buf.length;
+          allLines = allLines.concat(splitLogLines(buf.toString("utf-8")));
+        }
+      } catch (e) {
+        return errorResult(`Failed to read ${logPath}: ${e?.message ?? String(e)}`, logPath, platform10);
+      }
+      const scannedLineCount = allLines.length;
+      let lines = allLines;
+      if (hasSince) {
+        const fileDate = fileDateFor(args.date);
         const floor = args.sinceMs;
         lines = lines.filter((line) => {
           const ts2 = parseLineEpochMs(line, fileDate);
@@ -64480,30 +64670,26 @@ ${body}
         });
       }
       let appliedGrep;
-      if (typeof args.grep === "string" && args.grep.trim()) {
+      if (hasGrep) {
         appliedGrep = args.grep.trim();
-        let re = null;
-        try {
-          re = new RegExp(appliedGrep, "i");
-        } catch {
-          re = null;
-        }
-        if (re) {
-          const compiled = re;
-          lines = lines.filter((line) => compiled.test(line));
-        } else {
-          const needle = appliedGrep.toLowerCase();
-          lines = lines.filter((line) => line.toLowerCase().includes(needle));
-        }
+        const matches = buildGrepPredicate(appliedGrep);
+        lines = lines.filter(matches);
       }
+      const matchedLineCount = lines.length;
+      const excludedByFilter = scannedLineCount - matchedLineCount;
+      const capped = takeLastLinesWithinBytes(lines, limitBytes);
       return {
         success: true,
-        lines,
-        truncated: raw.truncated,
+        lines: capped.kept,
+        truncated: capped.truncated,
         logPath,
         platform: platform10,
-        bytesReturned: raw.bytesReturned,
-        filtered: lines.length !== rawCount,
+        bytesReturned: capped.bytesReturned,
+        filtered: excludedByFilter > 0,
+        fullScan: true,
+        scannedBytes,
+        matchedLineCount,
+        excludedByFilter,
         ...appliedGrep ? { grep: appliedGrep } : {}
       };
     }
@@ -64616,6 +64802,12 @@ ${body}
           truncated: tail.truncated,
           filtered: tail.filtered,
           bytesReturned: tail.bytesReturned,
+          // Transparency meta — lets the coordinator see that a full-file grep
+          // ran past the recent tail window, and how much was scanned/excluded.
+          fullScan: tail.fullScan,
+          scannedBytes: tail.scannedBytes,
+          matchedLineCount: tail.matchedLineCount,
+          excludedByFilter: tail.excludedByFilter,
           ...tail.grep ? { grep: tail.grep } : {}
         };
       }
@@ -71697,7 +71889,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           const adapter = this.adapters.get(ik);
           if (adapter) return { adapter, key: ik };
         }
-        if (opts?.dir) {
+        if (opts?.dir && !opts?.instanceKey) {
           for (const [k, a] of this.adapters) {
             if (a.cliType === agentType && a.workingDir === opts.dir) {
               return { adapter: a, key: k };
@@ -76309,7 +76501,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
                 return "";
               }
             })();
-            const isCoordinatorBaseNode = !!selfDaemonId && (nodeDaemonId === selfDaemonId || nodeMachineId === selfDaemonId) || !!selfMachineId && (nodeDaemonId === selfMachineId || nodeMachineId === selfMachineId);
+            const isCoordinatorBaseNode = !!selfDaemonId && (daemonIdsEquivalent(nodeDaemonId, selfDaemonId) || daemonIdsEquivalent(nodeMachineId, selfDaemonId)) || !!selfMachineId && (daemonIdsEquivalent(nodeDaemonId, selfMachineId) || daemonIdsEquivalent(nodeMachineId, selfMachineId));
             if (isCoordinatorBaseNode) {
               return {
                 success: false,
@@ -77640,7 +77832,7 @@ ${ptyResult.output.slice(-2e3)}`);
               workspace
             };
           }
-          const { existsSync: existsSync49, readFileSync: readFileSync39, writeFileSync: writeFileSync24, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
+          const { existsSync: existsSync49, readFileSync: readFileSync40, writeFileSync: writeFileSync24, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
           const { dirname: dirname17 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
           const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -77690,7 +77882,7 @@ ${ptyResult.output.slice(-2e3)}`);
           }
           if (hadExistingMcpConfig) {
             try {
-              const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync39(mcpConfigPath, "utf-8"), configFormat);
+              const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync40(mcpConfigPath, "utf-8"), configFormat);
               const existingCoordinatorConfig = hermesManualFallback ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig) : parsedExistingMcpConfig;
               existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
               copyFileSync4(mcpConfigPath, mcpConfigPath + ".backup");
@@ -79392,6 +79584,23 @@ ${ptyResult.output.slice(-2e3)}`);
         staleness
       };
     }
+    function buildMeshNodeProbeFreshness(args) {
+      const { git, liveTruthProbed, isSelfNode, daemonId, node, now } = args;
+      const status = {
+        git,
+        connection: { state: liveTruthProbed ? "connected" : "disconnected" }
+      };
+      if (liveTruthProbed) status[MESH_NODE_LIVE_TRUTH_MARKER] = true;
+      return buildMeshNodeDataFreshness({
+        status,
+        node,
+        isSelfNode,
+        daemonId,
+        liveTruthProbed,
+        directTruthUnavailable: !liveTruthProbed && !!daemonId,
+        now
+      });
+    }
     function finalizeMeshNodeStatus(args) {
       const { status, node, daemonId, isSelfNode, directTruthUnavailable } = args;
       if (!readStringValue(status.machineStatus)) {