@adhdev/daemon-standalone 0.9.82-rc.342 → 0.9.82-rc.344

package/dist/index.js

@@ -30036,10 +30036,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "ff8ffda8c3d1a14f846ad4d785e4cab4d111a36b" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "ff8ffda8" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.342" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-21T05:13:50.125Z" : 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 version2 = readInjected(true ? "0.9.82-rc.344" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-21T16:38:22.983Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -32279,6 +32279,314 @@ Follow these recovery rules:
 4. **Always record what happened**: After handling a failure, briefly note the outcome in your report to the user.`;
       }
     });
+    var fs32;
+    var AsyncBatchWriter;
+    var init_async_batch_writer = __esm2({
+      "src/logging/async-batch-writer.ts"() {
+        "use strict";
+        fs32 = __toESM2(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 fs32.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);
+                }
+              });
+            }
+          }
+        };
+      }
+    });
+    var logger_exports = {};
+    __export2(logger_exports, {
+      LOG: () => LOG2,
+      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(date5 = /* @__PURE__ */ new Date()) {
+      return path9.join(LOG_DIR, `daemon-${date5.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 file2 of files) {
+          const dateMatch = file2.match(/daemon-(\d{4}-\d{2}-\d{2})/);
+          if (dateMatch && dateMatch[1] < cutoffStr) {
+            try {
+              fs4.unlinkSync(path9.join(LOG_DIR, file2));
+            } 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;
+    var path9;
+    var os32;
+    var LEVEL_NUM;
+    var LEVEL_LABEL;
+    var currentLevel;
+    var LOG_DIR;
+    var MAX_LOG_SIZE;
+    var MAX_LOG_DAYS;
+    var currentDate;
+    var currentLogFile;
+    var writeCount;
+    var RING_BUFFER_SIZE;
+    var ringBuffer;
+    var origConsoleLog;
+    var origConsoleError;
+    var origConsoleWarn;
+    var LOG2;
+    var interceptorInstalled;
+    var LOG_PATH;
+    var LOG_DIR_PATH;
+    var init_logger = __esm2({
+      "src/logging/logger.ts"() {
+        "use strict";
+        fs4 = __toESM2(require("fs"));
+        path9 = __toESM2(require("path"));
+        os32 = __toESM2(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(os32.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path9.join(os32.homedir(), "Library", "Logs", "adhdev") : path9.join(os32.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);
+        LOG2 = {
+          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;
+      }
+    });
     function loadBetterSqlite3() {
       if (cached22) return cached22;
       const errors = [];
@@ -33012,314 +33320,6 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         ledgerImportDone = /* @__PURE__ */ new Set();
       }
     });
-    var fs32;
-    var AsyncBatchWriter;
-    var init_async_batch_writer = __esm2({
-      "src/logging/async-batch-writer.ts"() {
-        "use strict";
-        fs32 = __toESM2(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 fs32.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);
-                }
-              });
-            }
-          }
-        };
-      }
-    });
-    var logger_exports = {};
-    __export2(logger_exports, {
-      LOG: () => LOG2,
-      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(date5 = /* @__PURE__ */ new Date()) {
-      return path9.join(LOG_DIR, `daemon-${date5.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 file2 of files) {
-          const dateMatch = file2.match(/daemon-(\d{4}-\d{2}-\d{2})/);
-          if (dateMatch && dateMatch[1] < cutoffStr) {
-            try {
-              fs4.unlinkSync(path9.join(LOG_DIR, file2));
-            } 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;
-    var path9;
-    var os32;
-    var LEVEL_NUM;
-    var LEVEL_LABEL;
-    var currentLevel;
-    var LOG_DIR;
-    var MAX_LOG_SIZE;
-    var MAX_LOG_DAYS;
-    var currentDate;
-    var currentLogFile;
-    var writeCount;
-    var RING_BUFFER_SIZE;
-    var ringBuffer;
-    var origConsoleLog;
-    var origConsoleError;
-    var origConsoleWarn;
-    var LOG2;
-    var interceptorInstalled;
-    var LOG_PATH;
-    var LOG_DIR_PATH;
-    var init_logger = __esm2({
-      "src/logging/logger.ts"() {
-        "use strict";
-        fs4 = __toESM2(require("fs"));
-        path9 = __toESM2(require("path"));
-        os32 = __toESM2(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(os32.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path9.join(os32.homedir(), "Library", "Logs", "adhdev") : path9.join(os32.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);
-        LOG2 = {
-          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;
-      }
-    });
     var mesh_work_queue_exports = {};
     __export2(mesh_work_queue_exports, {
       ACTIVE_MESH_QUEUE_STATUSES: () => ACTIVE_MESH_QUEUE_STATUSES,
@@ -33635,6 +33635,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           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()
         };
@@ -33992,22 +33993,33 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
             (0, import_fs5.renameSync)(legacyCompanion, `${nextPath}${suffix}`);
           }
         }
-      } catch {
+      } catch (err) {
+        if (!loggedMigrationFailure) {
+          loggedMigrationFailure = true;
+          LOG2.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;
     var import_path5;
     var DatabaseCtor;
+    var loggedMigrationFailure;
     var MeshRuntimeStore;
     var init_mesh_runtime_store = __esm2({
       "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;
@@ -34029,9 +34041,21 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
             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;
+                  LOG2.warn(
+                    "MeshRuntimeStore",
+                    `getInstance failed; callers will degrade to JSONL-only: ${err?.message || err}`
+                  );
+                }
+                throw err;
+              }
             }
             return this.instance;
           }
@@ -37622,7 +37646,11 @@ ${rendered}`, "utf-8");
       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;
@@ -37639,10 +37667,13 @@ ${rendered}`, "utf-8");
     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;
@@ -37680,7 +37711,18 @@ ${rendered}`, "utf-8");
         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") {
@@ -37789,10 +37831,12 @@ Next step: ${nextStep}`;
       return "";
     }
     var MESH_SURFACED_PREVIEW_MAX_CHARS;
+    var MESH_COMPLETION_SURFACE_MAX_CHARS;
     var init_mesh_events_utils = __esm2({
       "src/mesh/mesh-events-utils.ts"() {
         "use strict";
         MESH_SURFACED_PREVIEW_MAX_CHARS = 512;
+        MESH_COMPLETION_SURFACE_MAX_CHARS = 4e3;
       }
     });
     function normalizeCoordinatorDaemonIds(coordinatorDaemonId) {
@@ -37948,6 +37992,37 @@ Next step: ${nextStep}`;
         if ((0, import_fs10.statSync)(path422).size <= MAX_PENDING_EVENTS_BYTES) return;
         const lines = (0, import_fs10.readFileSync)(path422, "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 } : {}
+              }
+            });
+            LOG2.warn("MeshEvents", `Pending-events trim dropping undelivered ${event.event} for mesh ${event.meshId} \u2014 recorded to ledger (recoverable)`);
+          } catch (e) {
+            LOG2.warn("MeshEvents", `Failed to ledger-record trim-dropped ${event.event} for mesh ${event.meshId}: ${e?.message || e}`);
+          }
+        }
         (0, import_fs10.writeFileSync)(path422, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
       } catch {
       }
