@adhdev/daemon-core 0.9.82-rc.311 → 0.9.82-rc.312

package/dist/index.js

@@ -316,10 +316,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "3902f3d63eabe7b9e34d0e849dc0fed2fd66c026" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "3902f3d6" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.311" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-17T12:17:11.243Z" : void 0);
+  const commit = readInjected(true ? "35facf0367dbbe37f25a3b5589287dc757ee6213" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "35facf03" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.312" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-17T22:48:50.124Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -2118,6 +2118,7 @@ var init_coordinator_prompt = __esm({
 | \`mesh_read_debug\` | Collect a daemon-side chat/parser debug bundle for a session |
 | \`mesh_task_history\` | Read the task ledger \u2014 dispatches, completions, failures. Use to understand what has been done before deciding next steps |
 | \`mesh_git_status\` | Check git status on a specific node |
+| \`mesh_read_node_logs\` | Fetch a remote node's daemon log tail directly over P2P (grep/since/byte-bounded, secrets redacted) \u2014 no session/PowerShell needed to debug a node's daemon |
 | \`mesh_fast_forward_node\` | Safely dry-run or explicitly execute an obvious clean fast-forward without launching an agent session |
 | \`mesh_checkpoint\` | Create a git checkpoint on a node |
 | \`mesh_approve\` | Approve/reject a pending agent action |
@@ -5825,8 +5826,8 @@ function stripCoordinatorWrapperFile(filePath) {
     const remaining = (existing.slice(0, openIdx) + existing.slice(closeIdx + CLOSE.length)).replace(/^\s*\n+/, "").replace(/\n+\s*$/, "");
     if (!remaining.trim()) {
       try {
-        const fs30 = require("fs");
-        fs30.unlinkSync(filePath);
+        const fs31 = require("fs");
+        fs31.unlinkSync(filePath);
       } catch {
       }
     } else {
@@ -10858,8 +10859,8 @@ var init_pty_transport = __esm({
         let cwd = options.cwd;
         if (cwd) {
           try {
-            const fs30 = require("fs");
-            const stat2 = fs30.statSync(cwd);
+            const fs31 = require("fs");
+            const stat2 = fs31.statSync(cwd);
             if (!stat2.isDirectory()) cwd = os11.homedir();
           } catch {
             cwd = os11.homedir();
@@ -10966,9 +10967,9 @@ function findBinary(name) {
     for (const ext of exes) {
       const fullPath = path17.join(p, trimmed + ext);
       try {
-        const fs30 = require("fs");
-        if (fs30.existsSync(fullPath)) {
-          const stat2 = fs30.statSync(fullPath);
+        const fs31 = require("fs");
+        if (fs31.existsSync(fullPath)) {
+          const stat2 = fs31.statSync(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
           }
@@ -10982,12 +10983,12 @@ function findBinary(name) {
 function isScriptBinary(binaryPath) {
   if (!path17.isAbsolute(binaryPath)) return false;
   try {
-    const fs30 = require("fs");
-    const resolved = fs30.realpathSync(binaryPath);
+    const fs31 = require("fs");
+    const resolved = fs31.realpathSync(binaryPath);
     const head = Buffer.alloc(8);
-    const fd = fs30.openSync(resolved, "r");
-    fs30.readSync(fd, head, 0, 8, 0);
-    fs30.closeSync(fd);
+    const fd = fs31.openSync(resolved, "r");
+    fs31.readSync(fd, head, 0, 8, 0);
+    fs31.closeSync(fd);
     let i = 0;
     if (head[0] === 239 && head[1] === 187 && head[2] === 191) i = 3;
     return head[i] === 35 && head[i + 1] === 33;
@@ -10998,12 +10999,12 @@ function isScriptBinary(binaryPath) {
 function looksLikeMachOOrElf(filePath) {
   if (!path17.isAbsolute(filePath)) return false;
   try {
-    const fs30 = require("fs");
-    const resolved = fs30.realpathSync(filePath);
+    const fs31 = require("fs");
+    const resolved = fs31.realpathSync(filePath);
     const buf = Buffer.alloc(8);
-    const fd = fs30.openSync(resolved, "r");
-    fs30.readSync(fd, buf, 0, 8, 0);
-    fs30.closeSync(fd);
+    const fd = fs31.openSync(resolved, "r");
+    fs31.readSync(fd, buf, 0, 8, 0);
+    fs31.closeSync(fd);
     let i = 0;
     if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
     const b = buf.subarray(i);
@@ -29841,7 +29842,7 @@ var DaemonCommandHandler = class {
       return { success: false, error: "invalid type" };
     }
     const https = require("https");
-    const fs30 = require("fs");
+    const fs31 = require("fs");
     const path41 = require("path");
     const crypto6 = require("crypto");
     const REGISTRY = "https://api.adhf.dev/api/v1/registry";
@@ -29885,7 +29886,7 @@ var DaemonCommandHandler = class {
       if (!targetDir.startsWith(installRootResolved + path41.sep)) {
         return { success: false, error: "install path escaped upstream root" };
       }
-      fs30.mkdirSync(targetDir, { recursive: true });
+      fs31.mkdirSync(targetDir, { recursive: true });
       let manifestProbe = {};
       try {
         manifestProbe = JSON.parse(manifestBody);
@@ -29910,7 +29911,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       }
       const targetFile = isV1 ? "provider.v1.json" : "provider.json";
       const targetPath = path41.join(targetDir, targetFile);
-      fs30.writeFileSync(targetPath, manifestBody, "utf-8");
+      fs31.writeFileSync(targetPath, manifestBody, "utf-8");
       const manifestJson = JSON.parse(manifestBody);
       const scriptFetch = await this.fetchProviderSources(
         manifestJson,
@@ -29980,7 +29981,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     const repo = source.repo;
     const ref = source.ref;
     const https = require("https");
-    const fs30 = require("fs");
+    const fs31 = require("fs");
     const path41 = require("path");
     function fetchJson(url, timeoutMs) {
       return new Promise((resolve24, reject) => {
@@ -30064,8 +30065,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
             const relInside = entry.path.startsWith(sharedDirRel + "/") ? entry.path.slice(sharedDirRel.length + 1) : entry.path;
             const outPath = path41.resolve(path41.join(sharedTargetDir, relInside));
             if (!outPath.startsWith(path41.resolve(sharedTargetDir) + path41.sep)) continue;
-            fs30.mkdirSync(path41.dirname(outPath), { recursive: true });
-            fs30.writeFileSync(outPath, body);
+            fs31.mkdirSync(path41.dirname(outPath), { recursive: true });
+            fs31.writeFileSync(outPath, body);
             fetchedCount++;
           } catch (e) {
             errors.push(`fetch shared ${entry.path}: ${e?.message ?? e}`);
@@ -30103,8 +30104,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
               errors.push(`refusing to write outside targetDir: ${entry.path}`);
               continue;
             }
-            fs30.mkdirSync(path41.dirname(outPath), { recursive: true });
-            fs30.writeFileSync(outPath, body);
+            fs31.mkdirSync(path41.dirname(outPath), { recursive: true });
+            fs31.writeFileSync(outPath, body);
             fetchedCount++;
           } catch (e) {
             errors.push(`fetch ${entry.path}: ${e?.message ?? e}`);
@@ -30132,7 +30133,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     if (!["cli", "ide", "extension", "acp"].includes(category)) {
       return { success: false, error: `unknown category: ${category}` };
     }
-    const fs30 = require("fs");
+    const fs31 = require("fs");
     const path41 = require("path");
     try {
       const installRoot = this.getUpstreamInstallRoot();
@@ -30141,10 +30142,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       if (!targetDir.startsWith(installRootResolved + path41.sep)) {
         return { success: false, error: "refusing to delete outside upstream root" };
       }
-      if (!fs30.existsSync(targetDir)) {
+      if (!fs31.existsSync(targetDir)) {
         return { success: false, error: "not installed" };
       }
-      fs30.rmSync(targetDir, { recursive: true, force: true });
+      fs31.rmSync(targetDir, { recursive: true, force: true });
       if (this._ctx.providerLoader) {
         this._ctx.providerLoader.reload();
         this._ctx.providerLoader.registerToDetector();
@@ -30160,28 +30161,28 @@ ${formatManifestValidationIssues2(validation.issues)}`,
    * the UI and by the update checker.
    */
   handleListInstalledProviders(_args) {
-    const fs30 = require("fs");
+    const fs31 = require("fs");
     const path41 = require("path");
     const installRoot = this.getUpstreamInstallRoot();
-    if (!fs30.existsSync(installRoot)) return { success: true, providers: [] };
+    if (!fs31.existsSync(installRoot)) return { success: true, providers: [] };
     const CATEGORIES = ["cli", "ide", "extension", "acp"];
     const items = [];
     for (const category of CATEGORIES) {
       const categoryDir = path41.join(installRoot, category);
-      if (!fs30.existsSync(categoryDir)) continue;
+      if (!fs31.existsSync(categoryDir)) continue;
       let entries;
       try {
-        entries = fs30.readdirSync(categoryDir);
+        entries = fs31.readdirSync(categoryDir);
       } catch {
         continue;
       }
       for (const type of entries) {
         const v1Path = path41.join(categoryDir, type, "provider.v1.json");
         const v0Path = path41.join(categoryDir, type, "provider.json");
-        const manifestPath = fs30.existsSync(v1Path) ? v1Path : fs30.existsSync(v0Path) ? v0Path : null;
+        const manifestPath = fs31.existsSync(v1Path) ? v1Path : fs31.existsSync(v0Path) ? v0Path : null;
         if (!manifestPath) continue;
         try {
-          const m = JSON.parse(fs30.readFileSync(manifestPath, "utf-8"));
+          const m = JSON.parse(fs31.readFileSync(manifestPath, "utf-8"));
           items.push({
             type,
             category,
@@ -30292,7 +30293,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     if (!/^@[a-z0-9_-]+$/i.test(requestedName)) {
       return { success: false, error: "name must match @[a-z0-9_-]+" };
     }
-    const fs30 = require("fs");
+    const fs31 = require("fs");
     const path41 = require("path");
     const { spawnSync: spawnSync2 } = require("child_process");
     const file = ext.loadExternalSources();
@@ -30303,8 +30304,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       return { success: false, error: `source url+ref already registered (use a different name to track another ref)` };
     }
     const sourceDir = path41.join(ext.externalRoot(), requestedName);
-    if (!fs30.existsSync(ext.externalRoot())) fs30.mkdirSync(ext.externalRoot(), { recursive: true });
-    if (fs30.existsSync(sourceDir)) {
+    if (!fs31.existsSync(ext.externalRoot())) fs31.mkdirSync(ext.externalRoot(), { recursive: true });
+    if (fs31.existsSync(sourceDir)) {
       return { success: false, error: `directory already exists: ${sourceDir} (rename or remove first)` };
     }
     const clone = spawnSync2("git", ["clone", "--depth=1", "--branch", ref, "--", url, sourceDir], {
@@ -30314,7 +30315,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     });
     if (clone.status !== 0) {
       try {
-        fs30.rmSync(sourceDir, { recursive: true, force: true });
+        fs31.rmSync(sourceDir, { recursive: true, force: true });
       } catch {
       }
       return { success: false, error: `git clone failed: ${(clone.stderr || clone.stdout || "").trim() || "unknown error"}` };
@@ -30358,15 +30359,15 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     const name = typeof args?.name === "string" ? args.name.trim() : "";
     if (!name) return { success: false, error: "name is required" };
     const ext = (init_external_sources(), __toCommonJS(external_sources_exports));
-    const fs30 = require("fs");
+    const fs31 = require("fs");
     const path41 = require("path");
     const file = ext.loadExternalSources();
     const match = file.sources.find((s) => s.name === name);
     if (!match) return { success: false, error: `source "${name}" not registered` };
     const sourceDir = path41.join(ext.externalRoot(), name);
-    if (fs30.existsSync(sourceDir)) {
+    if (fs31.existsSync(sourceDir)) {
       try {
-        fs30.rmSync(sourceDir, { recursive: true, force: true });
+        fs31.rmSync(sourceDir, { recursive: true, force: true });
       } catch (e) {
         return { success: false, error: `failed to delete ${sourceDir}: ${e?.message || e}` };
       }
@@ -39478,7 +39479,7 @@ var ProviderLoader = class _ProviderLoader {
     }
     if (providerDir) {
       try {
-        const fs30 = require("fs");
+        const fs31 = require("fs");
         const path41 = require("path");
         const candidates = [];
         if (Array.isArray(base.compatibility)) {
@@ -39490,13 +39491,13 @@ var ProviderLoader = class _ProviderLoader {
         }
         candidates.push(path41.join(providerDir, "specs", "default.json"));
         candidates.push(path41.join(providerDir, "spec.json"));
-        const specPath = candidates.find((p) => fs30.existsSync(p));
+        const specPath = candidates.find((p) => fs31.existsSync(p));
         if (specPath) {
           resolved._resolvedSpecPath = specPath;
           let specControls;
           let nh;
           try {
-            const rawSpec = JSON.parse(fs30.readFileSync(specPath, "utf8"));
+            const rawSpec = JSON.parse(fs31.readFileSync(specPath, "utf8"));
             specControls = rawSpec.control_bar;
             nh = rawSpec.native_history;
           } catch {
@@ -39521,7 +39522,7 @@ var ProviderLoader = class _ProviderLoader {
               reader = (input) => executeNativeHistory(nh, input);
             } else if (nh.override_path) {
               const overrideFile = path41.resolve(providerDir, nh.override_path);
-              if (fs30.existsSync(overrideFile)) {
+              if (fs31.existsSync(overrideFile)) {
                 try {
                   registerProviderScriptRootSafely(path41.dirname(path41.dirname(providerDir)));
                   delete require.cache[require.resolve(overrideFile)];
@@ -40706,7 +40707,7 @@ async function detectCurrentWorkspace(ideId) {
     }
   } else if (plat === "win32") {
     try {
-      const fs30 = require("fs");
+      const fs31 = require("fs");
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
@@ -40715,8 +40716,8 @@ async function detectCurrentWorkspace(ideId) {
           appName,
           "storage.json"
         );
-        if (fs30.existsSync(storagePath)) {
-          const data = JSON.parse(fs30.readFileSync(storagePath, "utf-8"));
+        if (fs31.existsSync(storagePath)) {
+          const data = JSON.parse(fs31.readFileSync(storagePath, "utf-8"));
           const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
           if (workspaces.length > 0) {
             const recent = workspaces[0];
@@ -41048,6 +41049,210 @@ cleanOldFiles();
 // src/commands/router.ts
 var yaml3 = __toESM(require("js-yaml"));
 init_logger();
+
+// src/logging/log-tail-reader.ts
+var fs23 = __toESM(require("fs"));
+init_logger();
+var DEFAULT_TAIL_BYTES = 64 * 1024;
+var MAX_TAIL_BYTES = 128 * 1024;
+var READ_CHUNK_BYTES = 64 * 1024;
+function resolveLogPath(date) {
+  if (date instanceof Date) return getCurrentDaemonLogPath(date);
+  if (typeof date === "string" && date.trim()) {
+    const parsed = /* @__PURE__ */ new Date(`${date.trim()}T00:00:00.000Z`);
+    if (!Number.isNaN(parsed.getTime())) return getCurrentDaemonLogPath(parsed);
+  }
+  return getCurrentDaemonLogPath();
+}
+function clampTailBytes(tailBytes) {
+  if (!Number.isFinite(tailBytes) || tailBytes <= 0) return DEFAULT_TAIL_BYTES;
+  return Math.min(Math.floor(tailBytes), MAX_TAIL_BYTES);
+}
+function readByteBoundedTail(filePath, limitBytes) {
+  const fd = fs23.openSync(filePath, "r");
+  try {
+    const stat2 = fs23.fstatSync(fd);
+    const size = stat2.size;
+    if (size === 0) return { text: "", truncated: false, bytesReturned: 0 };
+    const want = Math.min(limitBytes, size);
+    let start = size - want;
+    const truncated = start > 0;
+    const buffers = [];
+    let position = start;
+    while (position < size) {
+      const chunkSize = Math.min(READ_CHUNK_BYTES, size - position);
+      const chunk = Buffer.alloc(chunkSize);
+      fs23.readSync(fd, chunk, 0, chunkSize, position);
+      buffers.push(chunk);
+      position += chunkSize;
+    }
+    let buf = Buffer.concat(buffers);
+    if (truncated) {
+      const firstNewline = buf.indexOf(10);
+      if (firstNewline >= 0) {
+        buf = buf.subarray(firstNewline + 1);
+      }
+    }
+    return { text: buf.toString("utf-8"), truncated, bytesReturned: buf.length };
+  } finally {
+    fs23.closeSync(fd);
+  }
+}
+function parseLineEpochMs(line, fileDate) {
+  const m = line.match(/^\[(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?\]/);
+  if (!m) {
+    const iso = line.match(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?/);
+    if (iso) {
+      const t = Date.parse(iso[0].replace(" ", "T"));
+      return Number.isNaN(t) ? null : t;
+    }
+    return null;
+  }
+  const d = new Date(fileDate);
+  d.setHours(Number(m[1]), Number(m[2]), Number(m[3]), m[4] ? Number(m[4].padEnd(3, "0")) : 0);
+  return d.getTime();
+}
+function readDaemonLogTail(args = {}) {
+  const platform10 = process.platform;
+  const limitBytes = clampTailBytes(args.tailBytes);
+  let logPath = resolveLogPath(args.date);
+  if (!fs23.existsSync(logPath)) {
+    const backup = logPath.replace(/\.log$/, ".1.log");
+    if (fs23.existsSync(backup)) {
+      logPath = backup;
+    } else {
+      return {
+        success: false,
+        error: `No daemon log file at ${logPath} (dir: ${getDaemonLogDir()})`,
+        lines: [],
+        truncated: false,
+        logPath,
+        platform: platform10,
+        bytesReturned: 0,
+        filtered: false
+      };
+    }
+  }
+  let raw;
+  try {
+    raw = readByteBoundedTail(logPath, limitBytes);
+  } catch (e) {
+    return {
+      success: false,
+      error: `Failed to read ${logPath}: ${e?.message ?? String(e)}`,
+      lines: [],
+      truncated: false,
+      logPath,
+      platform: platform10,
+      bytesReturned: 0,
+      filtered: false
+    };
+  }
+  let lines = raw.text.split("\n");
+  if (lines.length && lines[lines.length - 1] === "") lines.pop();
+  const rawCount = lines.length;
+  if (Number.isFinite(args.sinceMs)) {
+    const fileDate = args.date instanceof Date ? args.date : typeof args.date === "string" && args.date.trim() ? /* @__PURE__ */ new Date(`${args.date.trim()}T00:00:00.000Z`) : /* @__PURE__ */ new Date();
+    const floor = args.sinceMs;
+    lines = lines.filter((line) => {
+      const ts2 = parseLineEpochMs(line, fileDate);
+      return ts2 === null || ts2 >= floor;
+    });
+  }
+  let appliedGrep;
+  if (typeof args.grep === "string" && args.grep.trim()) {
+    appliedGrep = args.grep.trim();
+    let re = null;
+    try {
+      re = new RegExp(appliedGrep, "i");
+    } catch {
+      re = null;
+    }
+    if (re) {
+      const compiled = re;
+      lines = lines.filter((line) => compiled.test(line));
+    } else {
+      const needle = appliedGrep.toLowerCase();
+      lines = lines.filter((line) => line.toLowerCase().includes(needle));
+    }
+  }
+  return {
+    success: true,
+    lines,
+    truncated: raw.truncated,
+    logPath,
+    platform: platform10,
+    bytesReturned: raw.bytesReturned,
+    filtered: lines.length !== rawCount,
+    ...appliedGrep ? { grep: appliedGrep } : {}
+  };
+}
+
+// src/logging/log-redactor.ts
+var MASK = "\u2022\u2022\u2022\u2022redacted";
+function maskKeepTail(token) {
+  if (token.length <= 8) return MASK;
+  return `${MASK}${token.slice(-4)}`;
+}
+var RULES = [
+  // `JWT_SECRET=...`, `TOKEN=...`, `API_KEY=...`, `password: ...` env/config dumps.
+  // Captures the key + delimiter and masks only the value.
+  {
+    name: "key_value_secret",
+    pattern: /\b([A-Z0-9_]*(?:SECRET|TOKEN|API[_-]?KEY|PASSWORD|PASSWD|PRIVATE[_-]?KEY|CREDENTIAL|CLIENT[_-]?SECRET)[A-Z0-9_]*)(\s*[:=]\s*)(["']?)([^\s"',;]+)\3/gi,
+    replace: (_m, key, delim, quote) => `${key}${delim}${quote}${MASK}${quote}`
+  },
+  // Authorization: Bearer <token>
+  {
+    name: "bearer_token",
+    pattern: /\b(Bearer\s+)([A-Za-z0-9._\-+/=]{8,})/g,
+    replace: (_m, prefix, token) => `${prefix}${maskKeepTail(token)}`
+  },
+  // ADHDev credential prefixes: API key (adk_), machine secret (adm_), provider key (adp_).
+  {
+    name: "adhdev_prefixed_secret",
+    pattern: /\b(ad[kmp]_)([A-Za-z0-9]{6,})/g,
+    replace: (_m, prefix, token) => `${prefix}${maskKeepTail(prefix + token)}`
+  },
+  // JWT: three base64url segments separated by dots, header starts with eyJ.
+  {
+    name: "jwt",
+    pattern: /\beyJ[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}/g,
+    replace: () => MASK
+  },
+  // TURN credential: a long credential value following a `credential` key in
+  // any common shape — `credential: x`, `credential=x`, or `credential "x"`.
+  // Mask the credential value only, preserving the key + delimiter/quote.
+  {
+    name: "turn_credential",
+    pattern: /\b(credential["']?\s*(?:[:=]\s*)?["']?)([^\s"',;]{6,})/gi,
+    replace: (_m, prefix) => `${prefix}${MASK}`
+  },
+  // TURN REST username:credential of the form `<expiry-ts>:<base64hmac>`,
+  // where the hmac part is long base64. Mask the hmac.
+  {
+    name: "turn_rest_pair",
+    pattern: /\b(\d{10,}:)([A-Za-z0-9+/]{20,}={0,2})\b/g,
+    replace: (_m, prefix) => `${prefix}${MASK}`
+  }
+];
+function redactLogLine(line) {
+  if (!line) return line;
+  let out = line;
+  for (const rule of RULES) {
+    try {
+      out = out.replace(rule.pattern, rule.replace);
+    } catch {
+    }
+  }
+  return out;
+}
+function redactLogLines(lines) {
+  return lines.map((line) => redactLogLine(line));
+}
+var LOG_REDACTION_RULE_NAMES = RULES.map((r) => r.name);
+
+// src/commands/router.ts
 init_mesh_coordinator();
 init_mesh_events();
 init_mesh_routing();
@@ -41692,21 +41897,21 @@ init_build_info();
 // src/commands/upgrade-helper.ts
 var import_child_process8 = require("child_process");
 var import_child_process9 = require("child_process");
-var fs23 = __toESM(require("fs"));
+var fs24 = __toESM(require("fs"));
 var os27 = __toESM(require("os"));
 var path35 = __toESM(require("path"));
 var UPGRADE_HELPER_ENV = "ADHDEV_DAEMON_UPGRADE_HELPER";
 function getUpgradeLogPath() {
   const home = os27.homedir();
   const dir = path35.join(home, ".adhdev");
-  fs23.mkdirSync(dir, { recursive: true });
+  fs24.mkdirSync(dir, { recursive: true });
   return path35.join(dir, "daemon-upgrade.log");
 }
 function appendUpgradeLog(message) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
 `;
   try {
-    fs23.appendFileSync(getUpgradeLogPath(), line, "utf8");
+    fs24.appendFileSync(getUpgradeLogPath(), line, "utf8");
   } catch {
   }
 }
@@ -41714,12 +41919,12 @@ function resolveSiblingNpmInvocation(nodeExecutable, platform10 = process.platfo
   const binDir = path35.dirname(nodeExecutable);
   if (platform10 === "win32") {
     const npmCliPath = path35.join(binDir, "node_modules", "npm", "bin", "npm-cli.js");
-    if (fs23.existsSync(npmCliPath)) {
+    if (fs24.existsSync(npmCliPath)) {
       return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform10) };
     }
     for (const candidate of ["npm.exe", "npm"]) {
       const candidatePath = path35.join(binDir, candidate);
-      if (fs23.existsSync(candidatePath)) {
+      if (fs24.existsSync(candidatePath)) {
         return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform10) };
       }
     }
@@ -41727,7 +41932,7 @@ function resolveSiblingNpmInvocation(nodeExecutable, platform10 = process.platfo
   }
   for (const candidate of ["npm"]) {
     const candidatePath = path35.join(binDir, candidate);
-    if (fs23.existsSync(candidatePath)) {
+    if (fs24.existsSync(candidatePath)) {
       return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform10) };
     }
   }
@@ -41737,12 +41942,12 @@ function findCurrentPackageRoot(currentCliPath, packageName) {
   if (!currentCliPath) return null;
   let resolvedPath = currentCliPath;
   try {
-    resolvedPath = fs23.realpathSync.native(currentCliPath);
+    resolvedPath = fs24.realpathSync.native(currentCliPath);
   } catch {
   }
   let currentDir = resolvedPath;
   try {
-    if (fs23.statSync(resolvedPath).isFile()) {
+    if (fs24.statSync(resolvedPath).isFile()) {
       currentDir = path35.dirname(resolvedPath);
     }
   } catch {
@@ -41751,8 +41956,8 @@ function findCurrentPackageRoot(currentCliPath, packageName) {
   while (true) {
     const packageJsonPath = path35.join(currentDir, "package.json");
     try {
-      if (fs23.existsSync(packageJsonPath)) {
-        const parsed = JSON.parse(fs23.readFileSync(packageJsonPath, "utf8"));
+      if (fs24.existsSync(packageJsonPath)) {
+        const parsed = JSON.parse(fs24.readFileSync(packageJsonPath, "utf8"));
         if (parsed?.name === packageName) {
           const normalized = currentDir.replace(/\\/g, "/");
           return normalized.includes("/node_modules/") ? currentDir : null;
@@ -41901,8 +42106,8 @@ async function waitForPidExit(pid, timeoutMs) {
 function stopSessionHostProcesses(appName) {
   const pidFile = path35.join(os27.homedir(), ".adhdev", `${appName}-session-host.pid`);
   try {
-    if (fs23.existsSync(pidFile)) {
-      const pid = Number.parseInt(fs23.readFileSync(pidFile, "utf8").trim(), 10);
+    if (fs24.existsSync(pidFile)) {
+      const pid = Number.parseInt(fs24.readFileSync(pidFile, "utf8").trim(), 10);
       if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid(pid)) {
         killPid(pid);
       }
@@ -41910,7 +42115,7 @@ function stopSessionHostProcesses(appName) {
   } catch {
   } finally {
     try {
-      fs23.unlinkSync(pidFile);
+      fs24.unlinkSync(pidFile);
     } catch {
     }
   }
@@ -41918,7 +42123,7 @@ function stopSessionHostProcesses(appName) {
 function removeDaemonPidFile() {
   const pidFile = path35.join(os27.homedir(), ".adhdev", "daemon.pid");
   try {
-    fs23.unlinkSync(pidFile);
+    fs24.unlinkSync(pidFile);
   } catch {
   }
 }
@@ -41936,23 +42141,23 @@ function cleanupStaleGlobalInstallDirs(pkgName, surface) {
   if (pkgName.startsWith("@")) {
     const [scope, name] = pkgName.split("/");
     const scopeDir = path35.join(npmRoot, scope);
-    if (!fs23.existsSync(scopeDir)) return;
-    for (const entry of fs23.readdirSync(scopeDir)) {
+    if (!fs24.existsSync(scopeDir)) return;
+    for (const entry of fs24.readdirSync(scopeDir)) {
       if (!entry.startsWith(`.${name}-`)) continue;
-      fs23.rmSync(path35.join(scopeDir, entry), { recursive: true, force: true });
+      fs24.rmSync(path35.join(scopeDir, entry), { recursive: true, force: true });
       appendUpgradeLog(`Removed stale scoped staging dir: ${path35.join(scopeDir, entry)}`);
     }
   } else {
-    for (const entry of fs23.readdirSync(npmRoot)) {
+    for (const entry of fs24.readdirSync(npmRoot)) {
       if (!entry.startsWith(`.${pkgName}-`)) continue;
-      fs23.rmSync(path35.join(npmRoot, entry), { recursive: true, force: true });
+      fs24.rmSync(path35.join(npmRoot, entry), { recursive: true, force: true });
       appendUpgradeLog(`Removed stale staging dir: ${path35.join(npmRoot, entry)}`);
     }
   }
-  if (fs23.existsSync(binDir)) {
-    for (const entry of fs23.readdirSync(binDir)) {
+  if (fs24.existsSync(binDir)) {
+    for (const entry of fs24.readdirSync(binDir)) {
       if (!Array.from(binNames).some((name) => entry.startsWith(`.${name}-`))) continue;
-      fs23.rmSync(path35.join(binDir, entry), { recursive: true, force: true });
+      fs24.rmSync(path35.join(binDir, entry), { recursive: true, force: true });
       appendUpgradeLog(`Removed stale bin staging entry: ${path35.join(binDir, entry)}`);
     }
   }
@@ -42043,7 +42248,7 @@ init_mesh_work_queue();
 init_repo_mesh_types();
 var import_os3 = require("os");
 var import_path11 = require("path");
-var fs24 = __toESM(require("fs"));
+var fs25 = __toESM(require("fs"));
 var import_node_child_process6 = require("child_process");
 var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
 var CHANNEL_SERVER_URL = {
@@ -42369,6 +42574,12 @@ function inlineMeshCarriesTransientNodeTruth(inlineMesh) {
 function readInlineMeshNodeId(node) {
   return normalizeMeshNodeId(node) ?? "";
 }
+function isDeadLocalWorktreeNode(node) {
+  if (node?.isLocalWorktree !== true) return false;
+  const workspace = readStringValue(node?.workspace);
+  if (!workspace) return false;
+  return !fs25.existsSync(workspace);
+}
 function foldMeshNodeIdentityToCanonical(node) {
   if (!node || typeof node !== "object" || Array.isArray(node)) return node;
   const canonical = normalizeMeshNodeId(node);
@@ -42615,7 +42826,7 @@ function summarizeInlineMeshBranchConvergence(nodes) {
   const followUps = nodes.filter((node) => {
     if (readObjectRecord(node.branchConvergence).needsConvergence !== true) return false;
     const workspace = typeof node.workspace === "string" ? node.workspace : "";
-    if (workspace && !fs24.existsSync(workspace)) return false;
+    if (workspace && !fs25.existsSync(workspace)) return false;
     return true;
   }).map((node) => {
     const convergence = readObjectRecord(node.branchConvergence);
@@ -42823,7 +43034,8 @@ async function hydrateInlineMeshDirectTruth(args) {
       peerAttemptedCount: 0,
       peerConfirmedCount: 0,
       standingEvidenceCount: 0,
-      unavailableNodeIds: []
+      unavailableNodeIds: [],
+      deadNodeIds: []
     };
   }
   const selectedCoordinatorNodeId = readStringValue(
@@ -42836,6 +43048,7 @@ async function hydrateInlineMeshDirectTruth(args) {
   let peerConfirmedCount = 0;
   let standingEvidenceCount = 0;
   const unavailableNodeIds = [];
+  const deadNodeIds = [];
   for (const [nodeIndex, node] of nodes.entries()) {
     const nodeId = normalizeMeshNodeId(node) || `node_${nodeIndex}`;
     const workspace = readStringValue(node?.workspace);
@@ -42845,11 +43058,18 @@ async function hydrateInlineMeshDirectTruth(args) {
     ) || Boolean(
       daemonId && (daemonId === args.localMachineId || daemonId === args.statusInstanceId)
     ) || Boolean(args.meshSource !== "local_config" && nodeIndex === 0);
+    const isSelfDaemonNode = Boolean(
+      daemonId && (daemonId === args.localMachineId || daemonId === args.statusInstanceId)
+    );
+    if ((isSelfNode || isSelfDaemonNode) && isDeadLocalWorktreeNode(node)) {
+      deadNodeIds.push(nodeId);
+      continue;
+    }
     if (!workspace) {
       if (!isSelfNode && daemonId) unavailableNodeIds.push(nodeId);
       continue;
     }
-    if (fs24.existsSync(workspace)) {
+    if (fs25.existsSync(workspace)) {
       try {
         const localGit = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
         if (localGit?.isGitRepo) {
@@ -42895,7 +43115,8 @@ async function hydrateInlineMeshDirectTruth(args) {
     peerAttemptedCount,
     peerConfirmedCount,
     standingEvidenceCount,
-    unavailableNodeIds
+    unavailableNodeIds,
+    deadNodeIds
   };
 }
 function summarizeMeshSessionRecord(record) {
@@ -42954,7 +43175,7 @@ function readLiveMeshNodeWorkspace(args) {
 }
 function collectLiveMeshSessionRecords(args) {
   const nodeWorkspace = readStringValue(args.node?.workspace);
-  const nodeIsMissingLocalWorktree = args.node?.isLocalWorktree === true && !!nodeWorkspace && !fs24.existsSync(nodeWorkspace);
+  const nodeIsMissingLocalWorktree = args.node?.isLocalWorktree === true && !!nodeWorkspace && !fs25.existsSync(nodeWorkspace);
   const matches = args.liveSessionRecords.filter((record) => {
     const recordNodeId = readStringValue(record?.meta?.meshNodeId);
     if (recordNodeId && recordNodeId !== args.nodeId) return false;
@@ -42981,7 +43202,7 @@ function buildHistoricalMeshSessions(args) {
     const workspace = readStringValue(node?.workspace);
     if (nodeId) liveNodeIds.add(nodeId);
     if (workspace) liveWorkspaces.add(workspace);
-    if (nodeId && node?.isLocalWorktree === true && workspace && !fs24.existsSync(workspace)) {
+    if (nodeId && node?.isLocalWorktree === true && workspace && !fs25.existsSync(workspace)) {
       missingLocalWorktreeNodeIds.add(nodeId);
     }
   }
@@ -43341,7 +43562,7 @@ function isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) {
   if (!baseCommit || !branchCommit) return false;
   if (baseCommit === branchCommit) return true;
   try {
-    if (!fs24.existsSync(submoduleRepoPath)) return false;
+    if (!fs25.existsSync(submoduleRepoPath)) return false;
     (0, import_node_child_process6.execFileSync)("git", ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
     (0, import_node_child_process6.execFileSync)("git", ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
     (0, import_node_child_process6.execFileSync)("git", ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
@@ -43458,7 +43679,7 @@ function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderC
       return newTree || void 0;
     } finally {
       try {
-        fs24.rmSync(tmpIndex, { force: true });
+        fs25.rmSync(tmpIndex, { force: true });
       } catch {
       }
     }
@@ -43533,7 +43754,7 @@ function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, g
       return newTree || void 0;
     } finally {
       try {
-        fs24.rmSync(tmpIndex, { force: true });
+        fs25.rmSync(tmpIndex, { force: true });
       } catch {
       }
     }
@@ -43639,7 +43860,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
       return { stdout: String(stdout || ""), stderr: String(stderr || ""), refspec };
     };
     const importCommitFromWorktreeSubmodule = async (submodulePath, worktreeSubmodulePath, commit) => {
-      if (!fs24.existsSync(worktreeSubmodulePath)) return false;
+      if (!fs25.existsSync(worktreeSubmodulePath)) return false;
       try {
         await runGit3(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
       } catch {
@@ -43662,7 +43883,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
         reachable: false
       };
       try {
-        if (!fs24.existsSync(submodulePath)) {
+        if (!fs25.existsSync(submodulePath)) {
           entry.error = `Submodule checkout missing at ${gitlink.path}`;
           entry.publishRequired = true;
           if (options.allowAutoPublishSubmoduleMainCommits === true) {
@@ -43899,9 +44120,9 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
     return ["npm", "pnpm", "yarn", "bun"].includes(command) && candidate.args.some((arg) => arg === "run" || arg === "test" || arg === "exec");
   };
   const dependenciesLikelyMissing = (cwd) => {
-    if (!fs24.existsSync((0, import_path11.join)(cwd, "package.json"))) return false;
-    if (fs24.existsSync((0, import_path11.join)(cwd, "node_modules"))) return false;
-    return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs24.existsSync((0, import_path11.join)(cwd, lock)));
+    if (!fs25.existsSync((0, import_path11.join)(cwd, "package.json"))) return false;
+    if (fs25.existsSync((0, import_path11.join)(cwd, "node_modules"))) return false;
+    return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs25.existsSync((0, import_path11.join)(cwd, lock)));
   };
   if (runLegacyBootstrapCommands) {
     summary.bootstrap = { stage: "legacy" };
@@ -44003,9 +44224,9 @@ function resolveHermesUserHome() {
 function loadHermesCoordinatorBaseConfig(targetConfigPath) {
   const sourceHome = resolveHermesUserHome();
   const sourceConfigPath = (0, import_path11.join)(sourceHome, "config.yaml");
-  if (!fs24.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+  if (!fs25.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
   if ((0, import_path11.resolve)(sourceConfigPath) === (0, import_path11.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-  const parsed = parseMeshCoordinatorMcpConfig(fs24.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
+  const parsed = parseMeshCoordinatorMcpConfig(fs25.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
   const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
   return { config: baseConfig, sourceHome, sourceConfigPath };
 }
@@ -44042,9 +44263,9 @@ function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
   for (const fileName of [".env", "auth.json"]) {
     const sourcePath = (0, import_path11.join)(sourceHome, fileName);
     const targetPath = (0, import_path11.join)(targetHome, fileName);
-    if (!fs24.existsSync(sourcePath)) continue;
+    if (!fs25.existsSync(sourcePath)) continue;
     try {
-      fs24.copyFileSync(sourcePath, targetPath);
+      fs25.copyFileSync(sourcePath, targetPath);
     } catch (error) {
       LOG.warn("MeshCoordinator", `Could not copy Hermes ${fileName} into isolated coordinator home: ${error?.message || error}`);
     }
@@ -44202,6 +44423,15 @@ var DaemonCommandRouter = class {
    *  Allows the MCP server to query mesh data via get_mesh even when
    *  the mesh doesn't exist in the local meshes.json file. */
   inlineMeshCache = /* @__PURE__ */ new Map();
+  /** Tombstones for inline mesh nodes removed via remove_mesh_node, keyed by
+   *  meshId → set of removed nodeIds. The dashboard keeps echoing the removed
+   *  node in the inlineMesh it attaches to every command; without a tombstone,
+   *  reconcileInlineMeshCache MERGEs it straight back (resurrection). A
+   *  tombstoned node is skipped during reconcile only while its workspace is
+   *  absent from disk — a genuine re-registration (same nodeId, workspace back
+   *  on disk) clears the tombstone and merges normally, preserving clone
+   *  worktree visibility and legitimate node re-creation. */
+  removedInlineMeshNodeIds = /* @__PURE__ */ new Map();
   /** Coordinator-owned whole-mesh aggregate status snapshots. Browser callers read this by default. */
   aggregateMeshStatusCache = /* @__PURE__ */ new Map();
   /** Shared per-peer git_status probe dedup + recently-probed reuse gate.
@@ -44235,10 +44465,23 @@ var DaemonCommandRouter = class {
     const unavailableNodeIds = /* @__PURE__ */ new Set();
     const sourceOfTruth = readObjectRecord(snapshot.sourceOfTruth);
     const directPeerTruth = readObjectRecord(sourceOfTruth.directPeerTruth);
+    const deadNodeIds = /* @__PURE__ */ new Set();
+    for (const node of mesh.nodes) {
+      if (!isDeadLocalWorktreeNode(node)) continue;
+      const deadId = readInlineMeshNodeId(node);
+      if (deadId) deadNodeIds.add(deadId);
+    }
+    let droppedDeadUnavailable = false;
     for (const entry of Array.isArray(directPeerTruth.unavailableNodeIds) ? directPeerTruth.unavailableNodeIds : []) {
       const nodeId = readStringValue(entry);
-      if (nodeId) unavailableNodeIds.add(nodeId);
+      if (!nodeId) continue;
+      if (deadNodeIds.has(nodeId)) {
+        droppedDeadUnavailable = true;
+        continue;
+      }
+      unavailableNodeIds.add(nodeId);
     }
+    if (droppedDeadUnavailable) changed = true;
     const nodes = snapshot.nodes.map((statusNode) => {
       const nodeId = normalizeMeshNodeId(statusNode);
       const inlineNode = nodeId ? inlineNodesById.get(nodeId) : void 0;
@@ -44353,7 +44596,10 @@ var DaemonCommandRouter = class {
   }
   warmInlineMeshCache(meshId, inlineMesh) {
     if (!inlineMesh || typeof inlineMesh !== "object") return void 0;
-    const sanitizedInlineMesh = sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(inlineMesh));
+    const sanitizedInlineMesh = this.applyInlineMeshNodeTombstones(
+      meshId,
+      sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(inlineMesh))
+    );
     const cached2 = this.inlineMeshCache.get(meshId);
     if (cached2) {
       const merged = reconcileInlineMeshCache(cached2, sanitizedInlineMesh);
@@ -44369,7 +44615,10 @@ var DaemonCommandRouter = class {
       const cached3 = this.getCachedInlineMesh(meshId);
       if (cached3) {
         if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
-          const merged = reconcileInlineMeshCache(cached3, inlineMesh);
+          const merged = reconcileInlineMeshCache(
+            cached3,
+            this.applyInlineMeshNodeTombstones(meshId, inlineMesh)
+          );
           this.inlineMeshCache.set(meshId, sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(merged)));
           return { mesh: merged, inline: true, source: "inline_cache" };
         }
@@ -44420,12 +44669,49 @@ var DaemonCommandRouter = class {
     if (!mesh || !Array.isArray(mesh.nodes)) return false;
     const idx = mesh.nodes.findIndex((entry) => meshNodeIdMatches(entry, nodeId));
     if (idx === -1) return false;
+    const canonicalNodeId = readInlineMeshNodeId(mesh.nodes[idx]) || nodeId;
     mesh.nodes.splice(idx, 1);
     mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.inlineMeshCache.set(meshId, mesh);
+    this.tombstoneRemovedInlineMeshNode(meshId, canonicalNodeId);
+    if (canonicalNodeId !== nodeId) this.tombstoneRemovedInlineMeshNode(meshId, nodeId);
     this.invalidateAggregateMeshStatus(meshId);
     return true;
   }
+  tombstoneRemovedInlineMeshNode(meshId, nodeId) {
+    if (!nodeId) return;
+    let set = this.removedInlineMeshNodeIds.get(meshId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.removedInlineMeshNodeIds.set(meshId, set);
+    }
+    set.add(nodeId);
+  }
+  /** Filter an incoming inline mesh against this mesh's tombstones before it is
+   *  reconciled into the cache. A tombstoned node is dropped only while its
+   *  workspace is still absent from disk; if the workspace is back (genuine
+   *  re-registration), the tombstone is cleared and the node merges normally. */
+  applyInlineMeshNodeTombstones(meshId, incoming) {
+    const tombstones = this.removedInlineMeshNodeIds.get(meshId);
+    if (!tombstones?.size || !incoming || typeof incoming !== "object" || !Array.isArray(incoming.nodes)) {
+      return incoming;
+    }
+    let dropped = false;
+    const nodes = incoming.nodes.filter((node) => {
+      const nodeId = readInlineMeshNodeId(node);
+      if (!nodeId || !tombstones.has(nodeId)) return true;
+      const workspace = readStringValue(node?.workspace);
+      if (workspace && fs25.existsSync(workspace)) {
+        tombstones.delete(nodeId);
+        return true;
+      }
+      dropped = true;
+      return false;
+    });
+    if (tombstones.size === 0) this.removedInlineMeshNodeIds.delete(meshId);
+    if (!dropped) return incoming;
+    return { ...incoming, nodes };
+  }
   normalizeMeshSessionCleanupMode(value) {
     return value === "stop" || value === "delete_stopped" || value === "stop_and_delete" || value === "preserve" ? value : "preserve";
   }
@@ -44448,13 +44734,13 @@ var DaemonCommandRouter = class {
         recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains."
       };
     }
-    const worktreeExists = fs24.existsSync(workspace);
+    const worktreeExists = fs25.existsSync(workspace);
     const sourceNode = args.node?.clonedFromNodeId ? args.mesh?.nodes?.find((n) => meshNodeIdMatches(n, args.node.clonedFromNodeId)) : args.mesh?.nodes?.find((n) => !n.isLocalWorktree);
     const repoRoot = typeof sourceNode?.repoRoot === "string" && sourceNode.repoRoot.trim() ? sourceNode.repoRoot.trim() : typeof sourceNode?.workspace === "string" && sourceNode.workspace.trim() ? sourceNode.workspace.trim() : "";
     if (!worktreeExists) {
       return { success: true, skipped: true, removedPath: workspace, repoRoot: repoRoot || void 0, reason: "worktree_path_missing" };
     }
-    if (!repoRoot || !fs24.existsSync(repoRoot)) {
+    if (!repoRoot || !fs25.existsSync(repoRoot)) {
       return {
         success: false,
         code: "mesh_worktree_cleanup_missing_source_repo",
@@ -44474,7 +44760,7 @@ var DaemonCommandRouter = class {
     const normalizePath = (value) => {
       const resolved = (0, import_path11.resolve)(value);
       try {
-        return fs24.realpathSync(resolved);
+        return fs25.realpathSync(resolved);
       } catch {
         return resolved;
       }
@@ -44560,7 +44846,7 @@ var DaemonCommandRouter = class {
           };
         } catch (deinitError) {
           try {
-            fs24.rmSync(workspace, { recursive: true, force: true });
+            fs25.rmSync(workspace, { recursive: true, force: true });
             await execFileAsync4("git", ["worktree", "prune"], {
               cwd: repoRoot,
               encoding: "utf8",
@@ -46339,8 +46625,8 @@ ${hintLines.join("\n")}` : "",
           if (sinceTs > 0) {
             return { success: true, logs: [], totalBuffered: 0 };
           }
-          if (fs24.existsSync(LOG_PATH)) {
-            const content = fs24.readFileSync(LOG_PATH, "utf-8");
+          if (fs25.existsSync(LOG_PATH)) {
+            const content = fs25.readFileSync(LOG_PATH, "utf-8");
             const allLines = content.split("\n");
             const recent = allLines.slice(-count).join("\n");
             return { success: true, logs: recent, totalLines: allLines.length };
@@ -46885,14 +47171,14 @@ ${hintLines.join("\n")}` : "",
       //    Settings page in the dashboard reads/writes via these two
       //    commands instead of going through fs from the browser.
       case "list_coordinator_prompts": {
-        const fs30 = await import("fs");
+        const fs31 = await import("fs");
         const path41 = await import("path");
         const os30 = await import("os");
         const dir = path41.join(os30.homedir(), ".adhdev", "coordinator-prompts");
         const entries = {};
         try {
-          if (fs30.existsSync(dir)) {
-            for (const name of fs30.readdirSync(dir)) {
+          if (fs31.existsSync(dir)) {
+            for (const name of fs31.readdirSync(dir)) {
               const matchOverride = name.match(/^([a-zA-Z0-9_.-]+)\.md$/);
               const matchAppend = name.match(/^([a-zA-Z0-9_.-]+)\.append\.md$/);
               const m = matchAppend || matchOverride;
@@ -46902,7 +47188,7 @@ ${hintLines.join("\n")}` : "",
               const full = path41.join(dir, name);
               let content = "";
               try {
-                content = fs30.readFileSync(full, "utf8");
+                content = fs31.readFileSync(full, "utf8");
               } catch {
               }
               if (!entries[key]) entries[key] = { override: "", append: "" };
@@ -46916,7 +47202,7 @@ ${hintLines.join("\n")}` : "",
         return { success: true, dir, entries };
       }
       case "write_coordinator_prompt": {
-        const fs30 = await import("fs");
+        const fs31 = await import("fs");
         const path41 = await import("path");
         const os30 = await import("os");
         const key = typeof args?.key === "string" ? args.key.trim() : "";
@@ -46929,11 +47215,11 @@ ${hintLines.join("\n")}` : "",
         const filename = kind === "append" ? `${key}.append.md` : `${key}.md`;
         const full = path41.join(dir, filename);
         try {
-          fs30.mkdirSync(dir, { recursive: true });
+          fs31.mkdirSync(dir, { recursive: true });
           if (content.trim()) {
-            fs30.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
-          } else if (fs30.existsSync(full)) {
-            fs30.unlinkSync(full);
+            fs31.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
+          } else if (fs31.existsSync(full)) {
+            fs31.unlinkSync(full);
           }
           return { success: true, path: full, kind, key };
         } catch (error) {
@@ -47711,6 +47997,55 @@ ${hintLines.join("\n")}` : "",
         });
         return result;
       }
+      case "get_mesh_node_logs": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+        let nodeDaemonId;
+        if (meshId && nodeId) {
+          const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const node = meshRecord?.mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+          nodeDaemonId = typeof node?.daemonId === "string" ? node.daemonId.trim() : void 0;
+        }
+        const selfDaemonId = this.deps.statusInstanceId;
+        const isRemote = nodeDaemonId && selfDaemonId && nodeDaemonId !== selfDaemonId;
+        if (isRemote && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+          const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, "get_mesh_node_logs", {
+            ...typeof args === "object" && args !== null ? args : {},
+            _meshDirectDispatch: true
+          });
+          return forwarded ?? { success: false, error: "no response from remote node" };
+        }
+        const rawTailBytes = Number(args?.tailBytes);
+        const tail = readDaemonLogTail({
+          date: typeof args?.date === "string" ? args.date : void 0,
+          tailBytes: Number.isFinite(rawTailBytes) ? Math.min(rawTailBytes, MAX_TAIL_BYTES) : void 0,
+          grep: typeof args?.grep === "string" ? args.grep : void 0,
+          sinceMs: Number.isFinite(Number(args?.sinceMs)) ? Number(args?.sinceMs) : void 0
+        });
+        if (!tail.success) {
+          return {
+            success: false,
+            error: tail.error || "failed to read daemon log tail",
+            nodeId,
+            logPath: tail.logPath,
+            platform: tail.platform
+          };
+        }
+        const redactedLines = redactLogLines(tail.lines);
+        return {
+          success: true,
+          nodeId,
+          daemonId: selfDaemonId,
+          logPath: tail.logPath,
+          platform: tail.platform,
+          lines: redactedLines,
+          lineCount: redactedLines.length,
+          truncated: tail.truncated,
+          filtered: tail.filtered,
+          bytesReturned: tail.bytesReturned,
+          ...tail.grep ? { grep: tail.grep } : {}
+        };
+      }
       case "refine_mesh_node": {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
@@ -48378,15 +48713,15 @@ ${ptyResult.output.slice(-2e3)}`);
             }
             if (cliType === "codex-cli") {
               const repoMcpConfigPath = (0, import_path11.join)(workspace, ".mcp.json");
-              if (fs24.existsSync(repoMcpConfigPath)) {
+              if (fs25.existsSync(repoMcpConfigPath)) {
                 try {
                   const repoMcpConfig = parseMeshCoordinatorMcpConfig(
-                    fs24.readFileSync(repoMcpConfigPath, "utf-8"),
+                    fs25.readFileSync(repoMcpConfigPath, "utf-8"),
                     "claude_mcp_json"
                   );
                   const existingServers2 = repoMcpConfig.mcpServers;
                   if (existingServers2 && typeof existingServers2 === "object" && !Array.isArray(existingServers2) && existingServers2[coordinatorSetup.serverName]) {
-                    fs24.writeFileSync(repoMcpConfigPath, serializeMeshCoordinatorMcpConfig({
+                    fs25.writeFileSync(repoMcpConfigPath, serializeMeshCoordinatorMcpConfig({
                       ...repoMcpConfig,
                       mcpServers: {
                         ...existingServers2,
@@ -48502,7 +48837,7 @@ ${ptyResult.output.slice(-2e3)}`);
               workspace
             };
           }
-          const { existsSync: existsSync43, readFileSync: readFileSync35, writeFileSync: writeFileSync23, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
+          const { existsSync: existsSync44, readFileSync: readFileSync35, writeFileSync: writeFileSync23, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
           const { dirname: dirname14 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
           const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -48545,7 +48880,7 @@ ${ptyResult.output.slice(-2e3)}`);
             if (hermesManualFallback) return returnManualFallback(message);
             return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
           }
-          const hadExistingMcpConfig = existsSync43(mcpConfigPath);
+          const hadExistingMcpConfig = existsSync44(mcpConfigPath);
           let existingMcpConfig = hermesBaseConfig?.config || {};
           if (hermesBaseConfig) {
             copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname14(mcpConfigPath));
@@ -48722,7 +49057,8 @@ ${ptyResult.output.slice(-2e3)}`);
             peerAttemptedCount: 0,
             peerConfirmedCount: 0,
             standingEvidenceCount: 0,
-            unavailableNodeIds: []
+            unavailableNodeIds: [],
+            deadNodeIds: []
           };
           const passivePeerTruthNotAttempted = requireDirectPeerTruth && !refreshRequested && directTruth.directEvidenceCount > 0 && directTruth.peerAttemptedCount === 0;
           const effectiveDirectTruth = passivePeerTruthNotAttempted ? { ...directTruth, unavailableNodeIds: [] } : directTruth;
@@ -48862,7 +49198,7 @@ ${ptyResult.output.slice(-2e3)}`);
               }
             }
             if (workspace) {
-              if (!fs24.existsSync(workspace)) {
+              if (!fs25.existsSync(workspace)) {
                 const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
                 let remoteProbeApplied = false;
                 if (inlineTransitGit) {
@@ -48953,7 +49289,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const pendingCoordinatorEvents = getPendingMeshCoordinatorEvents(meshId, callerCoordinatorDaemonId);
           const unroutableDeliveries = getRecentUnroutableDeliveries();
           const previewFreshness = (() => {
-            const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs24.existsSync(candidate));
+            const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs25.existsSync(candidate));
             return localRepoRoot ? buildPreviewFreshness(localRepoRoot) : void 0;
           })();
           const asyncRefineJobs = buildMeshAsyncRefineJobs({
@@ -49048,7 +49384,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const { deriveMeshReviewInboxItems: deriveMeshReviewInboxItems2 } = await Promise.resolve().then(() => (init_mesh_review_inbox(), mesh_review_inbox_exports));
           const { readLedgerEntries: readLedgerEntries2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
           const { getGitDiffSummary: getGitDiffSummary2 } = await Promise.resolve().then(() => (init_git_diff(), git_diff_exports));
-          const { existsSync: existsSync43 } = await import("fs");
+          const { existsSync: existsSync44 } = await import("fs");
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
           const mesh = meshRecord?.mesh;
           if (!mesh) return { success: false, error: "Mesh not found" };
@@ -49067,7 +49403,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const derivation = deriveMeshReviewInboxItems2({ nodes: nodeStatuses, ledgerEntries });
           for (const item of derivation.items) {
             const workspace = item.workspace;
-            if (!workspace || !existsSync43(workspace)) continue;
+            if (!workspace || !existsSync44(workspace)) continue;
             const baseRef = item.defaultBranch ? `origin/${item.defaultBranch}` : "origin/main";
             try {
               const diffResult = await getGitDiffSummary2(workspace, { baseRef, maxFiles: 100 });
@@ -50813,7 +51149,7 @@ var ProviderInstanceManager = class {
 };
 
 // src/providers/version-archive.ts
-var fs25 = __toESM(require("fs"));
+var fs26 = __toESM(require("fs"));
 var path36 = __toESM(require("path"));
 var os28 = __toESM(require("os"));
 var import_os4 = require("os");
@@ -50827,8 +51163,8 @@ var VersionArchive = class {
   }
   load() {
     try {
-      if (fs25.existsSync(ARCHIVE_PATH)) {
-        this.history = JSON.parse(fs25.readFileSync(ARCHIVE_PATH, "utf-8"));
+      if (fs26.existsSync(ARCHIVE_PATH)) {
+        this.history = JSON.parse(fs26.readFileSync(ARCHIVE_PATH, "utf-8"));
       }
     } catch {
       this.history = {};
@@ -50865,8 +51201,8 @@ var VersionArchive = class {
   }
   save() {
     try {
-      fs25.mkdirSync(path36.dirname(ARCHIVE_PATH), { recursive: true });
-      fs25.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
+      fs26.mkdirSync(path36.dirname(ARCHIVE_PATH), { recursive: true });
+      fs26.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
     } catch {
     }
   }
@@ -50891,8 +51227,8 @@ function findBinary2(name) {
     for (const ext of exes) {
       const fullPath = path36.join(p, name + ext);
       try {
-        if (fs25.existsSync(fullPath)) {
-          const stat2 = fs25.statSync(fullPath);
+        if (fs26.existsSync(fullPath)) {
+          const stat2 = fs26.statSync(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
           }
@@ -50939,9 +51275,9 @@ function checkPathExists2(paths) {
     if (p.includes("*")) {
       const home = os28.homedir();
       const resolved = p.replace(/\*/g, home.split(path36.sep).pop() || "");
-      if (fs25.existsSync(resolved)) return resolved;
+      if (fs26.existsSync(resolved)) return resolved;
     } else {
-      if (fs25.existsSync(p)) return p;
+      if (fs26.existsSync(p)) return p;
     }
   }
   return null;
@@ -50949,7 +51285,7 @@ function checkPathExists2(paths) {
 async function getMacAppVersion(appPath) {
   if ((0, import_os4.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
   const plistPath = path36.join(appPath, "Contents", "Info.plist");
-  if (!fs25.existsSync(plistPath)) return null;
+  if (!fs26.existsSync(plistPath)) return null;
   const raw = await runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
   return raw || null;
 }
@@ -50975,7 +51311,7 @@ async function detectAllVersions(loader, archive) {
       let resolvedBin = cliBin;
       if (!resolvedBin && appPath && currentOs === "darwin") {
         const bundled = path36.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
-        if (provider.cli && fs25.existsSync(bundled)) resolvedBin = bundled;
+        if (provider.cli && fs26.existsSync(bundled)) resolvedBin = bundled;
       }
       info.installed = !!(appPath || resolvedBin);
       info.path = appPath || null;
@@ -51014,7 +51350,7 @@ async function detectAllVersions(loader, archive) {
 
 // src/daemon/dev-server.ts
 var http2 = __toESM(require("http"));
-var fs29 = __toESM(require("fs"));
+var fs30 = __toESM(require("fs"));
 var path40 = __toESM(require("path"));
 init_config();
 
@@ -51365,7 +51701,7 @@ async (params) => {
 init_logger();
 
 // src/daemon/dev-cdp-handlers.ts
-var fs26 = __toESM(require("fs"));
+var fs27 = __toESM(require("fs"));
 var path37 = __toESM(require("path"));
 init_logger();
 async function handleCdpEvaluate(ctx, req, res) {
@@ -51546,17 +51882,17 @@ async function handleScriptHints(ctx, type, _req, res) {
   }
   let scriptsPath = "";
   const directScripts = path37.join(dir, "scripts.js");
-  if (fs26.existsSync(directScripts)) {
+  if (fs27.existsSync(directScripts)) {
     scriptsPath = directScripts;
   } else {
     const scriptsDir = path37.join(dir, "scripts");
-    if (fs26.existsSync(scriptsDir)) {
-      const versions = fs26.readdirSync(scriptsDir).filter((d) => {
-        return fs26.statSync(path37.join(scriptsDir, d)).isDirectory();
+    if (fs27.existsSync(scriptsDir)) {
+      const versions = fs27.readdirSync(scriptsDir).filter((d) => {
+        return fs27.statSync(path37.join(scriptsDir, d)).isDirectory();
       }).sort().reverse();
       for (const ver of versions) {
         const p = path37.join(scriptsDir, ver, "scripts.js");
-        if (fs26.existsSync(p)) {
+        if (fs27.existsSync(p)) {
           scriptsPath = p;
           break;
         }
@@ -51568,7 +51904,7 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   try {
-    const source = fs26.readFileSync(scriptsPath, "utf-8");
+    const source = fs27.readFileSync(scriptsPath, "utf-8");
     const hints = {};
     const funcRegex = /module\.exports\.(\w+)\s*=\s*function\s+\w+\s*\(params\)/g;
     let match;
@@ -52383,7 +52719,7 @@ async function handleDomContext(ctx, type, req, res) {
 }
 
 // src/daemon/dev-cli-debug.ts
-var fs27 = __toESM(require("fs"));
+var fs28 = __toESM(require("fs"));
 var path38 = __toESM(require("path"));
 function slugifyFixtureName(value) {
   const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -52399,10 +52735,10 @@ function getCliFixtureDir(ctx, type) {
 function readCliFixture(ctx, type, name) {
   const fixtureDir = getCliFixtureDir(ctx, type);
   const filePath = path38.join(fixtureDir, `${name}.json`);
-  if (!fs27.existsSync(filePath)) {
+  if (!fs28.existsSync(filePath)) {
     throw new Error(`Fixture not found: ${filePath}`);
   }
-  return JSON.parse(fs27.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs28.readFileSync(filePath, "utf-8"));
 }
 function getExerciseTranscriptText(result) {
   const parts = [];
@@ -53147,7 +53483,7 @@ async function handleCliFixtureCapture(ctx, req, res) {
       return;
     }
     const fixtureDir = getCliFixtureDir(ctx, type);
-    fs27.mkdirSync(fixtureDir, { recursive: true });
+    fs28.mkdirSync(fixtureDir, { recursive: true });
     const name = slugifyFixtureName(String(body?.name || `${type}-${Date.now()}`));
     const result = await runCliExerciseInternal(ctx, { ...request, type });
     const fixture = {
@@ -53175,7 +53511,7 @@ async function handleCliFixtureCapture(ctx, req, res) {
       notes: typeof body?.notes === "string" ? body.notes : void 0
     };
     const filePath = path38.join(fixtureDir, `${name}.json`);
-    fs27.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
+    fs28.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
     ctx.json(res, 200, {
       saved: true,
       name,
@@ -53193,14 +53529,14 @@ async function handleCliFixtureCapture(ctx, req, res) {
 async function handleCliFixtureList(ctx, type, _req, res) {
   try {
     const fixtureDir = getCliFixtureDir(ctx, type);
-    if (!fs27.existsSync(fixtureDir)) {
+    if (!fs28.existsSync(fixtureDir)) {
       ctx.json(res, 200, { fixtures: [], count: 0 });
       return;
     }
-    const fixtures = fs27.readdirSync(fixtureDir).filter((file) => file.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file) => {
+    const fixtures = fs28.readdirSync(fixtureDir).filter((file) => file.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file) => {
       const fullPath = path38.join(fixtureDir, file);
       try {
-        const raw = JSON.parse(fs27.readFileSync(fullPath, "utf-8"));
+        const raw = JSON.parse(fs28.readFileSync(fullPath, "utf-8"));
         return {
           name: raw.name || file.replace(/\.json$/i, ""),
           path: fullPath,
@@ -53333,7 +53669,7 @@ async function handleCliRaw(ctx, req, res) {
 }
 
 // src/daemon/dev-auto-implement.ts
-var fs28 = __toESM(require("fs"));
+var fs29 = __toESM(require("fs"));
 var path39 = __toESM(require("path"));
 var os29 = __toESM(require("os"));
 var import_session_host_core8 = require("@adhdev/session-host-core");
@@ -53382,10 +53718,10 @@ function resolveAutoImplReference(ctx, category, requestedReference, targetType)
   return fallback?.type || null;
 }
 function getLatestScriptVersionDir(scriptsDir) {
-  if (!fs28.existsSync(scriptsDir)) return null;
-  const versions = fs28.readdirSync(scriptsDir).filter((d) => {
+  if (!fs29.existsSync(scriptsDir)) return null;
+  const versions = fs29.readdirSync(scriptsDir).filter((d) => {
     try {
-      return fs28.statSync(path39.join(scriptsDir, d)).isDirectory();
+      return fs29.statSync(path39.join(scriptsDir, d)).isDirectory();
     } catch {
       return false;
     }
@@ -53407,13 +53743,13 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
   if (!sourceDir) {
     return { dir: null, reason: `Provider source directory not found for '${type}'` };
   }
-  if (!fs28.existsSync(desiredDir)) {
-    fs28.mkdirSync(path39.dirname(desiredDir), { recursive: true });
-    fs28.cpSync(sourceDir, desiredDir, { recursive: true });
+  if (!fs29.existsSync(desiredDir)) {
+    fs29.mkdirSync(path39.dirname(desiredDir), { recursive: true });
+    fs29.cpSync(sourceDir, desiredDir, { recursive: true });
     ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
   }
   const providerJson = path39.join(desiredDir, "provider.json");
-  if (!fs28.existsSync(providerJson)) {
+  if (!fs29.existsSync(providerJson)) {
     return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
   }
   return { dir: desiredDir };
@@ -53421,15 +53757,15 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
 function loadAutoImplReferenceScripts(ctx, referenceType) {
   if (!referenceType) return {};
   const refDir = ctx.findProviderDir(referenceType);
-  if (!refDir || !fs28.existsSync(refDir)) return {};
+  if (!refDir || !fs29.existsSync(refDir)) return {};
   const referenceScripts = {};
   const scriptsDir = path39.join(refDir, "scripts");
   const latestDir = getLatestScriptVersionDir(scriptsDir);
   if (!latestDir) return referenceScripts;
-  for (const file of fs28.readdirSync(latestDir)) {
+  for (const file of fs29.readdirSync(latestDir)) {
     if (!file.endsWith(".js")) continue;
     try {
-      referenceScripts[file] = fs28.readFileSync(path39.join(latestDir, file), "utf-8");
+      referenceScripts[file] = fs29.readFileSync(path39.join(latestDir, file), "utf-8");
     } catch {
     }
   }
@@ -53538,15 +53874,15 @@ async function handleAutoImplement(ctx, type, req, res) {
     const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
     const prompt = buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
     const tmpDir = path39.join(os29.tmpdir(), "adhdev-autoimpl");
-    if (!fs28.existsSync(tmpDir)) fs28.mkdirSync(tmpDir, { recursive: true });
+    if (!fs29.existsSync(tmpDir)) fs29.mkdirSync(tmpDir, { recursive: true });
     const promptFile = path39.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
-    fs28.writeFileSync(promptFile, prompt, "utf-8");
+    fs29.writeFileSync(promptFile, prompt, "utf-8");
     ctx.log(`Auto-implement prompt written to ${promptFile} (${prompt.length} chars)`);
     const agentProvider = ctx.providerLoader.resolve(agent) || ctx.providerLoader.getMeta(agent);
     const spawn4 = agentProvider?.spawn;
     if (!spawn4?.command) {
       try {
-        fs28.unlinkSync(promptFile);
+        fs29.unlinkSync(promptFile);
       } catch {
       }
       ctx.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
@@ -53648,7 +53984,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         } catch {
         }
         try {
-          fs28.unlinkSync(promptFile);
+          fs29.unlinkSync(promptFile);
         } catch {
         }
         ctx.log(`Auto-implement (ACP) ${success ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -53874,7 +54210,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         }
       });
       try {
-        fs28.unlinkSync(promptFile);
+        fs29.unlinkSync(promptFile);
       } catch {
       }
       ctx.log(`Auto-implement ${success ? "completed" : "failed"}: ${type} (exit: ${code})${verificationSummary ? ` verify=${verificationSummary.pass ? "pass" : "fail"}` : ""}`);
@@ -53979,10 +54315,10 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
     lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
     lines.push("");
-    for (const file of fs28.readdirSync(latestScriptsDir)) {
+    for (const file of fs29.readdirSync(latestScriptsDir)) {
       if (file.endsWith(".js") && targetFileNames.has(file)) {
         try {
-          const content = fs28.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
+          const content = fs29.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -53992,14 +54328,14 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
         }
       }
     }
-    const refFiles = fs28.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+    const refFiles = fs29.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
     if (refFiles.length > 0) {
       lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
       lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs28.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
+          const content = fs29.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -54044,7 +54380,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
   const loadGuide = (name) => {
     try {
       const p = path39.join(docsDir, name);
-      if (fs28.existsSync(p)) return fs28.readFileSync(p, "utf-8");
+      if (fs29.existsSync(p)) return fs29.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -54288,11 +54624,11 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
     lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
     lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
     lines.push("");
-    for (const file of fs28.readdirSync(latestScriptsDir)) {
+    for (const file of fs29.readdirSync(latestScriptsDir)) {
       if (!file.endsWith(".js")) continue;
       if (!targetFileNames.has(file)) continue;
       try {
-        const content = fs28.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
+        const content = fs29.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
         lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
         lines.push("```javascript");
         lines.push(content);
@@ -54301,14 +54637,14 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       } catch {
       }
     }
-    const refFiles = fs28.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+    const refFiles = fs29.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
     if (refFiles.length > 0) {
       lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
       lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs28.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
+          const content = fs29.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -54345,7 +54681,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
   const loadGuide = (name) => {
     try {
       const p = path39.join(docsDir, name);
-      if (fs28.existsSync(p)) return fs28.readFileSync(p, "utf-8");
+      if (fs29.existsSync(p)) return fs29.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -55085,7 +55421,7 @@ var DevServer = class _DevServer {
       path40.join(process.cwd(), "packages/web-devconsole/dist")
     ];
     for (const dir of candidates) {
-      if (fs29.existsSync(path40.join(dir, "index.html"))) return dir;
+      if (fs30.existsSync(path40.join(dir, "index.html"))) return dir;
     }
     return null;
   }
@@ -55097,7 +55433,7 @@ var DevServer = class _DevServer {
     }
     const htmlPath = path40.join(distDir, "index.html");
     try {
-      const html = fs29.readFileSync(htmlPath, "utf-8");
+      const html = fs30.readFileSync(htmlPath, "utf-8");
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
       res.end(html);
     } catch (e) {
@@ -55127,7 +55463,7 @@ var DevServer = class _DevServer {
       return;
     }
     try {
-      const content = fs29.readFileSync(filePath);
+      const content = fs30.readFileSync(filePath);
       const ext = path40.extname(filePath);
       const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
       res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
@@ -55236,14 +55572,14 @@ var DevServer = class _DevServer {
     const files = [];
     const scan = (d, prefix) => {
       try {
-        for (const entry of fs29.readdirSync(d, { withFileTypes: true })) {
+        for (const entry of fs30.readdirSync(d, { withFileTypes: true })) {
           if (entry.name.startsWith(".") || entry.name.endsWith(".bak")) continue;
           const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
           if (entry.isDirectory()) {
             files.push({ path: rel, size: 0, type: "dir" });
             scan(path40.join(d, entry.name), rel);
           } else {
-            const stat2 = fs29.statSync(path40.join(d, entry.name));
+            const stat2 = fs30.statSync(path40.join(d, entry.name));
             files.push({ path: rel, size: stat2.size, type: "file" });
           }
         }
@@ -55271,11 +55607,11 @@ var DevServer = class _DevServer {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
-    if (!fs29.existsSync(fullPath) || fs29.statSync(fullPath).isDirectory()) {
+    if (!fs30.existsSync(fullPath) || fs30.statSync(fullPath).isDirectory()) {
       this.json(res, 404, { error: `File not found: ${filePath}` });
       return;
     }
-    const content = fs29.readFileSync(fullPath, "utf-8");
+    const content = fs30.readFileSync(fullPath, "utf-8");
     this.json(res, 200, { type, path: filePath, content, lines: content.split("\n").length });
   }
   /** POST /api/providers/:type/file — write a file { path, content } */
@@ -55297,9 +55633,9 @@ var DevServer = class _DevServer {
       return;
     }
     try {
-      if (fs29.existsSync(fullPath)) fs29.copyFileSync(fullPath, fullPath + ".bak");
-      fs29.mkdirSync(path40.dirname(fullPath), { recursive: true });
-      fs29.writeFileSync(fullPath, content, "utf-8");
+      if (fs30.existsSync(fullPath)) fs30.copyFileSync(fullPath, fullPath + ".bak");
+      fs30.mkdirSync(path40.dirname(fullPath), { recursive: true });
+      fs30.writeFileSync(fullPath, content, "utf-8");
       this.log(`File saved: ${fullPath} (${content.length} chars)`);
       this.providerLoader.reload();
       this.json(res, 200, { saved: true, path: filePath, chars: content.length });
@@ -55316,8 +55652,8 @@ var DevServer = class _DevServer {
     }
     for (const name of ["scripts.js", "provider.json"]) {
       const p = path40.join(dir, name);
-      if (fs29.existsSync(p)) {
-        const source = fs29.readFileSync(p, "utf-8");
+      if (fs30.existsSync(p)) {
+        const source = fs30.readFileSync(p, "utf-8");
         this.json(res, 200, { type, path: p, source, lines: source.split("\n").length });
         return;
       }
@@ -55336,11 +55672,11 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider not found: ${type}` });
       return;
     }
-    const target = fs29.existsSync(path40.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+    const target = fs30.existsSync(path40.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
     const targetPath = path40.join(dir, target);
     try {
-      if (fs29.existsSync(targetPath)) fs29.copyFileSync(targetPath, targetPath + ".bak");
-      fs29.writeFileSync(targetPath, source, "utf-8");
+      if (fs30.existsSync(targetPath)) fs30.copyFileSync(targetPath, targetPath + ".bak");
+      fs30.writeFileSync(targetPath, source, "utf-8");
       this.log(`Saved provider: ${targetPath} (${source.length} chars)`);
       this.providerLoader.reload();
       this.json(res, 200, { saved: true, path: targetPath, chars: source.length });
@@ -55485,20 +55821,20 @@ var DevServer = class _DevServer {
     let targetDir;
     targetDir = this.providerLoader.getUserProviderDir(category, type);
     const jsonPath = path40.join(targetDir, "provider.json");
-    if (fs29.existsSync(jsonPath)) {
+    if (fs30.existsSync(jsonPath)) {
       this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
       return;
     }
     try {
       const result = generateFiles(type, name, category, { cdpPorts, cli, processName, installPath, binary, extensionId, version, osPaths, processNames });
-      fs29.mkdirSync(targetDir, { recursive: true });
-      fs29.writeFileSync(jsonPath, result["provider.json"], "utf-8");
+      fs30.mkdirSync(targetDir, { recursive: true });
+      fs30.writeFileSync(jsonPath, result["provider.json"], "utf-8");
       const createdFiles = ["provider.json"];
       if (result.files) {
         for (const [relPath, content] of Object.entries(result.files)) {
           const fullPath = path40.join(targetDir, relPath);
-          fs29.mkdirSync(path40.dirname(fullPath), { recursive: true });
-          fs29.writeFileSync(fullPath, content, "utf-8");
+          fs30.mkdirSync(path40.dirname(fullPath), { recursive: true });
+          fs30.writeFileSync(fullPath, content, "utf-8");
           createdFiles.push(relPath);
         }
       }
@@ -55547,10 +55883,10 @@ var DevServer = class _DevServer {
   }
   // ─── Phase 2: Auto-Implement Backend ───
   getLatestScriptVersionDir(scriptsDir) {
-    if (!fs29.existsSync(scriptsDir)) return null;
-    const versions = fs29.readdirSync(scriptsDir).filter((d) => {
+    if (!fs30.existsSync(scriptsDir)) return null;
+    const versions = fs30.readdirSync(scriptsDir).filter((d) => {
       try {
-        return fs29.statSync(path40.join(scriptsDir, d)).isDirectory();
+        return fs30.statSync(path40.join(scriptsDir, d)).isDirectory();
       } catch {
         return false;
       }
@@ -55572,13 +55908,13 @@ var DevServer = class _DevServer {
     if (!sourceDir) {
       return { dir: null, reason: `Provider source directory not found for '${type}'` };
     }
-    if (!fs29.existsSync(desiredDir)) {
-      fs29.mkdirSync(path40.dirname(desiredDir), { recursive: true });
-      fs29.cpSync(sourceDir, desiredDir, { recursive: true });
+    if (!fs30.existsSync(desiredDir)) {
+      fs30.mkdirSync(path40.dirname(desiredDir), { recursive: true });
+      fs30.cpSync(sourceDir, desiredDir, { recursive: true });
       this.log(`Auto-implement writable copy created: ${desiredDir}`);
     }
     const providerJson = path40.join(desiredDir, "provider.json");
-    if (!fs29.existsSync(providerJson)) {
+    if (!fs30.existsSync(providerJson)) {
       return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
     }
     return { dir: desiredDir };
@@ -55621,10 +55957,10 @@ var DevServer = class _DevServer {
       lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
       lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
       lines.push("");
-      for (const file of fs29.readdirSync(latestScriptsDir)) {
+      for (const file of fs30.readdirSync(latestScriptsDir)) {
         if (file.endsWith(".js") && targetFileNames.has(file)) {
           try {
-            const content = fs29.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
+            const content = fs30.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -55634,14 +55970,14 @@ var DevServer = class _DevServer {
           }
         }
       }
-      const refFiles = fs29.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+      const refFiles = fs30.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
       if (refFiles.length > 0) {
         lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
         lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
         lines.push("");
         for (const file of refFiles) {
           try {
-            const content = fs29.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
+            const content = fs30.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -55686,7 +56022,7 @@ var DevServer = class _DevServer {
     const loadGuide = (name) => {
       try {
         const p = path40.join(docsDir, name);
-        if (fs29.existsSync(p)) return fs29.readFileSync(p, "utf-8");
+        if (fs30.existsSync(p)) return fs30.readFileSync(p, "utf-8");
       } catch {
       }
       return null;
@@ -55867,11 +56203,11 @@ var DevServer = class _DevServer {
       lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
       lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
       lines.push("");
-      for (const file of fs29.readdirSync(latestScriptsDir)) {
+      for (const file of fs30.readdirSync(latestScriptsDir)) {
         if (!file.endsWith(".js")) continue;
         if (!targetFileNames.has(file)) continue;
         try {
-          const content = fs29.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
+          const content = fs30.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -55880,14 +56216,14 @@ var DevServer = class _DevServer {
         } catch {
         }
       }
-      const refFiles = fs29.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+      const refFiles = fs30.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
       if (refFiles.length > 0) {
         lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
         lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
         lines.push("");
         for (const file of refFiles) {
           try {
-            const content = fs29.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
+            const content = fs30.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -55924,7 +56260,7 @@ var DevServer = class _DevServer {
     const loadGuide = (name) => {
       try {
         const p = path40.join(docsDir, name);
-        if (fs29.existsSync(p)) return fs29.readFileSync(p, "utf-8");
+        if (fs30.existsSync(p)) return fs30.readFileSync(p, "utf-8");
       } catch {
       }
       return null;
@@ -57025,8 +57361,8 @@ async function installExtension(ide, extension) {
       const res = await fetch(extension.vsixUrl);
       if (res.ok) {
         const buffer = Buffer.from(await res.arrayBuffer());
-        const fs30 = await import("fs");
-        fs30.writeFileSync(vsixPath, buffer);
+        const fs31 = await import("fs");
+        fs31.writeFileSync(vsixPath, buffer);
         return new Promise((resolve24) => {
           const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
           (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {