adhdev 0.9.82-rc.23 → 0.9.82-rc.24

package/dist/cli/index.js

@@ -3810,6 +3810,36 @@ function getQueuePath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
   return (0, import_path4.join)(getLedgerDir(), `${safe}.queue.json`);
 }
+function getLockPath(meshId) {
+  const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return (0, import_path4.join)(getLedgerDir(), `${safe}.queue.lock`);
+}
+function withQueueLock(meshId, fn) {
+  const lockPath = getLockPath(meshId);
+  let fd = -1;
+  for (let i = 0; i < 10; i++) {
+    try {
+      fd = (0, import_fs4.openSync)(lockPath, "wx");
+      break;
+    } catch {
+      const deadline = Date.now() + 30;
+      while (Date.now() < deadline) {
+      }
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    if (fd !== -1) try {
+      (0, import_fs4.closeSync)(fd);
+    } catch {
+    }
+    try {
+      (0, import_fs4.unlinkSync)(lockPath);
+    } catch {
+    }
+  }
+}
 function readQueue(meshId) {
   const path42 = getQueuePath(meshId);
   if (!(0, import_fs4.existsSync)(path42)) return [];
@@ -3825,20 +3855,22 @@ function writeQueue(meshId, queue) {
   (0, import_fs4.writeFileSync)(path42, JSON.stringify(queue, null, 2), "utf-8");
 }
 function enqueueTask(meshId, message, opts) {
-  const queue = readQueue(meshId);
-  const entry = {
-    id: (0, import_crypto5.randomUUID)(),
-    meshId,
-    message,
-    status: "pending",
-    targetNodeId: opts?.targetNodeId,
-    targetSessionId: opts?.targetSessionId,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  queue.push(entry);
-  writeQueue(meshId, queue);
-  return entry;
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const entry = {
+      id: (0, import_crypto5.randomUUID)(),
+      meshId,
+      message,
+      status: "pending",
+      targetNodeId: opts?.targetNodeId,
+      targetSessionId: opts?.targetSessionId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    queue.push(entry);
+    writeQueue(meshId, queue);
+    return entry;
+  });
 }
 function getQueue(meshId, opts) {
   let queue = readQueue(meshId);
@@ -3849,100 +3881,109 @@ function getQueue(meshId, opts) {
   return queue;
 }
 function claimNextTask(meshId, nodeId, sessionId) {
-  const queue = readQueue(meshId);
-  const hasActiveAssignment = queue.some((q) => q.status === "assigned" && (q.assignedSessionId === sessionId || q.assignedNodeId === nodeId));
-  if (hasActiveAssignment) return null;
-  let targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetSessionId === sessionId);
-  if (targetIdx === -1) {
-    targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetNodeId === nodeId && !q.targetSessionId);
-  }
-  if (targetIdx === -1) {
-    targetIdx = queue.findIndex((q) => q.status === "pending" && !q.targetNodeId && !q.targetSessionId);
-  }
-  if (targetIdx === -1) return null;
-  const entry = queue[targetIdx];
-  entry.status = "assigned";
-  entry.assignedNodeId = nodeId;
-  entry.assignedSessionId = sessionId;
-  entry.dispatchTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-  entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeQueue(meshId, queue);
-  return entry;
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const hasActiveAssignment = queue.some((q) => q.status === "assigned" && (q.assignedSessionId === sessionId || q.assignedNodeId === nodeId));
+    if (hasActiveAssignment) return null;
+    let targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetSessionId === sessionId);
+    if (targetIdx === -1) {
+      targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetNodeId === nodeId && !q.targetSessionId);
+    }
+    if (targetIdx === -1) {
+      targetIdx = queue.findIndex((q) => q.status === "pending" && !q.targetNodeId && !q.targetSessionId);
+    }
+    if (targetIdx === -1) return null;
+    const entry = queue[targetIdx];
+    entry.status = "assigned";
+    entry.assignedNodeId = nodeId;
+    entry.assignedSessionId = sessionId;
+    entry.dispatchTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+    entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeQueue(meshId, queue);
+    return entry;
+  });
 }
 function updateTaskStatus(meshId, taskId, status) {
-  const queue = readQueue(meshId);
-  const idx = queue.findIndex((q) => q.id === taskId);
-  if (idx === -1) return null;
-  queue[idx].status = status;
-  queue[idx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeQueue(meshId, queue);
-  return queue[idx];
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex((q) => q.id === taskId);
+    if (idx === -1) return null;
+    queue[idx].status = status;
+    queue[idx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeQueue(meshId, queue);
+    return queue[idx];
+  });
 }
 function recordTaskAutoLaunch(meshId, taskId, autoLaunch) {
-  const queue = readQueue(meshId);
-  const idx = queue.findIndex((q) => q.id === taskId);
-  if (idx === -1) return null;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  queue[idx].autoLaunch = {
-    ...autoLaunch,
-    updatedAt: now
-  };
-  queue[idx].updatedAt = now;
-  writeQueue(meshId, queue);
-  return queue[idx];
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex((q) => q.id === taskId);
+    if (idx === -1) return null;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    queue[idx].autoLaunch = { ...autoLaunch, updatedAt: now };
+    queue[idx].updatedAt = now;
+    writeQueue(meshId, queue);
+    return queue[idx];
+  });
 }
 function cancelTask(meshId, taskId, opts) {
-  const queue = readQueue(meshId);
-  const idx = queue.findIndex((q) => q.id === taskId);
-  if (idx === -1) return null;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  queue[idx].status = "cancelled";
-  queue[idx].updatedAt = now;
-  queue[idx].cancelledAt = now;
-  if (opts?.reason) queue[idx].cancelReason = opts.reason;
-  writeQueue(meshId, queue);
-  return queue[idx];
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex((q) => q.id === taskId);
+    if (idx === -1) return null;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    queue[idx].status = "cancelled";
+    queue[idx].updatedAt = now;
+    queue[idx].cancelledAt = now;
+    if (opts?.reason) queue[idx].cancelReason = opts.reason;
+    writeQueue(meshId, queue);
+    return queue[idx];
+  });
 }
 function requeueTask(meshId, taskId, opts) {
-  const queue = readQueue(meshId);
-  const idx = queue.findIndex((q) => q.id === taskId);
-  if (idx === -1) return null;
-  const entry = queue[idx];
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  entry.status = "pending";
-  delete entry.assignedNodeId;
-  delete entry.assignedSessionId;
-  delete entry.cancelledAt;
-  delete entry.cancelReason;
-  if (opts?.clearTargetNode) delete entry.targetNodeId;
-  if (typeof opts?.targetNodeId === "string") entry.targetNodeId = opts.targetNodeId;
-  if (opts?.clearTargetSession !== false) delete entry.targetSessionId;
-  if (typeof opts?.targetSessionId === "string") entry.targetSessionId = opts.targetSessionId;
-  entry.updatedAt = now;
-  entry.requeuedAt = now;
-  entry.requeueCount = (entry.requeueCount || 0) + 1;
-  if (opts?.reason) entry.requeueReason = opts.reason;
-  writeQueue(meshId, queue);
-  return entry;
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex((q) => q.id === taskId);
+    if (idx === -1) return null;
+    const entry = queue[idx];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    entry.status = "pending";
+    delete entry.assignedNodeId;
+    delete entry.assignedSessionId;
+    delete entry.cancelledAt;
+    delete entry.cancelReason;
+    if (opts?.clearTargetNode) delete entry.targetNodeId;
+    if (typeof opts?.targetNodeId === "string") entry.targetNodeId = opts.targetNodeId;
+    if (opts?.clearTargetSession !== false) delete entry.targetSessionId;
+    if (typeof opts?.targetSessionId === "string") entry.targetSessionId = opts.targetSessionId;
+    entry.updatedAt = now;
+    entry.requeuedAt = now;
+    entry.requeueCount = (entry.requeueCount || 0) + 1;
+    if (opts?.reason) entry.requeueReason = opts.reason;
+    writeQueue(meshId, queue);
+    return entry;
+  });
 }
 function updateSessionTaskStatus(meshId, sessionId, status) {
-  const queue = readQueue(meshId);
-  let bestIdx = -1;
-  let bestTime = 0;
-  for (let i = queue.length - 1; i >= 0; i--) {
-    if (queue[i].assignedSessionId === sessionId && queue[i].status === "assigned") {
-      const time3 = new Date(queue[i].dispatchTimestamp || queue[i].updatedAt).getTime();
-      if (time3 > bestTime) {
-        bestTime = time3;
-        bestIdx = i;
-      }
-    }
-  }
-  if (bestIdx === -1) return null;
-  queue[bestIdx].status = status;
-  queue[bestIdx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeQueue(meshId, queue);
-  return queue[bestIdx];
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    let bestIdx = -1;
+    let bestTime = 0;
+    for (let i = queue.length - 1; i >= 0; i--) {
+      if (queue[i].assignedSessionId === sessionId && queue[i].status === "assigned") {
+        const time3 = new Date(queue[i].dispatchTimestamp || queue[i].updatedAt).getTime();
+        if (time3 > bestTime) {
+          bestTime = time3;
+          bestIdx = i;
+        }
+      }
+    }
+    if (bestIdx === -1) return null;
+    queue[bestIdx].status = status;
+    queue[bestIdx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeQueue(meshId, queue);
+    return queue[bestIdx];
+  });
 }
 function getMeshQueueStats(meshId) {
   const queue = readQueue(meshId);
@@ -4351,21 +4392,70 @@ __export(mesh_events_exports, {
   triggerMeshQueue: () => triggerMeshQueue,
   tryAssignQueueTask: () => tryAssignQueueTask
 });
+function sweepExpiredRemoteIdleSessions() {
+  const now = Date.now();
+  for (const [key, session] of remoteIdleSessions) {
+    if (session.expiresAt <= now) remoteIdleSessions.delete(key);
+  }
+}
+function getPendingEventsPath(meshId) {
+  const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return (0, import_path5.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
+}
 function queuePendingMeshCoordinatorEvent(event) {
-  if (pendingMeshCoordinatorEvents.length >= MAX_PENDING_EVENTS) {
+  try {
+    (0, import_fs6.appendFileSync)(getPendingEventsPath(event.meshId), JSON.stringify(event) + "\n", "utf-8");
+    return true;
+  } catch (e) {
+    LOG.warn("MeshEvents", `Failed to persist pending coordinator event: ${e?.message || e}`);
     return false;
   }
-  pendingMeshCoordinatorEvents.push(event);
-  return true;
 }
-function drainPendingMeshCoordinatorEvents() {
-  return pendingMeshCoordinatorEvents.splice(0);
+function drainPendingMeshCoordinatorEvents(meshId) {
+  if (!meshId) return [];
+  const path42 = getPendingEventsPath(meshId);
+  if (!(0, import_fs6.existsSync)(path42)) return [];
+  try {
+    const raw = (0, import_fs6.readFileSync)(path42, "utf-8");
+    try {
+      (0, import_fs6.unlinkSync)(path42);
+    } catch {
+    }
+    return raw.split("\n").filter(Boolean).flatMap((line) => {
+      try {
+        return [JSON.parse(line)];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
 }
-function getPendingMeshCoordinatorEvents() {
-  return pendingMeshCoordinatorEvents.slice();
+function getPendingMeshCoordinatorEvents(meshId) {
+  if (!meshId) return [];
+  const path42 = getPendingEventsPath(meshId);
+  if (!(0, import_fs6.existsSync)(path42)) return [];
+  try {
+    const raw = (0, import_fs6.readFileSync)(path42, "utf-8");
+    return raw.split("\n").filter(Boolean).flatMap((line) => {
+      try {
+        return [JSON.parse(line)];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
 }
-function clearPendingMeshCoordinatorEvents() {
-  pendingMeshCoordinatorEvents.splice(0);
+function clearPendingMeshCoordinatorEvents(meshId) {
+  if (!meshId) return;
+  const path42 = getPendingEventsPath(meshId);
+  if ((0, import_fs6.existsSync)(path42)) try {
+    (0, import_fs6.unlinkSync)(path42);
+  } catch {
+  }
 }
 function readNonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
@@ -4429,7 +4519,16 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
         message: task.message
       }).catch((e) => {
         LOG.error("MeshQueue", `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
-        updateTaskStatus(meshId, task.id, "failed");
+        updateTaskStatus(meshId, task.id, "pending");
+        try {
+          appendLedgerEntry(meshId, {
+            kind: "dispatch_failed",
+            nodeId,
+            sessionId,
+            payload: { taskId: task.id, error: e?.message, retryable: true }
+          });
+        } catch {
+        }
       });
       return true;
     }
@@ -4772,9 +4871,9 @@ function injectMeshSystemMessage(components, args) {
       const completedTask = updateSessionTaskStatus(args.meshId, sessionId, "completed");
       completedTaskForLedger = completedTask ? { id: completedTask.id } : null;
       if (nodeId && providerType) {
-        setTimeout(() => {
+        setImmediate(() => {
           tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-        }, 500);
+        });
       }
     }
   } else if (args.event === "agent:ready") {
@@ -4812,13 +4911,17 @@ function injectMeshSystemMessage(components, args) {
       }
     }
     if (sessionId && nodeId && providerType) {
-      remoteIdleSessions.set(`${nodeId}:${sessionId}`, { nodeId, sessionId, providerType });
-      setTimeout(() => {
+      sweepExpiredRemoteIdleSessions();
+      remoteIdleSessions.set(`${nodeId}:${sessionId}`, {
+        nodeId,
+        sessionId,
+        providerType,
+        expiresAt: Date.now() + REMOTE_IDLE_SESSION_TTL_MS
+      });
+      setImmediate(() => {
         const assigned = tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-        if (assigned) {
-          remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
-        }
-      }, 500);
+        if (assigned) remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+      });
     }
   } else if (args.event === "agent:generating_started") {
     const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
@@ -5021,19 +5124,20 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var remoteIdleSessions, MAX_PENDING_EVENTS, pendingMeshCoordinatorEvents, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
+var import_fs6, import_path5, REMOTE_IDLE_SESSION_TTL_MS, remoteIdleSessions, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
 var init_mesh_events = __esm({
   "../../oss/packages/daemon-core/src/mesh/mesh-events.ts"() {
     "use strict";
+    import_fs6 = require("fs");
+    import_path5 = require("path");
     init_config();
     init_mesh_config();
     init_cli_detector();
     init_logger();
     init_mesh_ledger();
     init_mesh_work_queue();
+    REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1e3;
     remoteIdleSessions = /* @__PURE__ */ new Map();
-    MAX_PENDING_EVENTS = 50;
-    pendingMeshCoordinatorEvents = [];
     MESH_COORDINATOR_EVENTS = /* @__PURE__ */ new Set([
       "agent:generating_started",
       "agent:generating_completed",
@@ -5176,7 +5280,7 @@ function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getStatePath() {
-  return (0, import_path5.join)(getConfigDir(), "state.json");
+  return (0, import_path6.join)(getConfigDir(), "state.json");
 }
 function normalizeState(raw) {
   const parsed = isPlainObject2(raw) ? raw : {};
@@ -5212,11 +5316,11 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!(0, import_fs6.existsSync)(statePath)) {
+  if (!(0, import_fs7.existsSync)(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
-    const raw = (0, import_fs6.readFileSync)(statePath, "utf-8");
+    const raw = (0, import_fs7.readFileSync)(statePath, "utf-8");
     return normalizeState(JSON.parse(raw));
   } catch {
     return { ...DEFAULT_STATE };
@@ -5225,17 +5329,17 @@ function loadState() {
 function saveState(state) {
   const statePath = getStatePath();
   const normalized = normalizeState(state);
-  (0, import_fs6.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs7.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function resetState() {
   saveState({ ...DEFAULT_STATE });
 }
-var import_fs6, import_path5, DEFAULT_STATE;
+var import_fs7, import_path6, DEFAULT_STATE;
 var init_state_store = __esm({
   "../../oss/packages/daemon-core/src/config/state-store.ts"() {
     "use strict";
-    import_fs6 = require("fs");
-    import_path5 = require("path");
+    import_fs7 = require("fs");
+    import_path6 = require("path");
     init_config();
     DEFAULT_STATE = {
       recentActivity: [],
@@ -5268,7 +5372,7 @@ function findCliCommand(command) {
   if (path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
     const candidate = trimmed.startsWith("~") ? path10.join((0, import_os2.homedir)(), trimmed.slice(1)) : trimmed;
     const resolved = path10.isAbsolute(candidate) ? candidate : path10.resolve(candidate);
-    return (0, import_fs7.existsSync)(resolved) ? resolved : null;
+    return (0, import_fs8.existsSync)(resolved) ? resolved : null;
   }
   try {
     const result = (0, import_child_process2.execSync)(
@@ -5299,9 +5403,9 @@ function checkPathExists(paths) {
     if (normalized.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
       const resolved = normalized.replace("*", username);
-      if ((0, import_fs7.existsSync)(resolved)) return resolved;
+      if ((0, import_fs8.existsSync)(resolved)) return resolved;
     } else {
-      if ((0, import_fs7.existsSync)(normalized)) return normalized;
+      if ((0, import_fs8.existsSync)(normalized)) return normalized;
     }
   }
   return null;
@@ -5315,7 +5419,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os32 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if ((0, import_fs7.existsSync)(bundledCli)) resolvedCli = bundledCli;
+      if ((0, import_fs8.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os32 === "win32") {
       const { dirname: dirname13 } = await import("path");
@@ -5328,7 +5432,7 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if ((0, import_fs7.existsSync)(c)) {
+        if ((0, import_fs8.existsSync)(c)) {
           resolvedCli = c;
           break;
         }
@@ -5349,12 +5453,12 @@ async function detectIDEs(providerLoader) {
   }
   return results;
 }
-var import_child_process2, import_fs7, import_os2, path10, BUILTIN_IDE_DEFINITIONS, registeredIDEs;
+var import_child_process2, import_fs8, import_os2, path10, BUILTIN_IDE_DEFINITIONS, registeredIDEs;
 var init_ide_detector = __esm({
   "../../oss/packages/daemon-core/src/detection/ide-detector.ts"() {
     "use strict";
     import_child_process2 = require("child_process");
-    import_fs7 = require("fs");
+    import_fs8 = require("fs");
     import_os2 = require("os");
     path10 = __toESM(require("path"));
     BUILTIN_IDE_DEFINITIONS = [];
@@ -37802,7 +37906,7 @@ function commandExists(command) {
   const trimmed = command.trim();
   if (!trimmed) return false;
   if (isExplicitCommand(trimmed)) {
-    return (0, import_fs8.existsSync)(expandExecutable(trimmed));
+    return (0, import_fs9.existsSync)(expandExecutable(trimmed));
   }
   try {
     (0, import_child_process6.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -37823,10 +37927,10 @@ function hasCliArg(args, flag) {
 }
 function ensureEmptyDelegatedMcpConfig(workspace) {
   const baseDir = path19.join(os16.tmpdir(), "adhdev-delegated-agent-empty-mcp");
-  (0, import_fs8.mkdirSync)(baseDir, { recursive: true });
+  (0, import_fs9.mkdirSync)(baseDir, { recursive: true });
   const workspaceHash = crypto4.createHash("sha256").update(path19.resolve(workspace || os16.tmpdir())).digest("hex").slice(0, 16);
   const filePath = path19.join(baseDir, `${workspaceHash}.json`);
-  (0, import_fs8.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
+  (0, import_fs9.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
   return filePath;
 }
 function buildCoordinatorDelegatedCliLaunchOptions(input) {
@@ -37953,14 +38057,14 @@ function resolveCliSessionBinding(provider, normalizedType, cliArgs, requestedRe
     launchMode: "new"
   };
 }
-var os16, path19, crypto4, import_fs8, import_child_process6, chalkModule, chalkApi, COORDINATOR_DELEGATED_ENV_UNSETS, DaemonCliManager;
+var os16, path19, crypto4, import_fs9, import_child_process6, chalkModule, chalkApi, COORDINATOR_DELEGATED_ENV_UNSETS, DaemonCliManager;
 var init_cli_manager = __esm({
   "../../oss/packages/daemon-core/src/commands/cli-manager.ts"() {
     "use strict";
     os16 = __toESM(require("os"));
     path19 = __toESM(require("path"));
     crypto4 = __toESM(require("crypto"));
-    import_fs8 = require("fs");
+    import_fs9 = require("fs");
     import_child_process6 = require("child_process");
     init_source2();
     init_provider_cli_adapter();
@@ -38874,7 +38978,7 @@ function createFsWatchInstance(path42, options, listener, errHandler, emitRaw) {
     }
   };
   try {
-    return (0, import_fs9.watch)(path42, {
+    return (0, import_fs10.watch)(path42, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error48) {
@@ -38882,11 +38986,11 @@ function createFsWatchInstance(path42, options, listener, errHandler, emitRaw) {
     return void 0;
   }
 }
-var import_fs9, import_promises5, sysPath, import_os3, STR_DATA, STR_END, STR_CLOSE, EMPTY_FN, pl, isWindows, isMacos, isLinux, isFreeBSD, isIBMi, EVENTS, EV, THROTTLE_MODE_WATCH, statMethods, KEY_LISTENERS, KEY_ERR, KEY_RAW, HANDLER_KEYS, binaryExtensions, isBinaryPath, foreach, addAndConvert, clearItem, delFromSet, isEmptySet, FsWatchInstances, fsWatchBroadcast, setFsWatchListener, FsWatchFileInstances, setFsWatchFileListener, NodeFsHandler;
+var import_fs10, import_promises5, sysPath, import_os3, STR_DATA, STR_END, STR_CLOSE, EMPTY_FN, pl, isWindows, isMacos, isLinux, isFreeBSD, isIBMi, EVENTS, EV, THROTTLE_MODE_WATCH, statMethods, KEY_LISTENERS, KEY_ERR, KEY_RAW, HANDLER_KEYS, binaryExtensions, isBinaryPath, foreach, addAndConvert, clearItem, delFromSet, isEmptySet, FsWatchInstances, fsWatchBroadcast, setFsWatchListener, FsWatchFileInstances, setFsWatchFileListener, NodeFsHandler;
 var init_handler2 = __esm({
   "../../oss/node_modules/chokidar/esm/handler.js"() {
     "use strict";
-    import_fs9 = require("fs");
+    import_fs10 = require("fs");
     import_promises5 = require("fs/promises");
     sysPath = __toESM(require("path"), 1);
     import_os3 = require("os");
@@ -39290,7 +39394,7 @@ var init_handler2 = __esm({
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
       if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-        (0, import_fs9.unwatchFile)(fullPath);
+        (0, import_fs10.unwatchFile)(fullPath);
         cont = void 0;
       }
       if (cont) {
@@ -39301,7 +39405,7 @@ var init_handler2 = __esm({
           listeners: listener,
           rawEmitters: rawEmitter,
           options,
-          watcher: (0, import_fs9.watchFile)(fullPath, options, (curr, prev) => {
+          watcher: (0, import_fs10.watchFile)(fullPath, options, (curr, prev) => {
             foreach(cont.rawEmitters, (rawEmitter2) => {
               rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
             });
@@ -39318,7 +39422,7 @@ var init_handler2 = __esm({
         delFromSet(cont, KEY_RAW, rawEmitter);
         if (isEmptySet(cont.listeners)) {
           FsWatchFileInstances.delete(fullPath);
-          (0, import_fs9.unwatchFile)(fullPath);
+          (0, import_fs10.unwatchFile)(fullPath);
           cont.options = cont.watcher = void 0;
           Object.freeze(cont);
         }
@@ -39696,11 +39800,11 @@ function watch(paths, options = {}) {
   watcher.add(paths);
   return watcher;
 }
-var import_fs10, import_promises6, import_events2, sysPath2, SLASH, SLASH_SLASH, ONE_DOT, TWO_DOTS, STRING_TYPE, BACK_SLASH_RE, DOUBLE_SLASH_RE, DOT_RE, REPLACER_RE, isMatcherObject, unifyPaths, toUnix, normalizePathToUnix, normalizeIgnored, getAbsolutePath, EMPTY_SET, DirEntry, STAT_METHOD_F, STAT_METHOD_L, WatchHelper, FSWatcher;
+var import_fs11, import_promises6, import_events2, sysPath2, SLASH, SLASH_SLASH, ONE_DOT, TWO_DOTS, STRING_TYPE, BACK_SLASH_RE, DOUBLE_SLASH_RE, DOT_RE, REPLACER_RE, isMatcherObject, unifyPaths, toUnix, normalizePathToUnix, normalizeIgnored, getAbsolutePath, EMPTY_SET, DirEntry, STAT_METHOD_F, STAT_METHOD_L, WatchHelper, FSWatcher;
 var init_esm2 = __esm({
   "../../oss/node_modules/chokidar/esm/index.js"() {
     "use strict";
-    import_fs10 = require("fs");
+    import_fs11 = require("fs");
     import_promises6 = require("fs/promises");
     import_events2 = require("events");
     sysPath2 = __toESM(require("path"), 1);
@@ -40178,7 +40282,7 @@ var init_esm2 = __esm({
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
-          (0, import_fs10.stat)(fullPath, (err, curStat) => {
+          (0, import_fs11.stat)(fullPath, (err, curStat) => {
             if (err || !writes.has(path42)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
@@ -46855,7 +46959,7 @@ function truncateValidationOutput(value) {
 }
 function readPackageScripts(workspace) {
   try {
-    const packageJsonPath = (0, import_path6.join)(workspace, "package.json");
+    const packageJsonPath = (0, import_path7.join)(workspace, "package.json");
     const parsed = JSON.parse(fs10.readFileSync(packageJsonPath, "utf-8"));
     return parsed?.scripts && typeof parsed.scripts === "object" && !Array.isArray(parsed.scripts) ? parsed.scripts : {};
   } catch {
@@ -47063,13 +47167,13 @@ function serializeMeshCoordinatorMcpConfig(config2, format) {
 }
 function resolveHermesUserHome() {
   const explicitHome = process.env.HERMES_HOME?.trim();
-  return explicitHome || (0, import_path6.join)((0, import_os4.homedir)(), ".hermes");
+  return explicitHome || (0, import_path7.join)((0, import_os4.homedir)(), ".hermes");
 }
 function loadHermesCoordinatorBaseConfig(targetConfigPath) {
   const sourceHome = resolveHermesUserHome();
-  const sourceConfigPath = (0, import_path6.join)(sourceHome, "config.yaml");
+  const sourceConfigPath = (0, import_path7.join)(sourceHome, "config.yaml");
   if (!fs10.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-  if ((0, import_path6.resolve)(sourceConfigPath) === (0, import_path6.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+  if ((0, import_path7.resolve)(sourceConfigPath) === (0, import_path7.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
   const parsed = parseMeshCoordinatorMcpConfig(fs10.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
   const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
   return { config: baseConfig, sourceHome, sourceConfigPath };
@@ -47103,10 +47207,10 @@ function stripHermesCoordinatorTempModelProviderOverrides(config2) {
   return sanitized;
 }
 function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-  if ((0, import_path6.resolve)(sourceHome) === (0, import_path6.resolve)(targetHome)) return;
+  if ((0, import_path7.resolve)(sourceHome) === (0, import_path7.resolve)(targetHome)) return;
   for (const fileName of [".env", "auth.json"]) {
-    const sourcePath = (0, import_path6.join)(sourceHome, fileName);
-    const targetPath = (0, import_path6.join)(targetHome, fileName);
+    const sourcePath = (0, import_path7.join)(sourceHome, fileName);
+    const targetPath = (0, import_path7.join)(targetHome, fileName);
     if (!fs10.existsSync(sourcePath)) continue;
     try {
       fs10.copyFileSync(sourcePath, targetPath);
@@ -47196,7 +47300,7 @@ function summarizeSessionHostPruneResult(result) {
     keptCount: Array.isArray(value.keptSessionIds) ? value.keptSessionIds.length : void 0
   };
 }
-var import_os4, import_path6, fs10, CHANNEL_NPM_TAG, CHANNEL_SERVER_URL, REFINE_VALIDATION_CATEGORIES, REFINE_VALIDATION_TIMEOUT_MS, REFINE_VALIDATION_OUTPUT_LIMIT_BYTES, REFINE_VALIDATION_SUMMARY_CHARS, REFINE_VALIDATION_MAX_COMMANDS, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter;
+var import_os4, import_path7, fs10, CHANNEL_NPM_TAG, CHANNEL_SERVER_URL, REFINE_VALIDATION_CATEGORIES, REFINE_VALIDATION_TIMEOUT_MS, REFINE_VALIDATION_OUTPUT_LIMIT_BYTES, REFINE_VALIDATION_SUMMARY_CHARS, REFINE_VALIDATION_MAX_COMMANDS, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter;
 var init_router = __esm({
   "../../oss/packages/daemon-core/src/commands/router.ts"() {
     "use strict";
@@ -47226,7 +47330,7 @@ var init_router = __esm({
     init_snapshot();
     init_upgrade_helper();
     import_os4 = require("os");
-    import_path6 = require("path");
+    import_path7 = require("path");
     fs10 = __toESM(require("fs"));
     CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
     CHANNEL_SERVER_URL = {
@@ -47355,7 +47459,7 @@ var init_router = __esm({
         }
         const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
         const normalizePath3 = (value) => {
-          const resolved = (0, import_path6.resolve)(value);
+          const resolved = (0, import_path7.resolve)(value);
           try {
             return fs10.realpathSync(resolved);
           } catch {
@@ -47756,7 +47860,8 @@ var init_router = __esm({
             return handleMeshForwardEvent({ instanceManager: this.deps.instanceManager }, args);
           }
           case "get_pending_mesh_events": {
-            const events = drainPendingMeshCoordinatorEvents();
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            const events = drainPendingMeshCoordinatorEvents(meshId || void 0);
             return { success: true, events };
           }
           case "launch_cli":
@@ -48977,7 +49082,7 @@ ${block}`);
                   workspace
                 };
               }
-              const { existsSync: existsSync32, readFileSync: readFileSync23, writeFileSync: writeFileSync18, copyFileSync: copyFileSync5, mkdirSync: mkdirSync22 } = await import("fs");
+              const { existsSync: existsSync33, readFileSync: readFileSync24, writeFileSync: writeFileSync18, copyFileSync: copyFileSync5, mkdirSync: mkdirSync22 } = await import("fs");
               const { dirname: dirname13 } = await import("path");
               const mcpConfigPath = coordinatorSetup.configPath;
               const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -49020,14 +49125,14 @@ ${block}`);
                 if (hermesManualFallback) return returnManualFallback(message);
                 return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
               }
-              const hadExistingMcpConfig = existsSync32(mcpConfigPath);
+              const hadExistingMcpConfig = existsSync33(mcpConfigPath);
               let existingMcpConfig = hermesBaseConfig?.config || {};
               if (hermesBaseConfig) {
                 copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname13(mcpConfigPath));
               }
               if (hadExistingMcpConfig) {
                 try {
-                  const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync23(mcpConfigPath, "utf-8"), configFormat);
+                  const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync24(mcpConfigPath, "utf-8"), configFormat);
                   const existingCoordinatorConfig = hermesManualFallback ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig) : parsedExistingMcpConfig;
                   existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
                   copyFileSync5(mcpConfigPath, mcpConfigPath + ".backup");
@@ -49215,29 +49320,48 @@ ${block}`);
                 }
                 if (workspace) {
                   if (!fs10.existsSync(workspace)) {
-                    if (applyCachedInlineMeshNodeStatus(status, node)) {
-                      status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
-                      nodeStatuses.push(status);
-                      continue;
-                    }
-                    if (meshRecord?.source === "inline_cache" && !isSelfNode) {
-                      status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
-                      nodeStatuses.push(status);
-                      continue;
+                    let remoteProbeApplied = false;
+                    if (!isSelfNode && daemonId && this.deps.dispatchMeshCommand) {
+                      try {
+                        const remoteResult = await Promise.race([
+                          this.deps.dispatchMeshCommand(daemonId, "git_status", { workspace }),
+                          new Promise((_2, reject) => setTimeout(() => reject(new Error("timeout")), 8e3))
+                        ]);
+                        const remoteGit = remoteResult?.status ?? remoteResult?.git ?? remoteResult;
+                        if (remoteGit && typeof remoteGit === "object" && typeof remoteGit.isGitRepo === "boolean") {
+                          status.git = remoteGit;
+                          status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
+                          remoteProbeApplied = true;
+                        }
+                      } catch {
+                      }
                     }
-                  }
-                  try {
-                    const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
-                    status.git = gitStatus;
-                    if (gitStatus.isGitRepo) {
-                      status.health = deriveMeshNodeHealthFromGit(gitStatus);
-                    } else {
-                      status.health = "degraded";
-                      if (gitStatus.error && !status.error) status.error = gitStatus.error;
+                    if (!remoteProbeApplied) {
+                      if (applyCachedInlineMeshNodeStatus(status, node)) {
+                        status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
+                        nodeStatuses.push(status);
+                        continue;
+                      }
+                      if (meshRecord?.source === "inline_cache" && !isSelfNode) {
+                        status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
+                        nodeStatuses.push(status);
+                        continue;
+                      }
                     }
-                  } catch {
-                    if (!applyCachedInlineMeshNodeStatus(status, node)) {
-                      status.health = "degraded";
+                  } else {
+                    try {
+                      const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
+                      status.git = gitStatus;
+                      if (gitStatus.isGitRepo) {
+                        status.health = deriveMeshNodeHealthFromGit(gitStatus);
+                      } else {
+                        status.health = "degraded";
+                        if (gitStatus.error && !status.error) status.error = gitStatus.error;
+                      }
+                    } catch {
+                      if (!applyCachedInlineMeshNodeStatus(status, node)) {
+                        status.health = "degraded";
+                      }
                     }
                   }
                 } else {
@@ -58095,7 +58219,7 @@ var require_yoctocolors_cjs = __commonJS({
   }
 });
 
-// ../../node_modules/@inquirer/figures/dist/esm/index.mjs
+// ../../node_modules/@inquirer/figures/dist/esm/index.js
 function isUnicodeSupported() {
   if (import_node_process3.default.platform !== "win32") {
     return import_node_process3.default.env["TERM"] !== "linux";
@@ -58107,7 +58231,7 @@ function isUnicodeSupported() {
 }
 var import_node_process3, common2, specialMainSymbols, specialFallbackSymbols, mainSymbols, fallbackSymbols, shouldUseMain, figures, esm_default, replacements;
 var init_esm3 = __esm({
-  "../../node_modules/@inquirer/figures/dist/esm/index.mjs"() {
+  "../../node_modules/@inquirer/figures/dist/esm/index.js"() {
     "use strict";
     import_node_process3 = __toESM(require("process"), 1);
     common2 = {
@@ -58378,7 +58502,10 @@ var init_esm3 = __esm({
       oneNinth: "1/9",
       oneTenth: "1/10"
     };
-    mainSymbols = { ...common2, ...specialMainSymbols };
+    mainSymbols = {
+      ...common2,
+      ...specialMainSymbols
+    };
     fallbackSymbols = {
       ...common2,
       ...specialFallbackSymbols
@@ -72538,7 +72665,7 @@ var require_buffer_list = __commonJS({
         }
       }, {
         key: "join",
-        value: function join39(s) {
+        value: function join40(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret = "" + p.data;
@@ -86597,13 +86724,13 @@ function splitStringBySpace(str2) {
   }
   return pieces;
 }
-var import_chardet, import_child_process12, import_fs11, import_node_path3, import_node_os3, import_node_crypto3, import_iconv_lite, ExternalEditor;
+var import_chardet, import_child_process12, import_fs12, import_node_path3, import_node_os3, import_node_crypto3, import_iconv_lite, ExternalEditor;
 var init_esm4 = __esm({
   "../../node_modules/@inquirer/external-editor/dist/esm/index.js"() {
     "use strict";
     import_chardet = __toESM(require_lib(), 1);
     import_child_process12 = require("child_process");
-    import_fs11 = require("fs");
+    import_fs12 = require("fs");
     import_node_path3 = __toESM(require("path"), 1);
     import_node_os3 = __toESM(require("os"), 1);
     import_node_crypto3 = require("crypto");
@@ -86679,14 +86806,14 @@ var init_esm4 = __esm({
           if (Object.prototype.hasOwnProperty.call(this.fileOptions, "mode")) {
             opt.mode = this.fileOptions.mode;
           }
-          (0, import_fs11.writeFileSync)(this.tempFile, this.text, opt);
+          (0, import_fs12.writeFileSync)(this.tempFile, this.text, opt);
         } catch (createFileError) {
           throw new CreateFileError(createFileError);
         }
       }
       readTemporaryFile() {
         try {
-          const tempFileBuffer = (0, import_fs11.readFileSync)(this.tempFile);
+          const tempFileBuffer = (0, import_fs12.readFileSync)(this.tempFile);
           if (tempFileBuffer.length === 0) {
             this.text = "";
           } else {
@@ -86702,7 +86829,7 @@ var init_esm4 = __esm({
       }
       removeTemporaryFile() {
         try {
-          (0, import_fs11.unlinkSync)(this.tempFile);
+          (0, import_fs12.unlinkSync)(this.tempFile);
         } catch (removeFileError) {
           throw new RemoveFileError(removeFileError);
         }
@@ -88404,25 +88531,25 @@ function resolvePackageVersion(options) {
   const injectedVersion = options?.injectedVersion || "unknown";
   const dir = options?.dirname || __dirname;
   const possiblePaths = [
-    (0, import_path7.join)(dir, "..", "..", "package.json"),
-    (0, import_path7.join)(dir, "..", "package.json"),
-    (0, import_path7.join)(dir, "package.json")
+    (0, import_path8.join)(dir, "..", "..", "package.json"),
+    (0, import_path8.join)(dir, "..", "package.json"),
+    (0, import_path8.join)(dir, "package.json")
   ];
   for (const p of possiblePaths) {
     try {
-      const data = JSON.parse((0, import_fs12.readFileSync)(p, "utf-8"));
+      const data = JSON.parse((0, import_fs13.readFileSync)(p, "utf-8"));
       if (data.version) return data.version;
     } catch {
     }
   }
   return injectedVersion;
 }
-var import_fs12, import_path7;
+var import_fs13, import_path8;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    import_fs12 = require("fs");
-    import_path7 = require("path");
+    import_fs13 = require("fs");
+    import_path8 = require("path");
   }
 });
 
@@ -90358,7 +90485,7 @@ var require_filesystem = __commonJS({
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync23 = (path42) => {
+    var readFileSync24 = (path42) => {
       const fd = fs24.openSync(path42, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
       const bytesRead = fs24.readSync(fd, buffer, 0, MAX_LENGTH, 0);
@@ -90383,7 +90510,7 @@ var require_filesystem = __commonJS({
     module2.exports = {
       LDD_PATH,
       SELF_PATH,
-      readFileSync: readFileSync23,
+      readFileSync: readFileSync24,
       readFile: readFile2
     };
   }
@@ -90432,7 +90559,7 @@ var require_detect_libc = __commonJS({
     "use strict";
     var childProcess = require("child_process");
     var { isLinux: isLinux2, getReport } = require_process();
-    var { LDD_PATH, SELF_PATH, readFile: readFile2, readFileSync: readFileSync23 } = require_filesystem();
+    var { LDD_PATH, SELF_PATH, readFile: readFile2, readFileSync: readFileSync24 } = require_filesystem();
     var { interpreterPath } = require_elf();
     var cachedFamilyInterpreter;
     var cachedFamilyFilesystem;
@@ -90524,7 +90651,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyFilesystem = null;
       try {
-        const lddContent = readFileSync23(LDD_PATH);
+        const lddContent = readFileSync24(LDD_PATH);
         cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
       } catch (e) {
       }
@@ -90549,7 +90676,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyInterpreter = null;
       try {
-        const selfContent = readFileSync23(SELF_PATH);
+        const selfContent = readFileSync24(SELF_PATH);
         const path42 = interpreterPath(selfContent);
         cachedFamilyInterpreter = familyFromInterpreterPath(path42);
       } catch (e) {
@@ -90613,7 +90740,7 @@ var require_detect_libc = __commonJS({
       }
       cachedVersionFilesystem = null;
       try {
-        const lddContent = readFileSync23(LDD_PATH);
+        const lddContent = readFileSync24(LDD_PATH);
         const versionMatch = lddContent.match(RE_GLIBC_VERSION);
         if (versionMatch) {
           cachedVersionFilesystem = versionMatch[1];
@@ -98283,7 +98410,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.23" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.24" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;