@@ -38077,7 +38152,8 @@ Next step: ${nextStep}`;
             if (event) pushUnique(event);
           }
         }
-      } catch {
+      } catch (e) {
+        LOG2.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 path422 of paths) {
@@ -39494,6 +39570,8 @@ Next step: ${nextStep}`;
       if (node?.daemonId && components.dispatchMeshCommand) {
         const isLocalNode = components.cliManager.adapters.has(sessionId);
         if (!isLocalNode) {
+          const localDaemonIdForDispatch = readNonEmptyString2(loadConfig2().machineId) || void 0;
+          const sourceCoordinatorSessionId = readNonEmptyString2(task.sourceCoordinatorSessionId) || void 0;
           const delivery2 = createSessionDelivery({
             meshId,
             nodeId,
@@ -39502,9 +39580,10 @@ Next step: ${nextStep}`;
             taskId: task.id,
             kind: "task",
             message: task.message,
-            status: "delivering"
+            status: "delivering",
+            ...sourceCoordinatorSessionId ? { sourceCoordinatorSessionId } : {},
+            ...localDaemonIdForDispatch ? { sourceCoordinatorDaemonId: localDaemonIdForDispatch } : {}
           });
-          const localDaemonIdForDispatch = readNonEmptyString2(loadConfig2().machineId) || void 0;
           components.dispatchMeshCommand(node.daemonId, "agent_command", {
             targetSessionId: sessionId,
             cliType: providerType,
@@ -39514,7 +39593,8 @@ Next step: ${nextStep}`;
               meshId,
               nodeId,
               taskId: task.id,
-              ...localDaemonIdForDispatch ? { coordinatorDaemonId: localDaemonIdForDispatch } : {}
+              ...localDaemonIdForDispatch ? { coordinatorDaemonId: localDaemonIdForDispatch } : {},
+              ...sourceCoordinatorSessionId ? { coordinatorSessionId: sourceCoordinatorSessionId } : {}
             }
           }).then(() => {
             updateSessionDeliveryStatus(delivery2.id, "delivered");
@@ -39539,12 +39619,16 @@ Next step: ${nextStep}`;
         const inst = components.instanceManager.getInstance(sessionId);
         if (inst && typeof inst.updateSettings === "function") {
           const localDaemonId = readNonEmptyString2(loadConfig2().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 {
@@ -39557,7 +39641,9 @@ Next step: ${nextStep}`;
         taskId: task.id,
         kind: "task",
         message: task.message,
-        status: "delivering"
+        status: "delivering",
+        ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { sourceCoordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {},
+        ...readNonEmptyString2(loadConfig2().machineId) ? { sourceCoordinatorDaemonId: readNonEmptyString2(loadConfig2().machineId) } : {}
       });
       components.cliManager.handleCliCommand("agent_command", {
         targetSessionId: sessionId,
@@ -39569,7 +39655,16 @@ Next step: ${nextStep}`;
       }).catch((e) => {
         LOG2.error("MeshQueue", `Failed to dispatch task locally to node ${nodeId}: ${e?.message}`);
         updateSessionDeliveryStatus(delivery.id, "failed", { lastError: e?.message, incrementAttempt: true });
-        updateTaskStatus(meshId, task.id, "failed");
+        updateTaskStatus(meshId, task.id, "pending");
+        try {
+          appendLedgerEntry(meshId, {
+            kind: "dispatch_failed",
+            nodeId,
+            sessionId,
+            payload: { taskId: task.id, deliveryId: delivery.id, error: e?.message, retryable: true }
+          });
+        } catch {
+        }
       });
       return true;
     }
@@ -40198,6 +40293,9 @@ Next step: ${nextStep}`;
       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);
@@ -40578,7 +40676,12 @@ Next step: ${nextStep}`;
         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
@@ -40586,10 +40689,13 @@ Next step: ${nextStep}`;
         // 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)) {
-        LOG2.info("MeshEvents", `Queued ${args.event} for coordinator (mesh ${args.meshId}${workerCoordinatorDaemonId ? `, coordinator daemon ${workerCoordinatorDaemonId}` : ""})`);
+        LOG2.info("MeshEvents", `Queued ${args.event} for coordinator (mesh ${args.meshId}${workerCoordinatorDaemonId ? `, coordinator daemon ${workerCoordinatorDaemonId}` : ""}${workerCoordinatorSessionId ? `, coordinator session ${workerCoordinatorSessionId}` : ""})`);
       }
       return { success: true, forwarded: 0 };
     }
@@ -40614,6 +40720,13 @@ Next step: ${nextStep}`;
           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
@@ -41532,7 +41645,8 @@ Next step: ${nextStep}`;
         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;
     }
