@adhdev/daemon-core 0.9.82-rc.343 → 0.9.82-rc.345

package/dist/index.js

@@ -316,10 +316,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "9a4c1af9349a342fc63d8d42746747a6feda8f08" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "9a4c1af9" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.343" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-21T11:25:17.034Z" : void 0);
+  const commit = readInjected(true ? "d04317b7eab7aec6a5557cb1991af603c7e5143c" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "d04317b7" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.345" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-21T13:55:50.824Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -2541,6 +2541,297 @@ Follow these recovery rules:
   }
 });
 
+// src/logging/async-batch-writer.ts
+var fs3, AsyncBatchWriter;
+var init_async_batch_writer = __esm({
+  "src/logging/async-batch-writer.ts"() {
+    "use strict";
+    fs3 = __toESM(require("fs"));
+    AsyncBatchWriter = class {
+      // Maps filePath -> string buffer
+      static buffers = /* @__PURE__ */ new Map();
+      static writePromises = /* @__PURE__ */ new Map();
+      static flushTimer = null;
+      /**
+       * Queues data to be written to a file asynchronously in a batch.
+       */
+      static write(filePath, data) {
+        let buf = this.buffers.get(filePath);
+        if (!buf) {
+          buf = [];
+          this.buffers.set(filePath, buf);
+        }
+        buf.push(data);
+        if (!this.flushTimer) {
+          this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            this.flushAll();
+          }, 50);
+        }
+      }
+      static async flushAll() {
+        const entries = Array.from(this.buffers.entries());
+        this.buffers.clear();
+        for (const [filePath, buffer] of entries) {
+          const dataToWrite = buffer.join("");
+          const doWrite = async () => {
+            try {
+              const prevPromise = this.writePromises.get(filePath);
+              if (prevPromise) await prevPromise;
+              await fs3.promises.appendFile(filePath, dataToWrite, { encoding: "utf-8", mode: 384 });
+            } catch {
+            }
+          };
+          const writePromise = doWrite();
+          this.writePromises.set(filePath, writePromise);
+          writePromise.finally(() => {
+            if (this.writePromises.get(filePath) === writePromise) {
+              this.writePromises.delete(filePath);
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/logging/logger.ts
+var logger_exports = {};
+__export(logger_exports, {
+  LOG: () => LOG,
+  LOG_DIR_PATH: () => LOG_DIR_PATH,
+  LOG_PATH: () => LOG_PATH,
+  daemonLog: () => daemonLog,
+  getCurrentDaemonLogPath: () => getCurrentDaemonLogPath,
+  getDaemonLogDir: () => getDaemonLogDir,
+  getLogBufferSize: () => getLogBufferSize,
+  getLogLevel: () => getLogLevel,
+  getLogPath: () => getLogPath,
+  getRecentLogs: () => getRecentLogs,
+  installGlobalInterceptor: () => installGlobalInterceptor,
+  setLogLevel: () => setLogLevel
+});
+function setLogLevel(level) {
+  currentLevel = level;
+  daemonLog("Logger", `Log level set to: ${level}`, "info");
+}
+function getLogLevel() {
+  return currentLevel;
+}
+function getDateStr() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function getDaemonLogDir() {
+  return LOG_DIR;
+}
+function getCurrentDaemonLogPath(date = /* @__PURE__ */ new Date()) {
+  return path9.join(LOG_DIR, `daemon-${date.toISOString().slice(0, 10)}.log`);
+}
+function checkDateRotation() {
+  const today = getDateStr();
+  if (today !== currentDate) {
+    currentDate = today;
+    currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
+    cleanOldLogs();
+  }
+}
+function cleanOldLogs() {
+  try {
+    const files = fs4.readdirSync(LOG_DIR).filter((f) => f.startsWith("daemon-") && f.endsWith(".log"));
+    const cutoff = /* @__PURE__ */ new Date();
+    cutoff.setDate(cutoff.getDate() - MAX_LOG_DAYS);
+    const cutoffStr = cutoff.toISOString().slice(0, 10);
+    for (const file of files) {
+      const dateMatch = file.match(/daemon-(\d{4}-\d{2}-\d{2})/);
+      if (dateMatch && dateMatch[1] < cutoffStr) {
+        try {
+          fs4.unlinkSync(path9.join(LOG_DIR, file));
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+function rotateSizeIfNeeded() {
+  try {
+    const stat2 = fs4.statSync(currentLogFile);
+    if (stat2.size > MAX_LOG_SIZE) {
+      const backup = currentLogFile.replace(".log", ".1.log");
+      try {
+        fs4.unlinkSync(backup);
+      } catch {
+      }
+      fs4.renameSync(currentLogFile, backup);
+    }
+  } catch {
+  }
+}
+function writeToFile(line) {
+  try {
+    if (++writeCount % 1e3 === 0) {
+      checkDateRotation();
+      rotateSizeIfNeeded();
+    }
+    AsyncBatchWriter.write(currentLogFile, line + "\n");
+  } catch {
+  }
+}
+function getRecentLogs(count = 50, minLevel = "info") {
+  const minNum = LEVEL_NUM[minLevel];
+  const filtered = ringBuffer.filter((e) => LEVEL_NUM[e.level] >= minNum);
+  return filtered.slice(-count);
+}
+function getLogBufferSize() {
+  return ringBuffer.length;
+}
+function ts() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+}
+function fullTs() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function daemonLog(category, msg, level = "info") {
+  const shouldOutput = LEVEL_NUM[level] >= LEVEL_NUM[currentLevel];
+  const label = LEVEL_LABEL[level];
+  const line = `[${ts()}] [${label}] [${category}] ${msg}`;
+  if (!shouldOutput) return;
+  writeToFile(line);
+  ringBuffer.push({ ts: Date.now(), level, category, message: msg });
+  if (ringBuffer.length > RING_BUFFER_SIZE) {
+    ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
+  }
+  origConsoleLog(line);
+}
+function installGlobalInterceptor() {
+  if (interceptorInstalled) return;
+  interceptorInstalled = true;
+  const stripAnsi4 = (str) => str.replace(/\x1B\[[0-9;]*m/g, "");
+  const isDaemonLogLine = (msg) => /\[(DBG|INF|WRN|ERR)\]/.test(msg);
+  console.log = (...args) => {
+    origConsoleLog(...args);
+    try {
+      const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+      const clean = stripAnsi4(msg);
+      if (isDaemonLogLine(clean)) return;
+      const line = clean.startsWith("[20") ? clean : `[${fullTs()}] ${clean}`;
+      writeToFile(line);
+      const catMatch = clean.match(/\[([^\]]+)\]/);
+      ringBuffer.push({
+        ts: Date.now(),
+        level: "info",
+        category: catMatch?.[1] || "System",
+        message: clean
+      });
+      if (ringBuffer.length > RING_BUFFER_SIZE) {
+        ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
+      }
+    } catch {
+    }
+  };
+  console.error = (...args) => {
+    origConsoleError(...args);
+    try {
+      const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+      const clean = stripAnsi4(msg);
+      if (isDaemonLogLine(clean)) return;
+      const line = `[${fullTs()}] [ERROR] ${clean}`;
+      writeToFile(line);
+      ringBuffer.push({ ts: Date.now(), level: "error", category: "System", message: clean });
+      if (ringBuffer.length > RING_BUFFER_SIZE) {
+        ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
+      }
+    } catch {
+    }
+  };
+  console.warn = (...args) => {
+    origConsoleWarn(...args);
+    try {
+      const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+      const clean = stripAnsi4(msg);
+      if (isDaemonLogLine(clean)) return;
+      const line = `[${fullTs()}] [WARN] ${clean}`;
+      writeToFile(line);
+      ringBuffer.push({ ts: Date.now(), level: "warn", category: "System", message: clean });
+      if (ringBuffer.length > RING_BUFFER_SIZE) {
+        ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
+      }
+    } catch {
+    }
+  };
+  writeToFile(`
+=== ADHDev Daemon started at ${fullTs()} ===`);
+  writeToFile(`Log file: ${currentLogFile}`);
+  writeToFile(`Log level: ${currentLevel}`);
+}
+function getLogPath() {
+  return currentLogFile;
+}
+var fs4, path9, os3, LEVEL_NUM, LEVEL_LABEL, currentLevel, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH, LOG_DIR_PATH;
+var init_logger = __esm({
+  "src/logging/logger.ts"() {
+    "use strict";
+    fs4 = __toESM(require("fs"));
+    path9 = __toESM(require("path"));
+    os3 = __toESM(require("os"));
+    init_async_batch_writer();
+    LEVEL_NUM = { debug: 0, info: 1, warn: 2, error: 3 };
+    LEVEL_LABEL = { debug: "DBG", info: "INF", warn: "WRN", error: "ERR" };
+    currentLevel = "info";
+    LOG_DIR = process.platform === "win32" ? path9.join(process.env.LOCALAPPDATA || process.env.APPDATA || path9.join(os3.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path9.join(os3.homedir(), "Library", "Logs", "adhdev") : path9.join(os3.homedir(), ".local", "share", "adhdev", "logs");
+    MAX_LOG_SIZE = 5 * 1024 * 1024;
+    MAX_LOG_DAYS = 7;
+    try {
+      fs4.mkdirSync(LOG_DIR, { recursive: true });
+    } catch {
+    }
+    currentDate = getDateStr();
+    currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
+    cleanOldLogs();
+    try {
+      const oldLog = path9.join(LOG_DIR, "daemon.log");
+      if (fs4.existsSync(oldLog)) {
+        const stat2 = fs4.statSync(oldLog);
+        const oldDate = stat2.mtime.toISOString().slice(0, 10);
+        fs4.renameSync(oldLog, path9.join(LOG_DIR, `daemon-${oldDate}.log`));
+      }
+      const oldLogBackup = path9.join(LOG_DIR, "daemon.log.old");
+      if (fs4.existsSync(oldLogBackup)) {
+        fs4.unlinkSync(oldLogBackup);
+      }
+    } catch {
+    }
+    writeCount = 0;
+    RING_BUFFER_SIZE = 200;
+    ringBuffer = [];
+    origConsoleLog = console.log.bind(console);
+    origConsoleError = console.error.bind(console);
+    origConsoleWarn = console.warn.bind(console);
+    LOG = {
+      debug: (category, msg) => daemonLog(category, msg, "debug"),
+      info: (category, msg) => daemonLog(category, msg, "info"),
+      warn: (category, msg) => daemonLog(category, msg, "warn"),
+      error: (category, msg) => daemonLog(category, msg, "error"),
+      /**
+       * Create a scoped logger for a specific component.
+       * Category is baked in so callers only pass the message.
+       */
+      forComponent(category) {
+        return {
+          debug: (msg) => daemonLog(category, msg, "debug"),
+          info: (msg) => daemonLog(category, msg, "info"),
+          warn: (msg) => daemonLog(category, msg, "warn"),
+          error: (msg) => daemonLog(category, msg, "error"),
+          asLogFn: (level = "info") => (msg) => daemonLog(category, msg, level)
+        };
+      }
+    };
+    interceptorInstalled = false;
+    LOG_PATH = path9.join(LOG_DIR, `daemon-${getDateStr()}.log`);
+    LOG_DIR_PATH = LOG_DIR;
+  }
+});
+
 // src/system/load-better-sqlite3.ts
 function loadBetterSqlite3() {
   if (cached2) return cached2;
@@ -3260,297 +3551,6 @@ var init_mesh_ledger = __esm({
   }
 });
 
-// src/logging/async-batch-writer.ts
-var fs3, AsyncBatchWriter;
-var init_async_batch_writer = __esm({
-  "src/logging/async-batch-writer.ts"() {
-    "use strict";
-    fs3 = __toESM(require("fs"));
-    AsyncBatchWriter = class {
-      // Maps filePath -> string buffer
-      static buffers = /* @__PURE__ */ new Map();
-      static writePromises = /* @__PURE__ */ new Map();
-      static flushTimer = null;
-      /**
-       * Queues data to be written to a file asynchronously in a batch.
-       */
-      static write(filePath, data) {
-        let buf = this.buffers.get(filePath);
-        if (!buf) {
-          buf = [];
-          this.buffers.set(filePath, buf);
-        }
-        buf.push(data);
-        if (!this.flushTimer) {
-          this.flushTimer = setTimeout(() => {
-            this.flushTimer = null;
-            this.flushAll();
-          }, 50);
-        }
-      }
-      static async flushAll() {
-        const entries = Array.from(this.buffers.entries());
-        this.buffers.clear();
-        for (const [filePath, buffer] of entries) {
-          const dataToWrite = buffer.join("");
-          const doWrite = async () => {
-            try {
-              const prevPromise = this.writePromises.get(filePath);
-              if (prevPromise) await prevPromise;
-              await fs3.promises.appendFile(filePath, dataToWrite, { encoding: "utf-8", mode: 384 });
-            } catch {
-            }
-          };
-          const writePromise = doWrite();
-          this.writePromises.set(filePath, writePromise);
-          writePromise.finally(() => {
-            if (this.writePromises.get(filePath) === writePromise) {
-              this.writePromises.delete(filePath);
-            }
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/logging/logger.ts
-var logger_exports = {};
-__export(logger_exports, {
-  LOG: () => LOG,
-  LOG_DIR_PATH: () => LOG_DIR_PATH,
-  LOG_PATH: () => LOG_PATH,
-  daemonLog: () => daemonLog,
-  getCurrentDaemonLogPath: () => getCurrentDaemonLogPath,
-  getDaemonLogDir: () => getDaemonLogDir,
-  getLogBufferSize: () => getLogBufferSize,
-  getLogLevel: () => getLogLevel,
-  getLogPath: () => getLogPath,
-  getRecentLogs: () => getRecentLogs,
-  installGlobalInterceptor: () => installGlobalInterceptor,
-  setLogLevel: () => setLogLevel
-});
-function setLogLevel(level) {
-  currentLevel = level;
-  daemonLog("Logger", `Log level set to: ${level}`, "info");
-}
-function getLogLevel() {
-  return currentLevel;
-}
-function getDateStr() {
-  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-}
-function getDaemonLogDir() {
-  return LOG_DIR;
-}
-function getCurrentDaemonLogPath(date = /* @__PURE__ */ new Date()) {
-  return path9.join(LOG_DIR, `daemon-${date.toISOString().slice(0, 10)}.log`);
-}
-function checkDateRotation() {
-  const today = getDateStr();
-  if (today !== currentDate) {
-    currentDate = today;
-    currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
-    cleanOldLogs();
-  }
-}
-function cleanOldLogs() {
-  try {
-    const files = fs4.readdirSync(LOG_DIR).filter((f) => f.startsWith("daemon-") && f.endsWith(".log"));
-    const cutoff = /* @__PURE__ */ new Date();
-    cutoff.setDate(cutoff.getDate() - MAX_LOG_DAYS);
-    const cutoffStr = cutoff.toISOString().slice(0, 10);
-    for (const file of files) {
-      const dateMatch = file.match(/daemon-(\d{4}-\d{2}-\d{2})/);
-      if (dateMatch && dateMatch[1] < cutoffStr) {
-        try {
-          fs4.unlinkSync(path9.join(LOG_DIR, file));
-        } catch {
-        }
-      }
-    }
-  } catch {
-  }
-}
-function rotateSizeIfNeeded() {
-  try {
-    const stat2 = fs4.statSync(currentLogFile);
-    if (stat2.size > MAX_LOG_SIZE) {
-      const backup = currentLogFile.replace(".log", ".1.log");
-      try {
-        fs4.unlinkSync(backup);
-      } catch {
-      }
-      fs4.renameSync(currentLogFile, backup);
-    }
-  } catch {
-  }
-}
-function writeToFile(line) {
-  try {
-    if (++writeCount % 1e3 === 0) {
-      checkDateRotation();
-      rotateSizeIfNeeded();
-    }
-    AsyncBatchWriter.write(currentLogFile, line + "\n");
-  } catch {
-  }
-}
-function getRecentLogs(count = 50, minLevel = "info") {
-  const minNum = LEVEL_NUM[minLevel];
-  const filtered = ringBuffer.filter((e) => LEVEL_NUM[e.level] >= minNum);
-  return filtered.slice(-count);
-}
-function getLogBufferSize() {
-  return ringBuffer.length;
-}
-function ts() {
-  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
-}
-function fullTs() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function daemonLog(category, msg, level = "info") {
-  const shouldOutput = LEVEL_NUM[level] >= LEVEL_NUM[currentLevel];
-  const label = LEVEL_LABEL[level];
-  const line = `[${ts()}] [${label}] [${category}] ${msg}`;
-  if (!shouldOutput) return;
-  writeToFile(line);
-  ringBuffer.push({ ts: Date.now(), level, category, message: msg });
-  if (ringBuffer.length > RING_BUFFER_SIZE) {
-    ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
-  }
-  origConsoleLog(line);
-}
-function installGlobalInterceptor() {
-  if (interceptorInstalled) return;
-  interceptorInstalled = true;
-  const stripAnsi4 = (str) => str.replace(/\x1B\[[0-9;]*m/g, "");
-  const isDaemonLogLine = (msg) => /\[(DBG|INF|WRN|ERR)\]/.test(msg);
-  console.log = (...args) => {
-    origConsoleLog(...args);
-    try {
-      const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-      const clean = stripAnsi4(msg);
-      if (isDaemonLogLine(clean)) return;
-      const line = clean.startsWith("[20") ? clean : `[${fullTs()}] ${clean}`;
-      writeToFile(line);
-      const catMatch = clean.match(/\[([^\]]+)\]/);
-      ringBuffer.push({
-        ts: Date.now(),
-        level: "info",
-        category: catMatch?.[1] || "System",
-        message: clean
-      });
-      if (ringBuffer.length > RING_BUFFER_SIZE) {
-        ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
-      }
-    } catch {
-    }
-  };
-  console.error = (...args) => {
-    origConsoleError(...args);
-    try {
-      const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-      const clean = stripAnsi4(msg);
-      if (isDaemonLogLine(clean)) return;
-      const line = `[${fullTs()}] [ERROR] ${clean}`;
-      writeToFile(line);
-      ringBuffer.push({ ts: Date.now(), level: "error", category: "System", message: clean });
-      if (ringBuffer.length > RING_BUFFER_SIZE) {
-        ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
-      }
-    } catch {
-    }
-  };
-  console.warn = (...args) => {
-    origConsoleWarn(...args);
-    try {
-      const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-      const clean = stripAnsi4(msg);
-      if (isDaemonLogLine(clean)) return;
-      const line = `[${fullTs()}] [WARN] ${clean}`;
-      writeToFile(line);
-      ringBuffer.push({ ts: Date.now(), level: "warn", category: "System", message: clean });
-      if (ringBuffer.length > RING_BUFFER_SIZE) {
-        ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
-      }
-    } catch {
-    }
-  };
-  writeToFile(`
-=== ADHDev Daemon started at ${fullTs()} ===`);
-  writeToFile(`Log file: ${currentLogFile}`);
-  writeToFile(`Log level: ${currentLevel}`);
-}
-function getLogPath() {
-  return currentLogFile;
-}
-var fs4, path9, os3, LEVEL_NUM, LEVEL_LABEL, currentLevel, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH, LOG_DIR_PATH;
-var init_logger = __esm({
-  "src/logging/logger.ts"() {
-    "use strict";
-    fs4 = __toESM(require("fs"));
-    path9 = __toESM(require("path"));
-    os3 = __toESM(require("os"));
-    init_async_batch_writer();
-    LEVEL_NUM = { debug: 0, info: 1, warn: 2, error: 3 };
-    LEVEL_LABEL = { debug: "DBG", info: "INF", warn: "WRN", error: "ERR" };
-    currentLevel = "info";
-    LOG_DIR = process.platform === "win32" ? path9.join(process.env.LOCALAPPDATA || process.env.APPDATA || path9.join(os3.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path9.join(os3.homedir(), "Library", "Logs", "adhdev") : path9.join(os3.homedir(), ".local", "share", "adhdev", "logs");
-    MAX_LOG_SIZE = 5 * 1024 * 1024;
-    MAX_LOG_DAYS = 7;
-    try {
-      fs4.mkdirSync(LOG_DIR, { recursive: true });
-    } catch {
-    }
-    currentDate = getDateStr();
-    currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
-    cleanOldLogs();
-    try {
-      const oldLog = path9.join(LOG_DIR, "daemon.log");
-      if (fs4.existsSync(oldLog)) {
-        const stat2 = fs4.statSync(oldLog);
-        const oldDate = stat2.mtime.toISOString().slice(0, 10);
-        fs4.renameSync(oldLog, path9.join(LOG_DIR, `daemon-${oldDate}.log`));
-      }
-      const oldLogBackup = path9.join(LOG_DIR, "daemon.log.old");
-      if (fs4.existsSync(oldLogBackup)) {
-        fs4.unlinkSync(oldLogBackup);
-      }
-    } catch {
-    }
-    writeCount = 0;
-    RING_BUFFER_SIZE = 200;
-    ringBuffer = [];
-    origConsoleLog = console.log.bind(console);
-    origConsoleError = console.error.bind(console);
-    origConsoleWarn = console.warn.bind(console);
-    LOG = {
-      debug: (category, msg) => daemonLog(category, msg, "debug"),
-      info: (category, msg) => daemonLog(category, msg, "info"),
-      warn: (category, msg) => daemonLog(category, msg, "warn"),
-      error: (category, msg) => daemonLog(category, msg, "error"),
-      /**
-       * Create a scoped logger for a specific component.
-       * Category is baked in so callers only pass the message.
-       */
-      forComponent(category) {
-        return {
-          debug: (msg) => daemonLog(category, msg, "debug"),
-          info: (msg) => daemonLog(category, msg, "info"),
-          warn: (msg) => daemonLog(category, msg, "warn"),
-          error: (msg) => daemonLog(category, msg, "error"),
-          asLogFn: (level = "info") => (msg) => daemonLog(category, msg, level)
-        };
-      }
-    };
-    interceptorInstalled = false;
-    LOG_PATH = path9.join(LOG_DIR, `daemon-${getDateStr()}.log`);
-    LOG_DIR_PATH = LOG_DIR;
-  }
-});
-
 // src/mesh/mesh-work-queue.ts
 var mesh_work_queue_exports = {};
 __export(mesh_work_queue_exports, {
@@ -3867,6 +3867,7 @@ function enqueueTask(meshId, message, opts) {
       requiredTags: resolvedRequiredTags,
       ...dependsOn.length > 0 ? { dependsOn } : {},
       ...typeof opts?.missionId === "string" && opts.missionId.trim() ? { missionId: opts.missionId.trim() } : {},
+      ...typeof opts?.sourceCoordinatorSessionId === "string" && opts.sourceCoordinatorSessionId.trim() ? { sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId.trim() } : {},
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
@@ -4217,19 +4218,29 @@ function meshRuntimeStorePath() {
         (0, import_fs5.renameSync)(legacyCompanion, `${nextPath}${suffix}`);
       }
     }
-  } catch {
+  } catch (err) {
+    if (!loggedMigrationFailure) {
+      loggedMigrationFailure = true;
+      LOG.warn(
+        "MeshRuntimeStore",
+        `Legacy beads.db\u2192mesh-runtime.db migration failed; using existing DB in-place to avoid data loss: ${err?.message || err}`
+      );
+    }
+    return (0, import_fs5.existsSync)(nextPath) ? nextPath : legacyPath;
   }
   return nextPath;
 }
-var import_fs5, import_path5, DatabaseCtor, MeshRuntimeStore;
+var import_fs5, import_path5, DatabaseCtor, loggedMigrationFailure, MeshRuntimeStore;
 var init_mesh_runtime_store = __esm({
   "src/mesh/mesh-runtime-store.ts"() {
     "use strict";
     import_fs5 = require("fs");
     import_path5 = require("path");
+    init_logger();
     init_load_better_sqlite3();
     init_mesh_ledger();
     init_mesh_work_queue();
+    loggedMigrationFailure = false;
     MeshRuntimeStore = class _MeshRuntimeStore {
       static instance;
       db;
@@ -4251,9 +4262,21 @@ var init_mesh_runtime_store = __esm({
         this.db.pragma("busy_timeout = 5000");
         this.migrate();
       }
+      static loggedGetInstanceFailure = false;
       static getInstance() {
         if (!this.instance) {
-          this.instance = new _MeshRuntimeStore(meshRuntimeStorePath());
+          try {
+            this.instance = new _MeshRuntimeStore(meshRuntimeStorePath());
+          } catch (err) {
+            if (!_MeshRuntimeStore.loggedGetInstanceFailure) {
+              _MeshRuntimeStore.loggedGetInstanceFailure = true;
+              LOG.warn(
+                "MeshRuntimeStore",
+                `getInstance failed; callers will degrade to JSONL-only: ${err?.message || err}`
+              );
+            }
+            throw err;
+          }
         }
         return this.instance;
       }
@@ -7846,7 +7869,11 @@ function buildMeshWorkerRelayStamp(currentSettings, meshContext) {
   if (coordinatorDaemonId && !readNonEmptyString2(settings.meshCoordinatorDaemonId)) {
     stamp.meshCoordinatorDaemonId = coordinatorDaemonId;
   }
-  if ((meshId || nodeId || coordinatorDaemonId) && settings.launchedByCoordinator !== true) {
+  const coordinatorSessionId = readNonEmptyString2(meshContext.coordinatorSessionId);
+  if (coordinatorSessionId && !readNonEmptyString2(settings.meshCoordinatorSessionId)) {
+    stamp.meshCoordinatorSessionId = coordinatorSessionId;
+  }
+  if ((meshId || nodeId || coordinatorDaemonId || coordinatorSessionId) && settings.launchedByCoordinator !== true) {
     stamp.launchedByCoordinator = true;
   }
   return Object.keys(stamp).length > 0 ? stamp : void 0;
@@ -7863,10 +7890,13 @@ function readRefineJobId(event) {
 function readWorkerResultMetadata(event) {
   return readRecord4(event.workerResult) || readRecord4(event.meshWorkerResult) || readRecord4(event.structuredResult);
 }
-function resolveMeshSurfacedSessionPreview(metadataEvent) {
+function readMeshCompletionSummary(metadataEvent) {
   const workerResult = readWorkerResultMetadata(metadataEvent);
   const resultRecord = readRecord4(metadataEvent.result);
-  const summaryText = readNonEmptyString2(metadataEvent.finalSummary) || readNonEmptyString2(workerResult?.summary) || readNonEmptyString2(workerResult?.finalSummary) || readNonEmptyString2(resultRecord?.summary) || readNonEmptyString2(resultRecord?.finalSummary);
+  return readNonEmptyString2(metadataEvent.finalSummary) || readNonEmptyString2(workerResult?.summary) || readNonEmptyString2(workerResult?.finalSummary) || readNonEmptyString2(resultRecord?.summary) || readNonEmptyString2(resultRecord?.finalSummary);
+}
+function resolveMeshSurfacedSessionPreview(metadataEvent) {
+  const summaryText = readMeshCompletionSummary(metadataEvent);
   if (!summaryText) return void 0;
   const truncationSuffix = "...[truncated]";
   const preview = summaryText.length > MESH_SURFACED_PREVIEW_MAX_CHARS ? `${summaryText.slice(0, MESH_SURFACED_PREVIEW_MAX_CHARS - truncationSuffix.length)}${truncationSuffix}` : summaryText;
@@ -7904,7 +7934,18 @@ function buildMeshSystemMessage(args) {
     if (args.metadataEvent.source === "no_progress_reconciliation") {
       return `[System] ${args.nodeLabel} already has completion evidence${metadata}. The no-progress monitor reconciled the terminal handoff and marked the session complete; wait for the queued completion event/status refresh before doing any manual transcript check.`;
     }
-    const reviewNote = args.metadataEvent.reviewRecommended === true ? " Completion evidence is insufficient \u2014 verify via git status or provider_session_id before assuming the task is done. Use mesh_read_chat once if needed, but do not poll repeatedly." : " Use mesh_read_chat once to review its final progress, but do not poll repeatedly.";
+    const reviewRecommended = args.metadataEvent.reviewRecommended === true;
+    const completionSummary = readMeshCompletionSummary(args.metadataEvent);
+    if (completionSummary) {
+      const truncationSuffix = "\n\u2026[truncated \u2014 call mesh_read_chat once for the full transcript]";
+      const surfaced = completionSummary.length > MESH_COMPLETION_SURFACE_MAX_CHARS ? `${completionSummary.slice(0, MESH_COMPLETION_SURFACE_MAX_CHARS - truncationSuffix.length)}${truncationSuffix}` : completionSummary;
+      const verifyNote = reviewRecommended ? " Completion evidence is insufficient \u2014 verify via git status or provider_session_id before assuming the task is done." : "";
+      return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. Its final summary is included below \u2014 read it directly and only call mesh_read_chat if you need the full transcript.${verifyNote}
+
+--- ${args.nodeLabel} final summary ---
+${surfaced}`;
+    }
+    const reviewNote = reviewRecommended ? " Completion evidence is insufficient \u2014 verify via git status or provider_session_id before assuming the task is done. Use mesh_read_chat once if needed, but do not poll repeatedly." : " Use mesh_read_chat once to review its final progress, but do not poll repeatedly.";
     return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. This completion came from the agent status event path;${reviewNote}`;
   }
   if (args.event === "agent:waiting_approval") {
@@ -8012,11 +8053,12 @@ Next step: ${nextStep}`;
   }
   return "";
 }
-var MESH_SURFACED_PREVIEW_MAX_CHARS;
+var MESH_SURFACED_PREVIEW_MAX_CHARS, MESH_COMPLETION_SURFACE_MAX_CHARS;
 var init_mesh_events_utils = __esm({
   "src/mesh/mesh-events-utils.ts"() {
     "use strict";
     MESH_SURFACED_PREVIEW_MAX_CHARS = 512;
+    MESH_COMPLETION_SURFACE_MAX_CHARS = 4e3;
   }
 });
 
@@ -8174,6 +8216,37 @@ function trimPendingEventsIfNeeded(path42) {
     if ((0, import_fs10.statSync)(path42).size <= MAX_PENDING_EVENTS_BYTES) return;
     const lines = (0, import_fs10.readFileSync)(path42, "utf-8").split("\n").filter(Boolean);
     if (lines.length <= MAX_PENDING_EVENTS_KEEP) return;
+    const dropped = lines.slice(0, lines.length - MAX_PENDING_EVENTS_KEEP);
+    for (const line of dropped) {
+      let event;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!event || !event.meshId) continue;
+      const finalSummary = readMeshCompletionSummary(event.metadataEvent || {});
+      if (!readNonEmptyString2(event.coordinatorMessage) && !finalSummary) continue;
+      try {
+        appendLedgerEntry(event.meshId, {
+          kind: "event_held",
+          ...event.nodeId ? { nodeId: event.nodeId } : {},
+          payload: {
+            event: event.event,
+            reason: "pending_trim_dropped",
+            recoverable: true,
+            nodeLabel: event.nodeLabel,
+            ...event.workspace ? { workspace: event.workspace } : {},
+            targetCoordinatorDaemonId: event.targetCoordinatorDaemonId ?? null,
+            queuedAt: event.queuedAt,
+            ...finalSummary ? { finalSummary } : {}
+          }
+        });
+        LOG.warn("MeshEvents", `Pending-events trim dropping undelivered ${event.event} for mesh ${event.meshId} \u2014 recorded to ledger (recoverable)`);
+      } catch (e) {
+        LOG.warn("MeshEvents", `Failed to ledger-record trim-dropped ${event.event} for mesh ${event.meshId}: ${e?.message || e}`);
+      }
+    }
     (0, import_fs10.writeFileSync)(path42, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
   } catch {
   }
@@ -8303,7 +8376,8 @@ function drainPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId, opts) {
         if (event) pushUnique(event);
       }
     }
-  } catch {
+  } catch (e) {
+    LOG.warn("MeshEvents", `SQLite pending-event drain failed for mesh ${meshId}; JSONL fallback only: ${e?.message || e}`);
   }
   const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   for (const path42 of paths) {
@@ -9718,6 +9792,8 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
   if (node?.daemonId && components.dispatchMeshCommand) {
     const isLocalNode = components.cliManager.adapters.has(sessionId);
     if (!isLocalNode) {
+      const localDaemonIdForDispatch = readNonEmptyString2(loadConfig().machineId) || void 0;
+      const sourceCoordinatorSessionId = readNonEmptyString2(task.sourceCoordinatorSessionId) || void 0;
       const delivery2 = createSessionDelivery({
         meshId,
         nodeId,
@@ -9726,9 +9802,10 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
         taskId: task.id,
         kind: "task",
         message: task.message,
-        status: "delivering"
+        status: "delivering",
+        ...sourceCoordinatorSessionId ? { sourceCoordinatorSessionId } : {},
+        ...localDaemonIdForDispatch ? { sourceCoordinatorDaemonId: localDaemonIdForDispatch } : {}
       });
-      const localDaemonIdForDispatch = readNonEmptyString2(loadConfig().machineId) || void 0;
       components.dispatchMeshCommand(node.daemonId, "agent_command", {
         targetSessionId: sessionId,
         cliType: providerType,
@@ -9738,7 +9815,8 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
           meshId,
           nodeId,
           taskId: task.id,
-          ...localDaemonIdForDispatch ? { coordinatorDaemonId: localDaemonIdForDispatch } : {}
+          ...localDaemonIdForDispatch ? { coordinatorDaemonId: localDaemonIdForDispatch } : {},
+          ...sourceCoordinatorSessionId ? { coordinatorSessionId: sourceCoordinatorSessionId } : {}
         }
       }).then(() => {
         updateSessionDeliveryStatus(delivery2.id, "delivered");
@@ -9763,12 +9841,16 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
     const inst = components.instanceManager.getInstance(sessionId);
     if (inst && typeof inst.updateSettings === "function") {
       const localDaemonId = readNonEmptyString2(loadConfig().machineId);
+      const localSourceCoordinatorSessionId = readNonEmptyString2(task.sourceCoordinatorSessionId);
       inst.updateSettings({
         meshNodeFor: meshId,
         meshNodeId: nodeId,
         launchedByCoordinator: true,
         autoApprove: resolveDelegatedWorkerAutoApprove(mesh?.policy, node?.policy),
-        ...localDaemonId ? { meshCoordinatorDaemonId: localDaemonId } : {}
+        ...localDaemonId ? { meshCoordinatorDaemonId: localDaemonId } : {},
+        // (3) Stamp the originating coordinator session for session-anchored routing
+        // of this co-located worker's completion. Absent → daemon-level fallback.
+        ...localSourceCoordinatorSessionId ? { meshCoordinatorSessionId: localSourceCoordinatorSessionId } : {}
       });
     }
   } catch {
@@ -9781,7 +9863,9 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
     taskId: task.id,
     kind: "task",
     message: task.message,
-    status: "delivering"
+    status: "delivering",
+    ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { sourceCoordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {},
+    ...readNonEmptyString2(loadConfig().machineId) ? { sourceCoordinatorDaemonId: readNonEmptyString2(loadConfig().machineId) } : {}
   });
   components.cliManager.handleCliCommand("agent_command", {
     targetSessionId: sessionId,
@@ -10431,6 +10515,9 @@ function injectMeshSystemMessage(components, args) {
   const workerCoordinatorDaemonId = readNonEmptyString2(
     sourceSession?.getState()?.settings?.meshCoordinatorDaemonId
   );
+  const workerCoordinatorSessionId = readNonEmptyString2(
+    sourceSession?.getState()?.settings?.meshCoordinatorSessionId
+  ) || readNonEmptyString2(args.metadataEvent.meshCoordinatorSessionId);
   if (components.onMeshCoordinatorEventForwarded) {
     try {
       const surfacedPreview = resolveMeshSurfacedSessionPreview(args.metadataEvent);
@@ -10811,7 +10898,12 @@ function injectMeshSystemMessage(components, args) {
     workspace: readNonEmptyString2(args.metadataEvent.workspace) || readNonEmptyString2(args.metadataEvent.workspaceName),
     metadataEvent: {
       ...args.metadataEvent,
-      ...recoveryContext ? { recoveryContext } : {}
+      ...recoveryContext ? { recoveryContext } : {},
+      // Stash the coordinator session id INSIDE metadataEvent too, so it survives the
+      // P2P relay serialization (buildForwardPayloadFromPending spreads metadata; the
+      // handleMeshForwardEvent whitelist reads it back) — a top-level field alone would
+      // be dropped when the event crosses a machine boundary.
+      ...workerCoordinatorSessionId ? { meshCoordinatorSessionId: workerCoordinatorSessionId } : {}
     },
     // Silent lifecycle events (agent:ready / agent:generating_started) carry no
     // coordinator message; they are queued only so the coordinator re-runs the
@@ -10819,10 +10911,13 @@ function injectMeshSystemMessage(components, args) {
     // entries without a coordinatorMessage, so a live CLI coordinator is not spammed.
     ...messageText ? { coordinatorMessage: messageText } : {},
     queuedAt: Date.now(),
-    ...workerCoordinatorDaemonId ? { targetCoordinatorDaemonId: workerCoordinatorDaemonId } : {}
+    ...workerCoordinatorDaemonId ? { targetCoordinatorDaemonId: workerCoordinatorDaemonId } : {},
+    // Top-level session anchor for the local PHASE 2 strict-match on the coordinator
+    // daemon. Absent → daemon-level broadcast (legacy / single-coordinator path).
+    ...workerCoordinatorSessionId ? { targetCoordinatorSessionId: workerCoordinatorSessionId } : {}
   };
   if (queuePendingMeshCoordinatorEvent(pendingEvent)) {
-    LOG.info("MeshEvents", `Queued ${args.event} for coordinator (mesh ${args.meshId}${workerCoordinatorDaemonId ? `, coordinator daemon ${workerCoordinatorDaemonId}` : ""})`);
+    LOG.info("MeshEvents", `Queued ${args.event} for coordinator (mesh ${args.meshId}${workerCoordinatorDaemonId ? `, coordinator daemon ${workerCoordinatorDaemonId}` : ""}${workerCoordinatorSessionId ? `, coordinator session ${workerCoordinatorSessionId}` : ""})`);
   }
   return { success: true, forwarded: 0 };
 }
@@ -10847,6 +10942,13 @@ function handleMeshForwardEvent(components, payload) {
       targetSessionId: readNonEmptyString2(payload.targetSessionId) || readNonEmptyString2(payload.sessionId) || readNonEmptyString2(payload.instanceId),
       providerType: readNonEmptyString2(payload.providerType),
       providerSessionId: readNonEmptyString2(payload.providerSessionId),
+      // Preserve the originating coordinator SESSION id across the machine boundary so
+      // the completion routes back to the exact coordinator session (multi-coordinator).
+      // buildForwardPayloadFromPending spreads the worker event's metadata, so the id
+      // arrives as payload.meshCoordinatorSessionId; the top-level targetCoordinatorSessionId
+      // is also accepted as a fallback. injectMeshSystemMessage re-derives the routing
+      // anchors from this. Absent → daemon-level fallback (version-skew safe).
+      meshCoordinatorSessionId: readNonEmptyString2(payload.meshCoordinatorSessionId) || readNonEmptyString2(payload.targetCoordinatorSessionId),
       // Carry the session identity fields the worker provider event emits so the
       // coordinator's mirror (updateMeshOwnedSession) gets a real workspace/title/
       // settings. Without these the remote-relay hop reconstructs metadataEvent with
@@ -11743,7 +11845,8 @@ function findLiveCoordinators(components) {
     if (!meshId) continue;
     const status = readNonEmptyString2(state.status).toLowerCase();
     const modalParked = status === "waiting_choice" || status === "waiting_approval";
-    out.push({ meshId, instance: inst, idle: status === "idle", modalParked });
+    const sessionId = readNonEmptyString2(state.instanceId);
+    out.push({ meshId, instance: inst, sessionId, idle: status === "idle", modalParked });
   }
   return out;
 }
@@ -11755,6 +11858,44 @@ function injectPendingIntoCoordinator(coordinator, pending) {
     ...force ? { force: true } : {}
   });
 }
+function recordHeldTerminalEventsToLedger(meshId, drainDaemonIds, reason, heldForCoordinatorCount) {
+  let pending;
+  try {
+    pending = getPendingMeshCoordinatorEvents(meshId, drainDaemonIds.length > 0 ? drainDaemonIds : void 0);
+  } catch {
+    return;
+  }
+  for (const event of pending) {
+    if (!shouldForceInjectMeshEvent(event.event)) continue;
+    const fingerprint = buildPendingEventFingerprint(event);
+    const key = `${meshId}::${fingerprint || `${event.event}::${event.nodeId || ""}::${event.queuedAt}`}`;
+    if (heldEventLedgerRecorded.has(key)) continue;
+    heldEventLedgerRecorded.add(key);
+    const finalSummary = readMeshCompletionSummary(event.metadataEvent);
+    try {
+      appendLedgerEntry(meshId, {
+        kind: "event_held",
+        ...event.nodeId ? { nodeId: event.nodeId } : {},
+        payload: {
+          event: event.event,
+          reason,
+          recoverable: true,
+          heldForCoordinators: heldForCoordinatorCount,
+          nodeLabel: event.nodeLabel,
+          ...event.workspace ? { workspace: event.workspace } : {},
+          targetCoordinatorDaemonId: event.targetCoordinatorDaemonId ?? null,
+          queuedAt: event.queuedAt,
+          ...fingerprint ? { fingerprint } : {},
+          ...finalSummary ? { finalSummary } : {}
+        }
+      });
+      LOG.info("MeshReconcile", `Ledger-recorded held ${event.event} for mesh ${meshId} (reason ${reason}) \u2014 recoverable from ledger`);
+    } catch (e) {
+      heldEventLedgerRecorded.delete(key);
+      LOG.warn("MeshReconcile", `Failed to ledger-record held ${event.event} for mesh ${meshId}: ${e?.message || e}`);
+    }
+  }
+}
 async function runMeshReconcileTick(components) {
   const localDaemonId = readNonEmptyString2(loadConfig().machineId) || void 0;
   const drainDaemonIds = resolveCoordinatorDaemonIds(components);
@@ -11839,6 +11980,21 @@ async function runMeshReconcileTick(components) {
     if (targetCoordinators.length === 0) {
       if (modalParkedCoordinators.length > 0) {
         LOG.info("MeshReconcile", `Reconcile skip \u2192 modal-parked: holding pending event(s) for mesh ${meshId} (${modalParkedCoordinators.length} coordinator(s) awaiting a modal answer; events left queued)`);
+        let hasPending = true;
+        if (store) {
+          try {
+            hasPending = store.pendingEventCount(meshId) > 0;
+          } catch {
+          }
+        }
+        if (hasPending) {
+          recordHeldTerminalEventsToLedger(
+            meshId,
+            drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId ? [localDaemonId] : [],
+            "modal_parked",
+            modalParkedCoordinators.length
+          );
+        }
       }
       continue;
     }
@@ -11863,12 +12019,55 @@ async function runMeshReconcileTick(components) {
     const mode = forceOnly ? "force-drain \u2192 generating" : "inject \u2192 idle";
     LOG.info("MeshReconcile", `Reconcile ${mode}: ${pendingEvents.length} pending event(s) \u2192 ${targetCoordinators.length} coordinator(s) for mesh ${meshId}`);
     for (const pending of pendingEvents) {
+      const wantSession = readNonEmptyString2(pending.targetCoordinatorSessionId);
+      if (wantSession) {
+        const matched = targetCoordinators.filter((c) => c.sessionId === wantSession);
+        if (matched.length === 0) {
+          holdOrExpireStrictUnmatchedEvent(pending, wantSession, meshId);
+          continue;
+        }
+        for (const c of matched) injectPendingIntoCoordinator(c.instance, pending);
+        continue;
+      }
       for (const c of targetCoordinators) {
         injectPendingIntoCoordinator(c.instance, pending);
       }
     }
   }
 }
+function holdOrExpireStrictUnmatchedEvent(pending, wantSession, meshId) {
+  const queuedAt = typeof pending.queuedAt === "number" ? pending.queuedAt : Date.now();
+  if (Date.now() - queuedAt <= STRICT_SESSION_MATCH_TTL_MS) {
+    try {
+      queuePendingMeshCoordinatorEvent(pending);
+      LOG.info("MeshReconcile", `Strict route hold: coordinator session ${wantSession} not live on mesh ${meshId} \u2014 re-queued (${pending.event})`);
+    } catch (e) {
+      LOG.warn("MeshReconcile", `Strict route re-queue failed for ${pending.event} on mesh ${meshId}: ${e?.message || e}`);
+    }
+    return;
+  }
+  const finalSummary = readMeshCompletionSummary(pending.metadataEvent || {});
+  try {
+    appendLedgerEntry(meshId, {
+      kind: "event_held",
+      ...pending.nodeId ? { nodeId: pending.nodeId } : {},
+      payload: {
+        event: pending.event,
+        reason: "strict_route_expired",
+        recoverable: true,
+        targetCoordinatorSessionId: wantSession,
+        targetCoordinatorDaemonId: pending.targetCoordinatorDaemonId ?? null,
+        nodeLabel: pending.nodeLabel,
+        ...pending.workspace ? { workspace: pending.workspace } : {},
+        queuedAt,
+        ...finalSummary ? { finalSummary } : {}
+      }
+    });
+    LOG.warn("MeshReconcile", `Strict route expire: coordinator session ${wantSession} never returned for mesh ${meshId} \u2014 recorded to ledger (recoverable), dropped (${pending.event})`);
+  } catch (e) {
+    LOG.warn("MeshReconcile", `Failed to ledger-expire strict-unmatched ${pending.event} for mesh ${meshId}: ${e?.message || e}`);
+  }
+}
 async function retryUnresolvedDelegateForwards(components) {
   const dispatchMeshCommand = components.dispatchMeshCommand;
   if (!dispatchMeshCommand) return;
@@ -12086,6 +12285,11 @@ function buildForwardPayloadFromPending(event) {
     meshId: readNonEmptyString2(event?.meshId),
     nodeId: readNonEmptyString2(event?.nodeId) || readNonEmptyString2(metadata.meshNodeId),
     workspace: readNonEmptyString2(event?.workspace) || readNonEmptyString2(metadata.workspace),
+    // Preserve the originating coordinator session id across the relay. It is normally
+    // carried inside metadataEvent.meshCoordinatorSessionId (spread below), but pass the
+    // top-level field through explicitly too so the handleMeshForwardEvent whitelist
+    // recovers it regardless of which carrier the producing daemon used.
+    ...readNonEmptyString2(event?.targetCoordinatorSessionId) ? { targetCoordinatorSessionId: readNonEmptyString2(event.targetCoordinatorSessionId) } : {},
     ...metadata
   };
 }
@@ -12108,7 +12312,7 @@ function setupMeshReconcileLoop(components) {
     }
   };
 }
-var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS;
+var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, heldEventLedgerRecorded, STRICT_SESSION_MATCH_TTL_MS;
 var init_mesh_reconcile_loop = __esm({
   "src/mesh/mesh-reconcile-loop.ts"() {
     "use strict";
@@ -12116,6 +12320,7 @@ var init_mesh_reconcile_loop = __esm({
     init_mesh_config();
     init_logger();
     init_mesh_events_pending();
+    init_mesh_ledger();
     init_mesh_runtime_store();
     init_mesh_events_coordinator();
     init_mesh_unresolved_forward_outbox();
@@ -12127,6 +12332,8 @@ var init_mesh_reconcile_loop = __esm({
     init_chat_message_normalization();
     DEFAULT_RECONCILE_INTERVAL_MS = 4e3;
     DEFAULT_AUTO_PRUNE_MIN_AGE_MS = 24 * 60 * 6e4;
+    heldEventLedgerRecorded = /* @__PURE__ */ new Set();
+    STRICT_SESSION_MATCH_TTL_MS = 6e4;
   }
 });
 
@@ -35059,7 +35266,10 @@ var CliProviderInstance = class _CliProviderInstance {
       meshNodeFor: assignment.meshId,
       ...assignment.nodeId ? { meshNodeId: assignment.nodeId } : {},
       ...assignment.taskId ? { meshActiveTaskId: assignment.taskId } : {},
-      ...assignment.coordinatorDaemonId ? { meshCoordinatorDaemonId: assignment.coordinatorDaemonId } : {}
+      ...assignment.coordinatorDaemonId ? { meshCoordinatorDaemonId: assignment.coordinatorDaemonId } : {},
+      // Session-level routing anchor: the originating coordinator session, so this
+      // worker's completion events route back to the exact session that dispatched it.
+      ...assignment.coordinatorSessionId ? { meshCoordinatorSessionId: assignment.coordinatorSessionId } : {}
     };
     this.adapter.updateRuntimeSettings?.(this.settings);
   }
@@ -38043,6 +38253,12 @@ Enable and detect this provider from the Machine Providers page before starting
       );
     }
     const key = crypto5.randomUUID();
+    {
+      const coordinatorMeshId = options?.settingsOverride?.meshCoordinatorFor;
+      if (typeof coordinatorMeshId === "string" && coordinatorMeshId.trim()) {
+        options = { ...options, extraEnv: { ...options?.extraEnv || {}, ADHDEV_COORDINATOR_SESSION_ID: key } };
+      }
+    }
     const sessionRegistry = this.deps.getSessionRegistry?.() || null;
     if (provider && provider.category === "acp") {
       const instanceManager2 = this.deps.getInstanceManager();
@@ -44457,6 +44673,40 @@ function readCachedInlineMeshActiveSessions(node) {
   const sessionId = readStringValue(fallbackSession.id, fallbackSession.sessionId, fallbackSession.session_id, node?.activeSessionId, node?.active_session_id, node?.sessionId, node?.session_id);
   return sessionId ? [sessionId] : [];
 }
+function collectMeshNodeHostedSessionIds(node) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const id of readCachedInlineMeshActiveSessions(node)) ids.add(id);
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  for (const value of [
+    node?.activeSessions,
+    node?.active_sessions,
+    node?.activeSessionDetails,
+    node?.active_session_details,
+    node?.sessions,
+    node?.sessionDetails,
+    node?.session_details,
+    readObjectRecord(node?.lastProbe).sessions,
+    readObjectRecord(node?.last_probe).sessions,
+    cachedStatus.activeSessions,
+    cachedStatus.active_sessions,
+    cachedStatus.activeSessionDetails,
+    cachedStatus.active_session_details,
+    cachedStatus.sessions
+  ]) {
+    if (!Array.isArray(value)) continue;
+    for (const item of value) {
+      if (typeof item === "string") {
+        const id2 = readStringValue(item);
+        if (id2) ids.add(id2);
+        continue;
+      }
+      const record = readObjectRecord(item);
+      const id = readStringValue(record.id, record.sessionId, record.session_id, record.runtimeSessionId, record.instanceId);
+      if (id) ids.add(id);
+    }
+  }
+  return ids;
+}
 function resolveMeshNodeAttribution(node) {
   const record = readObjectRecord(node);
   return {
@@ -46335,25 +46585,47 @@ var DaemonCommandRouter = class {
    * 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 cached inline-mesh nodes for the one whose active session matches 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.
+   * 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.
    */
   resolveRemoteMeshSessionOwnerDaemonId(sessionId) {
     const trimmed = typeof sessionId === "string" ? sessionId.trim() : "";
     if (!trimmed) return void 0;
     const selfDaemonId = this.deps.statusInstanceId;
-    for (const node of this.getCachedInlineMeshNodes()) {
-      const nodeSessions = readCachedInlineMeshActiveSessions(node);
-      if (!nodeSessions.includes(trimmed)) continue;
+    for (const node of this.collectMeshSessionOwnerCandidateNodes()) {
+      if (!collectMeshNodeHostedSessionIds(node).has(trimmed)) continue;
       const nodeDaemonId = readMeshNodeDaemonId(readObjectRecord(node));
-      if (!nodeDaemonId) return void 0;
+      if (!nodeDaemonId) continue;
       if (selfDaemonId && 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;
+  }
   getCachedInlineMesh(meshId, inlineMesh) {
     if (inlineMesh && typeof inlineMesh === "object") {
       return this.warmInlineMeshCache(meshId, inlineMesh);
@@ -48373,7 +48645,10 @@ ${hintLines.join("\n")}` : "",
                   {
                     meshId: dispatchMeshContext.meshId,
                     nodeId: dispatchMeshContext.nodeId,
-                    coordinatorDaemonId: dispatchMeshContext.coordinatorDaemonId
+                    coordinatorDaemonId: dispatchMeshContext.coordinatorDaemonId,
+                    // Session-level anchor: preserved across the P2P dispatch to a
+                    // remote worker so its completion echoes back to the right session.
+                    coordinatorSessionId: dispatchMeshContext.coordinatorSessionId
                   }
                 );
                 if (stamp) inst.updateSettings(stamp);