@@ -41544,6 +41658,44 @@ Next step: ${nextStep}`;
         ...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 } : {}
+            }
+          });
+          LOG2.info("MeshReconcile", `Ledger-recorded held ${event.event} for mesh ${meshId} (reason ${reason}) \u2014 recoverable from ledger`);
+        } catch (e) {
+          heldEventLedgerRecorded.delete(key);
+          LOG2.warn("MeshReconcile", `Failed to ledger-record held ${event.event} for mesh ${meshId}: ${e?.message || e}`);
+        }
+      }
+    }
     async function runMeshReconcileTick(components) {
       const localDaemonId = readNonEmptyString2(loadConfig2().machineId) || void 0;
       const drainDaemonIds = resolveCoordinatorDaemonIds(components);
@@ -41628,6 +41780,21 @@ Next step: ${nextStep}`;
         if (targetCoordinators.length === 0) {
           if (modalParkedCoordinators.length > 0) {
             LOG2.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;
         }
@@ -41652,12 +41819,55 @@ Next step: ${nextStep}`;
         const mode = forceOnly ? "force-drain \u2192 generating" : "inject \u2192 idle";
         LOG2.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);
+          LOG2.info("MeshReconcile", `Strict route hold: coordinator session ${wantSession} not live on mesh ${meshId} \u2014 re-queued (${pending.event})`);
+        } catch (e) {
+          LOG2.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 } : {}
+          }
+        });
+        LOG2.warn("MeshReconcile", `Strict route expire: coordinator session ${wantSession} never returned for mesh ${meshId} \u2014 recorded to ledger (recoverable), dropped (${pending.event})`);
+      } catch (e) {
+        LOG2.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;
@@ -41875,6 +42085,11 @@ Next step: ${nextStep}`;
         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
       };
     }
@@ -41899,6 +42114,8 @@ Next step: ${nextStep}`;
     }
     var DEFAULT_RECONCILE_INTERVAL_MS;
     var DEFAULT_AUTO_PRUNE_MIN_AGE_MS;
+    var heldEventLedgerRecorded;
+    var STRICT_SESSION_MATCH_TTL_MS;
     var init_mesh_reconcile_loop = __esm2({
       "src/mesh/mesh-reconcile-loop.ts"() {
         "use strict";
@@ -41906,6 +42123,7 @@ Next step: ${nextStep}`;
         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();
@@ -41917,6 +42135,8 @@ Next step: ${nextStep}`;
         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;
       }
     });
     var mesh_events_exports = {};
@@ -61621,7 +61841,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       return n;
     }
     var SUBMIT_DELAY_FLOOR_MS = 200;
-    var WIN32_SUBMIT_REPEAT_GAP_MS = 300;
+    var WIN32_SUBMIT_RESEND_GAP_MS = 350;
+    var WIN32_SUBMIT_MAX_RESENDS = 14;
     function resolveSubmitDelayMs(specBeforeSubmit, text) {
       const lines = countNewlines(text);
       const linesBonus = Math.min(800, lines * 80);
@@ -61673,6 +61894,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
        *  after a re-prime we don't re-inject until the screen changes (which
        *  resets the stall reference) or another full stall window lapses. */
       lastRefocusAt = 0;
+      /** Timer driving the win32 verification-based submit resend loop (see
+       *  WIN32_SUBMIT_* and scheduleWin32Submit). Re-arms itself until the FSM
+       *  leaves idle (submitted) or the resend budget is spent. */
+      win32SubmitTimer = null;
       currentEval = null;
       stateHistory = [];
       prevStateAt = 0;
@@ -61789,6 +62014,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           clearTimeout(this.stallTimer);
           this.stallTimer = null;
         }
+        if (this.win32SubmitTimer) {
+          clearTimeout(this.win32SubmitTimer);
+          this.win32SubmitTimer = null;
+        }
         this.specWatcher?.close();
         this.adapter.kill();
       }
@@ -62201,13 +62430,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         const perChar = sm.delay_ms_per_char ?? 0;
         const beforeSubmit = resolveSubmitDelayMs(sm.delay_ms_before_submit, text);
         if (process.platform === "win32") {
-          const submitTwice = () => {
-            this.adapter.send_keys(sm.submit_key);
-            setTimeout(() => this.adapter.send_keys(sm.submit_key), WIN32_SUBMIT_REPEAT_GAP_MS);
-          };
           this.adapter.send_keys(text);
-          if (beforeSubmit > 0) setTimeout(submitTwice, beforeSubmit);
-          else submitTwice();
+          this.scheduleWin32Submit(sm.submit_key, beforeSubmit);
           return;
         }
         if (perChar === 0) {
@@ -62227,6 +62451,40 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           i += 1;
         }, perChar);
       }
+      /** The agent's current coarse status, derived from the FSM node we're in. */
+      currentStatus() {
+        const st = stateById(this.spec, this.currentStateId);
+        return st ? statusForState(st) : "idle";
+      }
+      /**
+       * win32 verification-based submit. Sends the submit key, waits a gap, and if
+       * the FSM is still 'idle' (the prompt did not submit — the CR was absorbed as
+       * a multiline-paste newline) resends, up to WIN32_SUBMIT_MAX_RESENDS. The
+       * first CR always fires (so a stale/edge status never suppresses the submit);
+       * subsequent resends are gated on still being idle, and stop the instant the
+       * agent leaves idle (submitted → generating / approval). This converges the
+       * nondeterministic multiline window without spamming Enter into the next turn.
+       */
+      scheduleWin32Submit(submitKey, initialDelayMs) {
+        if (this.win32SubmitTimer) {
+          clearTimeout(this.win32SubmitTimer);
+          this.win32SubmitTimer = null;
+        }
+        const fire = (attempt) => {
+          this.win32SubmitTimer = null;
+          this.adapter.send_keys(submitKey);
+          if (attempt + 1 >= WIN32_SUBMIT_MAX_RESENDS) return;
+          this.win32SubmitTimer = setTimeout(() => {
+            if (this.currentStatus() !== "idle") {
+              this.win32SubmitTimer = null;
+              return;
+            }
+            fire(attempt + 1);
+          }, WIN32_SUBMIT_RESEND_GAP_MS);
+        };
+        if (initialDelayMs > 0) this.win32SubmitTimer = setTimeout(() => fire(0), initialDelayMs);
+        else fire(0);
+      }
       handleClickControl(controlId, payload) {
         const ctl = (this.spec.control_bar ?? []).find((c) => c.id === controlId);
         if (!ctl) return;
@@ -64634,7 +64892,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           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);
       }
@@ -67610,6 +67871,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();
@@ -73970,6 +74237,40 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       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 record2 = readObjectRecord(item);
+          const id = readStringValue(record2.id, record2.sessionId, record2.session_id, record2.runtimeSessionId, record2.instanceId);
+          if (id) ids.add(id);
+        }
+      }
+      return ids;
+    }
     function resolveMeshNodeAttribution(node) {
       const record2 = readObjectRecord(node);
       return {
@@ -75848,25 +76149,47 @@ ${mergeTreeErr?.stderr || ""}`;
        * 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);
@@ -77886,7 +78209,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);