@essentialai/cogent-bridge-bundled 3.23.5 → 3.23.7

package/cogent-bridge.mjs

@@ -1259,8 +1259,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path24, errorMaps, issueData } = params;
-      const fullPath = [...path24, ...issueData.path || []];
+      const { data, path: path25, errorMaps, issueData } = params;
+      const fullPath = [...path25, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -1540,11 +1540,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path24, key) {
+      constructor(parent, value, path25, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path24;
+        this._path = path25;
         this._key = key;
       }
       get path() {
@@ -4996,10 +4996,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path24) {
-  if (!path24)
+function getElementAtPath(obj, path25) {
+  if (!path25)
     return obj;
-  return path24.reduce((acc, key) => acc?.[key], obj);
+  return path25.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -5248,11 +5248,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path24, issues) {
+function prefixIssues(path25, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path24);
+    iss.path.unshift(path25);
     return iss;
   });
 }
@@ -17058,8 +17058,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path24) {
-      let input = path24;
+    function removeDotSegments(path25) {
+      let input = path25;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -17258,8 +17258,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path24, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path24 && path24 !== "/" ? path24 : void 0;
+        const [path25, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path25 && path25 !== "/" ? path25 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -20612,12 +20612,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs22, exportName) {
+    function addFormats(ajv, list, fs23, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs22[f]);
+        ajv.addFormat(f, fs23[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -21729,8 +21729,8 @@ var require_parseUtil = __commonJS({
     var errors_js_1 = require_errors2();
     var en_js_1 = __importDefault(require_en());
     var makeIssue2 = (params) => {
-      const { data, path: path24, errorMaps, issueData } = params;
-      const fullPath = [...path24, ...issueData.path || []];
+      const { data, path: path25, errorMaps, issueData } = params;
+      const fullPath = [...path25, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -21884,11 +21884,11 @@ var require_types2 = __commonJS({
     var parseUtil_js_1 = require_parseUtil();
     var util_js_1 = require_util2();
     var ParseInputLazyPath2 = class {
-      constructor(parent, value, path24, key) {
+      constructor(parent, value, path25, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path24;
+        this._path = path25;
         this._key = key;
       }
       get path() {
@@ -26389,8 +26389,8 @@ var init_stdio2 = __esm({
 // src/constants.ts
 import { createRequire } from "node:module";
 function resolveVersion() {
-  if ("3.23.5") {
-    return "3.23.5";
+  if ("3.23.7") {
+    return "3.23.7";
   }
   try {
     const require2 = createRequire(import.meta.url);
@@ -27826,7 +27826,7 @@ var init_http_backend = __esm({
        * in cloud mode we ignore it and use this.sessionId (the cloud session).
        */
       async registerPeer(peerId, _sessionId, cwd, label, clientVersion, mode, _channelSessionId, capabilities, workspaceId, threadId, peerSecret) {
-        const path24 = PATHS.peers.replace(":sessionId", this.sessionId);
+        const path25 = PATHS.peers.replace(":sessionId", this.sessionId);
         const body = {
           peerId,
           cwd,
@@ -27857,7 +27857,7 @@ var init_http_backend = __esm({
         if (peerSecret !== void 0 && await relaySupports(this.http, "peer-ownership")) {
           body.peerSecret = peerSecret;
         }
-        return this.http.post(path24, body);
+        return this.http.post(path25, body);
       }
       /**
        * Deregister a peer from the cloud session.
@@ -27869,9 +27869,9 @@ var init_http_backend = __esm({
        * local mail creds. A 404 (peer not found) resolves to `{ removed: false, ... }`, not a throw.
        */
       async deregisterPeer(peerId) {
-        const path24 = PATHS.peer.replace(":sessionId", this.sessionId).replace(":peerId", peerId);
+        const path25 = PATHS.peer.replace(":sessionId", this.sessionId).replace(":peerId", peerId);
         try {
-          const headers = await this.http.delete(path24, {});
+          const headers = await this.http.delete(path25, {});
           const mailboxDeprovisioned = headers.get(MAILBOX_DEPROVISIONED_HEADER) === "true";
           return { removed: true, mailboxDeprovisioned };
         } catch (err) {
@@ -27895,8 +27895,8 @@ var init_http_backend = __esm({
        * GET /api/sessions/:sessionId/peers
        */
       async listPeers() {
-        const path24 = PATHS.peers.replace(":sessionId", this.sessionId);
-        const result = await this.http.get(path24);
+        const path25 = PATHS.peers.replace(":sessionId", this.sessionId);
+        const result = await this.http.get(path25);
         return result.peers;
       }
       /**
@@ -27904,8 +27904,8 @@ var init_http_backend = __esm({
        * Calls the lightweight heartbeat endpoint on the cloud relay server.
        */
       async updateLastSeen(peerId) {
-        const path24 = PATHS.heartbeat.replace(":sessionId", this.sessionId);
-        await this.http.post(path24, { peerId });
+        const path25 = PATHS.heartbeat.replace(":sessionId", this.sessionId);
+        await this.http.post(path25, { peerId });
       }
       /**
        * Record a message in the cloud session.
@@ -27916,7 +27916,7 @@ var init_http_backend = __esm({
        * the input record to construct a full MessageRecord.
        */
       async recordMessage(record2) {
-        const path24 = PATHS.messages.replace(":sessionId", this.sessionId);
+        const path25 = PATHS.messages.replace(":sessionId", this.sessionId);
         const body = {
           fromPeerId: record2.fromPeerId,
           toPeerId: record2.toPeerId,
@@ -27939,7 +27939,7 @@ var init_http_backend = __esm({
         if (record2.attachments && record2.attachments.length > 0) {
           body.attachments = record2.attachments;
         }
-        const resp = await this.http.post(path24, body);
+        const resp = await this.http.post(path25, body);
         return {
           ...record2,
           id: resp.id,
@@ -27953,7 +27953,7 @@ var init_http_backend = __esm({
        * Supports optional peerId filter and limit (default 300).
        */
       async getHistory(peerId, limit, includeRelayEchoes, metadataOnly, dedupInferredEchoes) {
-        const path24 = PATHS.messages.replace(":sessionId", this.sessionId);
+        const path25 = PATHS.messages.replace(":sessionId", this.sessionId);
         const query = {};
         if (peerId) {
           query.peerId = peerId;
@@ -27968,7 +27968,7 @@ var init_http_backend = __esm({
         if (dedupInferredEchoes) {
           query.dedupInferredEchoes = "true";
         }
-        const result = await this.http.get(path24, query);
+        const result = await this.http.get(path25, query);
         return result.messages;
       }
       /**
@@ -27979,12 +27979,12 @@ var init_http_backend = __esm({
        * so that get-history shows the actual response (not null).
        */
       async updateMessageResponse(messageId, response, durationMs, pending) {
-        const path24 = PATHS.message.replace(":sessionId", this.sessionId).replace(":messageId", messageId);
+        const path25 = PATHS.message.replace(":sessionId", this.sessionId).replace(":messageId", messageId);
         const body = { response, durationMs };
         if (pending === true) {
           body.pending = true;
         }
-        await this.http.patch(path24, body);
+        await this.http.patch(path25, body);
       }
       /**
        * Validate a session.
@@ -28126,8 +28126,8 @@ var init_http_client = __esm({
        * Perform an authenticated GET request.
        * Appends query parameters to the URL if provided.
        */
-      async get(path24, query) {
-        const url = new URL(path24, this.baseUrl);
+      async get(path25, query) {
+        const url = new URL(path25, this.baseUrl);
         if (query) {
           for (const [k, v] of Object.entries(query)) {
             url.searchParams.set(k, v);
@@ -28142,8 +28142,8 @@ var init_http_client = __esm({
       /**
        * Perform an authenticated POST request with a JSON body.
        */
-      async post(path24, body) {
-        const url = new URL(path24, this.baseUrl);
+      async post(path25, body) {
+        const url = new URL(path25, this.baseUrl);
         const resp = await this.fetchWithTimeout(url, {
           method: "POST",
           headers: this.headers(),
@@ -28161,8 +28161,8 @@ var init_http_client = __esm({
        * Perform an authenticated PATCH request with a JSON body.
        * Used to update existing resources (e.g., message response fields).
        */
-      async patch(path24, body) {
-        const url = new URL(path24, this.baseUrl);
+      async patch(path25, body) {
+        const url = new URL(path25, this.baseUrl);
         const resp = await this.fetchWithTimeout(url, {
           method: "PATCH",
           headers: this.headers(),
@@ -28187,8 +28187,8 @@ var init_http_client = __esm({
        * "Malformed JSON in request body" 400 from cogent-server <=3.1.2 when
        * any client (including third-party tools) DELETEd a peer without a body.
        */
-      async delete(path24, body) {
-        const url = new URL(path24, this.baseUrl);
+      async delete(path25, body) {
+        const url = new URL(path25, this.baseUrl);
         const headers = {
           "Authorization": `Bearer ${this.token}`
         };
@@ -32393,14 +32393,14 @@ var init_ws_client = __esm({
         if (this.pollTimer) return;
         const poll = async () => {
           try {
-            const path24 = `/api/sessions/${this.opts.sessionId}/poll`;
+            const path25 = `/api/sessions/${this.opts.sessionId}/poll`;
             const query = {
               peerId: this.opts.peerId
             };
             if (this.lastMessageId) {
               query.lastMessageId = this.lastMessageId;
             }
-            const result = await this.opts.http.get(path24, query);
+            const result = await this.opts.http.get(path25, query);
             if (result.messages && result.messages.length > 0) {
               this.opts.onMessages(result.messages);
               this.lastMessageId = result.messages[result.messages.length - 1].id;
@@ -33741,6 +33741,162 @@ var init_wake_ownership = __esm({
   }
 });
 
+// src/services/stale-bridge-reaper.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import fs18 from "node:fs";
+import path19 from "node:path";
+function isBridgeCommand(argv) {
+  if (!argv) return false;
+  if (/\.test\.|-test\.mjs|scripts\//.test(argv)) return false;
+  return /\/bridge\/cogent-bridge\.mjs(\s|$)/.test(argv) || // plugin bundle (Claude + codex)
+  /\/cogent-bridge(\s|$)/.test(argv) || // npx / global bin shim
+  /@essentialai\/cogent-bridge(-bundled)?\/dist\/(cli|index)\.js(\s|$)/.test(argv);
+}
+function versionFromArgv(argv) {
+  const m = argv.match(/\/cogent\/(\d+\.\d+\.\d+)\//);
+  return m ? m[1] : null;
+}
+function listProcesses() {
+  let out;
+  try {
+    out = execFileSync2("ps", ["-eo", "pid=,ppid=,lstart=,args="], {
+      encoding: "utf-8",
+      maxBuffer: 8 * 1024 * 1024,
+      timeout: 1e4
+    });
+  } catch (err) {
+    logger.debug(`stale-bridge-reaper: ps failed (${err.message})`);
+    return [];
+  }
+  const procs = [];
+  for (const line of out.split("\n")) {
+    const m = line.match(/^\s*(\d+)\s+(\d+)\s+(\S+\s+\S+\s+\S+\s+\S+\s+\S+)\s+(.*)$/);
+    if (!m) continue;
+    const started = Date.parse(m[3]);
+    procs.push({
+      pid: Number(m[1]),
+      ppid: Number(m[2]),
+      startedAt: Number.isFinite(started) ? started : NaN,
+      argv: m[4]
+    });
+  }
+  return procs;
+}
+function processCwd(pid) {
+  try {
+    if (process.platform === "linux") {
+      return path19.resolve(fs18.readlinkSync(`/proc/${pid}/cwd`));
+    }
+    if (process.platform === "darwin") {
+      const out = execFileSync2("lsof", ["-a", "-d", "cwd", "-p", String(pid), "-Fn"], {
+        encoding: "utf-8",
+        timeout: 1e4,
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      const line = out.split("\n").find((l) => l.startsWith("n"));
+      return line ? path19.resolve(line.slice(1)) : null;
+    }
+  } catch {
+  }
+  return null;
+}
+function canonicalPath(p) {
+  try {
+    return fs18.realpathSync(path19.resolve(p));
+  } catch {
+    return path19.resolve(p);
+  }
+}
+function ancestorsOf(pid, procs) {
+  const byPid = new Map(procs.map((p) => [p.pid, p]));
+  const seen = /* @__PURE__ */ new Set();
+  let cur = byPid.get(pid)?.ppid;
+  while (cur && cur > 1 && !seen.has(cur)) {
+    seen.add(cur);
+    cur = byPid.get(cur)?.ppid;
+  }
+  return seen;
+}
+function announcedPidsFor(cwd) {
+  const pids = /* @__PURE__ */ new Set();
+  try {
+    const base = path19.dirname(bridgeDirFor(cwd, "x"));
+    const prefix = path19.basename(bridgeDirFor(cwd, "x")).split(".")[0];
+    for (const dir of fs18.readdirSync(base)) {
+      if (!dir.startsWith(`${prefix}.`)) continue;
+      const peerId = dir.slice(prefix.length + 1);
+      for (const e of listLiveBridges(cwd, peerId)) pids.add(e.pid);
+    }
+  } catch {
+  }
+  return pids;
+}
+function findStaleBridges(cwd, procs = listProcesses(), opts = {}) {
+  const selfPid = opts.selfPid ?? process.pid;
+  const selfStartedAt = opts.selfStartedAt ?? Date.now() - Math.floor(process.uptime() * 1e3);
+  const cwdOf = opts.cwdOf ?? processCwd;
+  const announced = opts.announced ?? announcedPidsFor(cwd);
+  const target = canonicalPath(cwd);
+  const ancestors = ancestorsOf(selfPid, procs);
+  const out = [];
+  for (const p of procs) {
+    if (p.pid === selfPid) continue;
+    if (ancestors.has(p.pid)) continue;
+    if (!isBridgeCommand(p.argv)) continue;
+    if (announced.has(p.pid)) continue;
+    if (!Number.isFinite(p.startedAt) || p.startedAt >= selfStartedAt) continue;
+    const theirCwd = cwdOf(p.pid);
+    if (!theirCwd || canonicalPath(theirCwd) !== target) continue;
+    const ver = versionFromArgv(p.argv);
+    out.push({
+      proc: p,
+      reason: `pid ${p.pid}${ver ? ` (plugin ${ver})` : ""} is a cogent bridge in this exact checkout, started ${new Date(p.startedAt).toISOString()} \u2014 before this process \u2014 and has not announced itself, so it predates self-supersession and would keep waking this session forever`
+    });
+  }
+  return out;
+}
+function reaperEnabled(env = process.env) {
+  const v = env.COGENT_REAP_STALE_BRIDGES;
+  if (v === void 0 || v === "") return true;
+  return !/^(0|false|no|off)$/i.test(v.trim());
+}
+function reapStaleBridges(cwd, opts = {}) {
+  if (!reaperEnabled()) {
+    logger.debug("stale-bridge-reaper: disabled by COGENT_REAP_STALE_BRIDGES");
+    return [];
+  }
+  let candidates;
+  try {
+    candidates = findStaleBridges(cwd, listProcesses(), opts);
+  } catch (err) {
+    logger.warn(`stale-bridge-reaper: scan failed (${err.message}) \u2014 reaping nothing`);
+    return [];
+  }
+  const reaped = [];
+  for (const c2 of candidates) {
+    logger.warn(`Cogent: terminating a stale bridge \u2014 ${c2.reason}`);
+    try {
+      process.kill(c2.proc.pid, "SIGTERM");
+      reaped.push(c2);
+    } catch (err) {
+      logger.warn(`stale-bridge-reaper: could not signal pid ${c2.proc.pid}: ${err.message}`);
+    }
+  }
+  if (reaped.length) {
+    logger.warn(
+      `Cogent: reaped ${reaped.length} stale bridge process(es) left behind by an earlier plugin version. They could not stand down on their own because they predate 3.23.4.`
+    );
+  }
+  return reaped;
+}
+var init_stale_bridge_reaper = __esm({
+  "src/services/stale-bridge-reaper.ts"() {
+    "use strict";
+    init_logger();
+    init_wake_ownership();
+  }
+});
+
 // src/services/auto-relay.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 function buildStatusNotice(status, peerId, traceId) {
@@ -33883,6 +34039,7 @@ var init_auto_relay = __esm({
     init_wake_claim();
     init_wake_lock();
     init_wake_ownership();
+    init_stale_bridge_reaper();
     init_constants();
     init_logger();
     init_npm_update_check();
@@ -33932,6 +34089,8 @@ var init_auto_relay = __esm({
       processing = false;
       /** Senders already told this bridge is superseded — one notice each, not one per message. */
       supersededNotified = /* @__PURE__ */ new Set();
+      /** Reaping leftovers is a one-shot per process, not a per-registration action. */
+      reapedStaleBridges = false;
       queue = [];
       // Message ids to be handled inject-only (full-group-chat awareness) rather than
       // full-wake+reply. Shares the `processing` lock + `queue` so an awareness inject
@@ -33980,6 +34139,14 @@ var init_auto_relay = __esm({
         );
         announceBridge(cwd, peerId, CLIENT_VERSION, getConfig().COGENT_ENDPOINT ?? "local");
         this.supersededNotified.clear();
+        if (!this.reapedStaleBridges) {
+          this.reapedStaleBridges = true;
+          try {
+            reapStaleBridges(cwd);
+          } catch (err) {
+            logger.debug(`stale-bridge reap skipped: ${err.message}`);
+          }
+        }
       }
       /**
        * Emit one content-free wake-trace line (ids/decisions/timings only — NEVER
@@ -35101,8 +35268,8 @@ __export(startup_exports, {
   triggerReRegistration: () => triggerReRegistration
 });
 import os14 from "node:os";
-import path19 from "node:path";
-import fs18 from "node:fs/promises";
+import path20 from "node:path";
+import fs19 from "node:fs/promises";
 import readline2 from "node:readline";
 import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
@@ -35120,7 +35287,7 @@ function bindInboxNotifier() {
 }
 async function loadPersistedConfig() {
   try {
-    const raw = await fs18.readFile(PERSIST_PATH, "utf-8");
+    const raw = await fs19.readFile(PERSIST_PATH, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -35128,7 +35295,7 @@ async function loadPersistedConfig() {
 }
 async function savePersistedConfig(config2) {
   try {
-    await fs18.writeFile(PERSIST_PATH, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+    await fs19.writeFile(PERSIST_PATH, JSON.stringify(config2, null, 2) + "\n", "utf-8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     logger.warn(`Could not save config to ${PERSIST_PATH}: ${msg}`);
@@ -35163,11 +35330,11 @@ First run detected. Where should cogent-bridge store its data?
   });
 }
 async function validateStateDir(statePath) {
-  await fs18.mkdir(statePath, { recursive: true });
-  const testFile = path19.join(statePath, ".write-test");
+  await fs19.mkdir(statePath, { recursive: true });
+  const testFile = path20.join(statePath, ".write-test");
   try {
-    await fs18.writeFile(testFile, "test", "utf-8");
-    await fs18.unlink(testFile);
+    await fs19.writeFile(testFile, "test", "utf-8");
+    await fs19.unlink(testFile);
   } catch {
     throw new BridgeError(
       "STARTUP_FAILED" /* STARTUP_FAILED */,
@@ -35355,10 +35522,10 @@ async function runStartup() {
   if (envStatePath) {
     statePath = envStatePath;
   } else {
-    const defaultPath = path19.join(os14.homedir(), ".cogent");
+    const defaultPath = path20.join(os14.homedir(), ".cogent");
     statePath = await firstRunPrompt(defaultPath);
   }
-  if (!envStatePath && statePath !== path19.join(os14.homedir(), ".cogent")) {
+  if (!envStatePath && statePath !== path20.join(os14.homedir(), ".cogent")) {
     process.env.COGENT_STATE_PATH = statePath;
   } else if (!envStatePath) {
     process.env.COGENT_STATE_PATH = statePath;
@@ -35422,7 +35589,7 @@ async function runStartup() {
   }
   initLogger(
     config2.COGENT_LOG_LEVEL,
-    path19.join(config2.COGENT_STATE_PATH, "logs")
+    path20.join(config2.COGENT_STATE_PATH, "logs")
   );
   if (isCloud && effectiveSessionId && effectiveToken) {
     cloudInbox = new MessageInbox();
@@ -35484,7 +35651,7 @@ var init_startup = __esm({
     init_auto_relay();
     UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
     execFileAsync3 = promisify4(execFile5);
-    PERSIST_PATH = path19.join(os14.homedir(), ".cogent-config.json");
+    PERSIST_PATH = path20.join(os14.homedir(), ".cogent-config.json");
     legacyWarnEmitted = false;
     cloudWsClient = null;
     cloudInbox = null;
@@ -35499,12 +35666,12 @@ var init_startup = __esm({
 
 // src/cloud/mail-credential-store.ts
 import crypto9 from "node:crypto";
-import fs19 from "node:fs/promises";
-import path20 from "node:path";
+import fs20 from "node:fs/promises";
+import path21 from "node:path";
 import os15 from "node:os";
 function defaultMailCredentialPath(cwd = process.cwd()) {
-  const hash = crypto9.createHash("sha256").update(path20.resolve(cwd)).digest("hex").slice(0, 16);
-  return path20.join(os15.homedir(), ".cogent", "mail-credentials", `${hash}.json`);
+  const hash = crypto9.createHash("sha256").update(path21.resolve(cwd)).digest("hex").slice(0, 16);
+  return path21.join(os15.homedir(), ".cogent", "mail-credentials", `${hash}.json`);
 }
 function resolveMailCredentialPath(credentialPath) {
   if (credentialPath) return credentialPath;
@@ -35515,16 +35682,16 @@ function resolveMailCredentialPath(credentialPath) {
 async function loadMailCredentials(credentialPath) {
   const filePath = resolveMailCredentialPath(credentialPath);
   try {
-    return JSON.parse(await fs19.readFile(filePath, "utf-8"));
+    return JSON.parse(await fs20.readFile(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 async function saveMailCredentials(creds, credentialPath) {
   const filePath = resolveMailCredentialPath(credentialPath);
-  await fs19.mkdir(path20.dirname(filePath), { recursive: true, mode: 448 });
-  await fs19.writeFile(filePath, JSON.stringify(creds, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
-  await fs19.chmod(filePath, 384);
+  await fs20.mkdir(path21.dirname(filePath), { recursive: true, mode: 448 });
+  await fs20.writeFile(filePath, JSON.stringify(creds, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  await fs20.chmod(filePath, 384);
 }
 async function persistProvisionedMailbox(mailbox, credentialPath) {
   if (!mailbox?.address || !mailbox.password) return false;
@@ -35545,7 +35712,7 @@ async function persistProvisionedMailbox(mailbox, credentialPath) {
 async function clearMailCredentials(credentialPath) {
   const filePath = resolveMailCredentialPath(credentialPath);
   try {
-    await fs19.unlink(filePath);
+    await fs20.unlink(filePath);
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
@@ -35694,19 +35861,60 @@ function registerRegisterPeerTool(server) {
             storedPeerSecret = void 0;
           }
         }
-        const peer = await backend.registerPeer(
-          peerId,
-          sessionId,
-          cwd,
-          label,
-          CLIENT_VERSION,
-          mode,
-          channelSessionId,
-          capabilities,
-          workspaceId,
-          threadId,
-          storedPeerSecret
-        );
+        let peer;
+        try {
+          peer = await backend.registerPeer(
+            peerId,
+            sessionId,
+            cwd,
+            label,
+            CLIENT_VERSION,
+            mode,
+            channelSessionId,
+            capabilities,
+            workspaceId,
+            threadId,
+            storedPeerSecret
+          );
+        } catch (regErr) {
+          const msg = regErr instanceof Error ? regErr.message : String(regErr);
+          let recovered;
+          if (/PEER_NOT_YOURS/.test(msg) && isCloudMode()) {
+            try {
+              const creds = await loadCredentials();
+              if (creds?.ownerToken && creds.ownerToken !== creds.token && creds.endpoint && creds.sessionId) {
+                logger.warn(
+                  `register_peer: '${peerId}' is owned by an earlier token (its peerSecret was lost by a pre-3.23.5 re-join). Re-proving ownership with the stored owner token.`
+                );
+                const res = await fetch(`${creds.endpoint}/api/sessions/${creds.sessionId}/peers`, {
+                  method: "POST",
+                  headers: { "content-type": "application/json", authorization: `Bearer ${creds.ownerToken}` },
+                  body: JSON.stringify({
+                    peerId,
+                    cwd,
+                    label,
+                    type: "agent",
+                    clientVersion: CLIENT_VERSION,
+                    ...mode ? { mode } : {},
+                    ...capabilities ? { capabilities } : {}
+                  })
+                });
+                if (res.ok) {
+                  recovered = await res.json();
+                  const secret = recovered?.peerSecret;
+                  if (secret) {
+                    await saveCredentials({ ...creds, peerId, peerSecret: secret, savedAt: (/* @__PURE__ */ new Date()).toISOString() });
+                    logger.info(`register_peer: ownership reclaimed for '${peerId}'; a fresh peerSecret is stored.`);
+                  }
+                }
+              }
+            } catch (recoverErr) {
+              logger.debug(`register_peer: ownership recovery failed: ${recoverErr.message}`);
+            }
+          }
+          if (!recovered) throw regErr;
+          peer = recovered;
+        }
         if (isCloudMode()) {
           try {
             const creds = await loadCredentials();
@@ -37223,7 +37431,12 @@ function registerJoinSessionTool(server) {
           if (prior && prior.endpoint === endpoint && prior.sessionId === data.sessionId) {
             carried = {
               ...prior.peerId ? { peerId: prior.peerId } : {},
-              ...prior.peerSecret ? { peerSecret: prior.peerSecret } : {}
+              ...prior.peerSecret ? { peerSecret: prior.peerSecret } : {},
+              // Keep the token that owns the peer. A re-join mints a NEW one, and ownership is
+              // proven by the CREATING token (or its secret) — so overwriting this field is what
+              // turned a lost peerSecret into a permanent lockout. Prefer an ownerToken we are
+              // already carrying; only fall back to `prior.token` the first time.
+              ...prior.ownerToken || prior.token ? { ownerToken: prior.ownerToken ?? prior.token } : {}
             };
           }
         } catch (err) {
@@ -37510,8 +37723,8 @@ var require_cookies = __commonJS({
         if (urlparts.hostname !== cookie.domain && (cookie.domain.charAt(0) !== "." || ("." + urlparts.hostname).substr(-cookie.domain.length) !== cookie.domain)) {
           return false;
         }
-        let path24 = this.getPath(urlparts.pathname);
-        if (path24.substr(0, cookie.path.length) !== cookie.path) {
+        let path25 = this.getPath(urlparts.pathname);
+        if (path25.substr(0, cookie.path.length) !== cookie.path) {
           return false;
         }
         if (cookie.secure && urlparts.protocol !== "https:") {
@@ -37571,16 +37784,16 @@ var require_cookies = __commonJS({
        * @returns {String} Normalized path
        */
       getPath(pathname) {
-        let path24 = (pathname || "/").split("/");
-        path24.pop();
-        path24 = path24.join("/").trim();
-        if (path24.charAt(0) !== "/") {
-          path24 = "/" + path24;
+        let path25 = (pathname || "/").split("/");
+        path25.pop();
+        path25 = path25.join("/").trim();
+        if (path25.charAt(0) !== "/") {
+          path25 = "/" + path25;
         }
-        if (path24.substr(-1) !== "/") {
-          path24 += "/";
+        if (path25.substr(-1) !== "/") {
+          path25 += "/";
         }
-        return path24;
+        return path25;
       }
     };
     module.exports = Cookies;
@@ -37881,7 +38094,7 @@ var require_shared = __commonJS({
     "use strict";
     var urllib = __require("url");
     var util2 = __require("util");
-    var fs22 = __require("fs");
+    var fs23 = __require("fs");
     var nmfetch = require_fetch();
     var dns = __require("dns");
     var net = __require("net");
@@ -38267,7 +38480,7 @@ var require_shared = __commonJS({
           }
           return callback(null, parsedDataUri.data);
         } else if (content.path) {
-          return resolveStream(fs22.createReadStream(content.path), callback);
+          return resolveStream(fs23.createReadStream(content.path), callback);
         }
       }
       if (typeof data[key].content === "string" && !["utf8", "usascii", "ascii"].includes(encoding)) {
@@ -38391,7 +38604,7 @@ var require_shared = __commonJS({
 var require_mime_types = __commonJS({
   "node_modules/nodemailer/lib/mime-funcs/mime-types.js"(exports, module) {
     "use strict";
-    var path24 = __require("path");
+    var path25 = __require("path");
     var defaultMimeType = "application/octet-stream";
     var defaultExtension = "bin";
     var mimeTypes = /* @__PURE__ */ new Map([
@@ -40449,7 +40662,7 @@ var require_mime_types = __commonJS({
         if (!filename) {
           return defaultMimeType;
         }
-        let parsed = path24.parse(filename);
+        let parsed = path25.parse(filename);
         let extension = (parsed.ext.substr(1) || parsed.name || "").split("?").shift().trim().toLowerCase();
         let value = defaultMimeType;
         if (extensions.has(extension)) {
@@ -41851,7 +42064,7 @@ var require_mime_node = __commonJS({
   "node_modules/nodemailer/lib/mime-node/index.js"(exports, module) {
     "use strict";
     var crypto12 = __require("crypto");
-    var fs22 = __require("fs");
+    var fs23 = __require("fs");
     var punycode = require_punycode();
     var PassThrough = __require("stream").PassThrough;
     var shared = require_shared();
@@ -42566,7 +42779,7 @@ var require_mime_node = __commonJS({
             setImmediate(() => contentStream.emit("error", new Error("File access rejected for " + content.path)));
             return contentStream;
           }
-          return fs22.createReadStream(content.path);
+          return fs23.createReadStream(content.path);
         } else if (content && typeof content.href === "string") {
           if (this.disableUrlAccess) {
             contentStream = new PassThrough();
@@ -43587,8 +43800,8 @@ var require_dkim = __commonJS({
     var RelaxedBody = require_relaxed_body();
     var sign = require_sign();
     var PassThrough = __require("stream").PassThrough;
-    var fs22 = __require("fs");
-    var path24 = __require("path");
+    var fs23 = __require("fs");
+    var path25 = __require("path");
     var crypto12 = __require("crypto");
     var DKIM_ALGO = "sha256";
     var MAX_MESSAGE_SIZE = 128 * 1024;
@@ -43602,7 +43815,7 @@ var require_dkim = __commonJS({
         this.chunks = [];
         this.chunklen = 0;
         this.readPos = 0;
-        this.cachePath = this.cacheDir ? path24.join(this.cacheDir, "message." + Date.now() + "-" + crypto12.randomBytes(14).toString("hex")) : false;
+        this.cachePath = this.cacheDir ? path25.join(this.cacheDir, "message." + Date.now() + "-" + crypto12.randomBytes(14).toString("hex")) : false;
         this.cache = false;
         this.headers = false;
         this.bodyHash = false;
@@ -43622,10 +43835,10 @@ var require_dkim = __commonJS({
         if (!this.cache || !this.cachePath) {
           return;
         }
-        fs22.unlink(this.cachePath, () => false);
+        fs23.unlink(this.cachePath, () => false);
       }
       createReadCache() {
-        this.cache = fs22.createReadStream(this.cachePath);
+        this.cache = fs23.createReadStream(this.cachePath);
         this.cache.once("error", (err) => {
           this.cleanup();
           this.output.emit("error", err);
@@ -43681,7 +43894,7 @@ var require_dkim = __commonJS({
       }
       createWriteCache() {
         this.output.usingCache = true;
-        this.cache = fs22.createWriteStream(this.cachePath);
+        this.cache = fs23.createWriteStream(this.cachePath);
         this.cache.once("error", (err) => {
           this.cleanup();
           this.relaxedBody.unpipe(this.cache);
@@ -48570,13 +48783,13 @@ var require_nodemailer = __commonJS({
 });
 
 // src/mail/mail-sender.ts
-import fs20 from "node:fs/promises";
-import path21 from "node:path";
+import fs21 from "node:fs/promises";
+import path22 from "node:path";
 async function buildAndSendMail(sender, creds, params) {
   const attachments = [];
   for (const p of params.attachmentPaths ?? []) {
-    const content = await fs20.readFile(p);
-    attachments.push({ filename: path21.basename(p), content });
+    const content = await fs21.readFile(p);
+    attachments.push({ filename: path22.basename(p), content });
   }
   const { messageId } = await sender.send({
     from: creds.address,
@@ -48965,8 +49178,8 @@ var require_req = __commonJS({
       if (req.originalUrl) {
         _req.url = req.originalUrl;
       } else {
-        const path24 = req.path;
-        _req.url = typeof path24 === "string" ? path24 : req.url ? req.url.path || req.url : void 0;
+        const path25 = req.path;
+        _req.url = typeof path25 === "string" ? path25 : req.url ? req.url.path || req.url : void 0;
       }
       if (req.query) {
         _req.query = req.query;
@@ -49131,14 +49344,14 @@ var require_redact = __commonJS({
       }
       return obj;
     }
-    function parsePath(path24) {
+    function parsePath(path25) {
       const parts = [];
       let current = "";
       let inBrackets = false;
       let inQuotes = false;
       let quoteChar = "";
-      for (let i = 0; i < path24.length; i++) {
-        const char = path24[i];
+      for (let i = 0; i < path25.length; i++) {
+        const char = path25[i];
         if (!inBrackets && char === ".") {
           if (current) {
             parts.push(current);
@@ -49269,10 +49482,10 @@ var require_redact = __commonJS({
       return current;
     }
     function redactPaths(obj, paths, censor, remove = false) {
-      for (const path24 of paths) {
-        const parts = parsePath(path24);
+      for (const path25 of paths) {
+        const parts = parsePath(path25);
         if (parts.includes("*")) {
-          redactWildcardPath(obj, parts, censor, path24, remove);
+          redactWildcardPath(obj, parts, censor, path25, remove);
         } else {
           if (remove) {
             removeKey(obj, parts);
@@ -49357,8 +49570,8 @@ var require_redact = __commonJS({
           }
         } else {
           if (afterWildcard.includes("*")) {
-            const wrappedCensor = typeof censor === "function" ? (value, path24) => {
-              const fullPath = [...pathArray.slice(0, pathLength), ...path24];
+            const wrappedCensor = typeof censor === "function" ? (value, path25) => {
+              const fullPath = [...pathArray.slice(0, pathLength), ...path25];
               return censor(value, fullPath);
             } : censor;
             redactWildcardPath(current, afterWildcard, wrappedCensor, originalPath, remove);
@@ -49393,8 +49606,8 @@ var require_redact = __commonJS({
         return null;
       }
       const pathStructure = /* @__PURE__ */ new Map();
-      for (const path24 of pathsToClone) {
-        const parts = parsePath(path24);
+      for (const path25 of pathsToClone) {
+        const parts = parsePath(path25);
         let current = pathStructure;
         for (let i = 0; i < parts.length; i++) {
           const part = parts[i];
@@ -49446,24 +49659,24 @@ var require_redact = __commonJS({
       }
       return cloneSelectively(obj, pathStructure);
     }
-    function validatePath(path24) {
-      if (typeof path24 !== "string") {
+    function validatePath(path25) {
+      if (typeof path25 !== "string") {
         throw new Error("Paths must be (non-empty) strings");
       }
-      if (path24 === "") {
+      if (path25 === "") {
         throw new Error("Invalid redaction path ()");
       }
-      if (path24.includes("..")) {
-        throw new Error(`Invalid redaction path (${path24})`);
+      if (path25.includes("..")) {
+        throw new Error(`Invalid redaction path (${path25})`);
       }
-      if (path24.includes(",")) {
-        throw new Error(`Invalid redaction path (${path24})`);
+      if (path25.includes(",")) {
+        throw new Error(`Invalid redaction path (${path25})`);
       }
       let bracketCount = 0;
       let inQuotes = false;
       let quoteChar = "";
-      for (let i = 0; i < path24.length; i++) {
-        const char = path24[i];
+      for (let i = 0; i < path25.length; i++) {
+        const char = path25[i];
         if ((char === '"' || char === "'") && bracketCount > 0) {
           if (!inQuotes) {
             inQuotes = true;
@@ -49477,20 +49690,20 @@ var require_redact = __commonJS({
         } else if (char === "]" && !inQuotes) {
           bracketCount--;
           if (bracketCount < 0) {
-            throw new Error(`Invalid redaction path (${path24})`);
+            throw new Error(`Invalid redaction path (${path25})`);
           }
         }
       }
       if (bracketCount !== 0) {
-        throw new Error(`Invalid redaction path (${path24})`);
+        throw new Error(`Invalid redaction path (${path25})`);
       }
     }
     function validatePaths(paths) {
       if (!Array.isArray(paths)) {
         throw new TypeError("paths must be an array");
       }
-      for (const path24 of paths) {
-        validatePath(path24);
+      for (const path25 of paths) {
+        validatePath(path25);
       }
     }
     function slowRedact(options = {}) {
@@ -49658,8 +49871,8 @@ var require_redaction = __commonJS({
         if (shape[k] === null) {
           o[k] = (value) => topCensor(value, [k]);
         } else {
-          const wrappedCensor = typeof censor === "function" ? (value, path24) => {
-            return censor(value, [k, ...path24]);
+          const wrappedCensor = typeof censor === "function" ? (value, path25) => {
+            return censor(value, [k, ...path25]);
           } : censor;
           o[k] = Redact({
             paths: shape[k],
@@ -49877,10 +50090,10 @@ var require_atomic_sleep = __commonJS({
 var require_sonic_boom = __commonJS({
   "node_modules/sonic-boom/index.js"(exports, module) {
     "use strict";
-    var fs22 = __require("fs");
+    var fs23 = __require("fs");
     var EventEmitter = __require("events");
     var inherits = __require("util").inherits;
-    var path24 = __require("path");
+    var path25 = __require("path");
     var sleep4 = require_atomic_sleep();
     var assert2 = __require("assert");
     var BUSY_WRITE_TIMEOUT = 100;
@@ -49934,20 +50147,20 @@ var require_sonic_boom = __commonJS({
       const mode = sonic.mode;
       if (sonic.sync) {
         try {
-          if (sonic.mkdir) fs22.mkdirSync(path24.dirname(file), { recursive: true });
-          const fd = fs22.openSync(file, flags, mode);
+          if (sonic.mkdir) fs23.mkdirSync(path25.dirname(file), { recursive: true });
+          const fd = fs23.openSync(file, flags, mode);
           fileOpened(null, fd);
         } catch (err) {
           fileOpened(err);
           throw err;
         }
       } else if (sonic.mkdir) {
-        fs22.mkdir(path24.dirname(file), { recursive: true }, (err) => {
+        fs23.mkdir(path25.dirname(file), { recursive: true }, (err) => {
           if (err) return fileOpened(err);
-          fs22.open(file, flags, mode, fileOpened);
+          fs23.open(file, flags, mode, fileOpened);
         });
       } else {
-        fs22.open(file, flags, mode, fileOpened);
+        fs23.open(file, flags, mode, fileOpened);
       }
     }
     function SonicBoom(opts) {
@@ -49988,8 +50201,8 @@ var require_sonic_boom = __commonJS({
         this.flush = flushBuffer;
         this.flushSync = flushBufferSync;
         this._actualWrite = actualWriteBuffer;
-        fsWriteSync = () => fs22.writeSync(this.fd, this._writingBuf);
-        fsWrite = () => fs22.write(this.fd, this._writingBuf, this.release);
+        fsWriteSync = () => fs23.writeSync(this.fd, this._writingBuf);
+        fsWrite = () => fs23.write(this.fd, this._writingBuf, this.release);
       } else if (contentMode === void 0 || contentMode === kContentModeUtf8) {
         this._writingBuf = "";
         this.write = write;
@@ -49998,15 +50211,15 @@ var require_sonic_boom = __commonJS({
         this._actualWrite = actualWrite;
         fsWriteSync = () => {
           if (Buffer.isBuffer(this._writingBuf)) {
-            return fs22.writeSync(this.fd, this._writingBuf);
+            return fs23.writeSync(this.fd, this._writingBuf);
           }
-          return fs22.writeSync(this.fd, this._writingBuf, "utf8");
+          return fs23.writeSync(this.fd, this._writingBuf, "utf8");
         };
         fsWrite = () => {
           if (Buffer.isBuffer(this._writingBuf)) {
-            return fs22.write(this.fd, this._writingBuf, this.release);
+            return fs23.write(this.fd, this._writingBuf, this.release);
           }
-          return fs22.write(this.fd, this._writingBuf, "utf8", this.release);
+          return fs23.write(this.fd, this._writingBuf, "utf8", this.release);
         };
       } else {
         throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
@@ -50063,7 +50276,7 @@ var require_sonic_boom = __commonJS({
           }
         }
         if (this._fsync) {
-          fs22.fsyncSync(this.fd);
+          fs23.fsyncSync(this.fd);
         }
         const len = this._len;
         if (this._reopening) {
@@ -50177,7 +50390,7 @@ var require_sonic_boom = __commonJS({
       const onDrain = () => {
         if (!this._fsync) {
           try {
-            fs22.fsync(this.fd, (err) => {
+            fs23.fsync(this.fd, (err) => {
               this._flushPending = false;
               cb(err);
             });
@@ -50279,7 +50492,7 @@ var require_sonic_boom = __commonJS({
       const fd = this.fd;
       this.once("ready", () => {
         if (fd !== this.fd) {
-          fs22.close(fd, (err) => {
+          fs23.close(fd, (err) => {
             if (err) {
               return this.emit("error", err);
             }
@@ -50328,7 +50541,7 @@ var require_sonic_boom = __commonJS({
           buf = this._bufs[0];
         }
         try {
-          const n = Buffer.isBuffer(buf) ? fs22.writeSync(this.fd, buf) : fs22.writeSync(this.fd, buf, "utf8");
+          const n = Buffer.isBuffer(buf) ? fs23.writeSync(this.fd, buf) : fs23.writeSync(this.fd, buf, "utf8");
           const releasedBufObj = releaseWritingBuf(buf, this._len, n);
           buf = releasedBufObj.writingBuf;
           this._len = releasedBufObj.len;
@@ -50344,7 +50557,7 @@ var require_sonic_boom = __commonJS({
         }
       }
       try {
-        fs22.fsyncSync(this.fd);
+        fs23.fsyncSync(this.fd);
       } catch {
       }
     }
@@ -50365,7 +50578,7 @@ var require_sonic_boom = __commonJS({
           buf = mergeBuf(this._bufs[0], this._lens[0]);
         }
         try {
-          const n = fs22.writeSync(this.fd, buf);
+          const n = fs23.writeSync(this.fd, buf);
           buf = buf.subarray(n);
           this._len = Math.max(this._len - n, 0);
           if (buf.length <= 0) {
@@ -50393,13 +50606,13 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf.length ? this._writingBuf : this._bufs.shift() || "";
       if (this.sync) {
         try {
-          const written = Buffer.isBuffer(this._writingBuf) ? fs22.writeSync(this.fd, this._writingBuf) : fs22.writeSync(this.fd, this._writingBuf, "utf8");
+          const written = Buffer.isBuffer(this._writingBuf) ? fs23.writeSync(this.fd, this._writingBuf) : fs23.writeSync(this.fd, this._writingBuf, "utf8");
           release(null, written);
         } catch (err) {
           release(err);
         }
       } else {
-        fs22.write(this.fd, this._writingBuf, release);
+        fs23.write(this.fd, this._writingBuf, release);
       }
     }
     function actualWriteBuffer() {
@@ -50408,7 +50621,7 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf.length ? this._writingBuf : mergeBuf(this._bufs.shift(), this._lens.shift());
       if (this.sync) {
         try {
-          const written = fs22.writeSync(this.fd, this._writingBuf);
+          const written = fs23.writeSync(this.fd, this._writingBuf);
           release(null, written);
         } catch (err) {
           release(err);
@@ -50417,7 +50630,7 @@ var require_sonic_boom = __commonJS({
         if (kCopyBuffer) {
           this._writingBuf = Buffer.from(this._writingBuf);
         }
-        fs22.write(this.fd, this._writingBuf, release);
+        fs23.write(this.fd, this._writingBuf, release);
       }
     }
     function actualClose(sonic) {
@@ -50433,12 +50646,12 @@ var require_sonic_boom = __commonJS({
       sonic._lens = [];
       assert2(typeof sonic.fd === "number", `sonic.fd must be a number, got ${typeof sonic.fd}`);
       try {
-        fs22.fsync(sonic.fd, closeWrapped);
+        fs23.fsync(sonic.fd, closeWrapped);
       } catch {
       }
       function closeWrapped() {
         if (sonic.fd !== 1 && sonic.fd !== 2) {
-          fs22.close(sonic.fd, done);
+          fs23.close(sonic.fd, done);
         } else {
           done();
         }
@@ -51274,15 +51487,15 @@ var require_transport = __commonJS({
       if (!unquoted) {
         return false;
       }
-      let path24 = unquoted;
-      if (path24.startsWith("file://")) {
+      let path25 = unquoted;
+      if (path25.startsWith("file://")) {
         try {
-          path24 = fileURLToPath(path24);
+          path25 = fileURLToPath(path25);
         } catch {
           return false;
         }
       }
-      return isAbsolute(path24) && !existsSync(path24);
+      return isAbsolute(path25) && !existsSync(path25);
     }
     function stripQuotes(value) {
       const first = value[0];
@@ -85349,15 +85562,15 @@ var require_tools2 = __commonJS({
        * @param {String} path - Mailbox path to encode
        * @returns {String} Encoded mailbox path
        */
-      encodePath(connection, path24) {
-        path24 = (path24 || "").toString();
-        if (!connection.enabled.has("UTF8=ACCEPT") && !tools.isRev2Active(connection) && /[&\x00-\x08\x0b-\x0c\x0e-\x1f\u0080-\uffff]/.test(path24)) {
+      encodePath(connection, path25) {
+        path25 = (path25 || "").toString();
+        if (!connection.enabled.has("UTF8=ACCEPT") && !tools.isRev2Active(connection) && /[&\x00-\x08\x0b-\x0c\x0e-\x1f\u0080-\uffff]/.test(path25)) {
           try {
-            path24 = iconv.encode(path24, "utf-7-imap").toString();
+            path25 = iconv.encode(path25, "utf-7-imap").toString();
           } catch {
           }
         }
-        return path24;
+        return path25;
       },
       /**
        * Decodes a mailbox path from modified UTF-7 if the server does not support UTF8=ACCEPT.
@@ -85366,15 +85579,15 @@ var require_tools2 = __commonJS({
        * @param {String} path - Mailbox path to decode
        * @returns {String} Decoded mailbox path
        */
-      decodePath(connection, path24) {
-        path24 = (path24 || "").toString();
-        if (!connection.enabled.has("UTF8=ACCEPT") && !tools.isRev2Active(connection) && /[&]/.test(path24)) {
+      decodePath(connection, path25) {
+        path25 = (path25 || "").toString();
+        if (!connection.enabled.has("UTF8=ACCEPT") && !tools.isRev2Active(connection) && /[&]/.test(path25)) {
           try {
-            path24 = iconv.decode(Buffer.from(path24), "utf-7-imap").toString();
+            path25 = iconv.decode(Buffer.from(path25), "utf-7-imap").toString();
           } catch {
           }
         }
-        return path24;
+        return path25;
       },
       /**
        * Normalizes a mailbox path by joining array segments with the namespace delimiter,
@@ -85385,17 +85598,17 @@ var require_tools2 = __commonJS({
        * @param {Boolean} [skipNamespace] - If true, skips prepending the namespace prefix
        * @returns {String} Normalized mailbox path
        */
-      normalizePath(connection, path24, skipNamespace) {
-        if (Array.isArray(path24)) {
-          path24 = path24.join(connection.namespace && connection.namespace.delimiter || "");
+      normalizePath(connection, path25, skipNamespace) {
+        if (Array.isArray(path25)) {
+          path25 = path25.join(connection.namespace && connection.namespace.delimiter || "");
         }
-        if (path24.toUpperCase() === "INBOX") {
+        if (path25.toUpperCase() === "INBOX") {
           return "INBOX";
         }
-        if (!skipNamespace && connection.namespace && connection.namespace.prefix && !path24.startsWith(connection.namespace.prefix)) {
-          path24 = connection.namespace.prefix + path24;
+        if (!skipNamespace && connection.namespace && connection.namespace.prefix && !path25.startsWith(connection.namespace.prefix)) {
+          path25 = connection.namespace.prefix + path25;
         }
-        return path24;
+        return path25;
       },
       /**
        * Compares two mailbox paths for equality after normalization.
@@ -85726,14 +85939,14 @@ var require_tools2 = __commonJS({
           }
         }
         if (map.emailId || map.uid) {
-          let path24 = mailbox.path;
-          if (/[\u0080-\uffff]/.test(path24)) {
+          let path25 = mailbox.path;
+          if (/[\u0080-\uffff]/.test(path25)) {
             try {
-              path24 = iconv.encode(path24, "utf-7-imap").toString();
+              path25 = iconv.encode(path25, "utf-7-imap").toString();
             } catch {
             }
           }
-          map.id = map.emailId || createHash2("md5").update([path24, mailbox.uidValidity?.toString() || "", map.uid.toString()].join(":")).digest("hex");
+          map.id = map.emailId || createHash2("md5").update([path25, mailbox.uidValidity?.toString() || "", map.uid.toString()].join(":")).digest("hex");
         }
         if (map.flags) {
           let flagColor = tools.getFlagColor(map.flags);
@@ -85908,16 +86121,16 @@ var require_tools2 = __commonJS({
        * @returns {Object} Parsed body structure tree with part numbers, types, parameters, and child nodes
        */
       parseBodystructure(entry) {
-        let walk = (node, path24) => {
-          path24 = path24 || [];
+        let walk = (node, path25) => {
+          path25 = path25 || [];
           let curNode = {}, i = 0, part = 0;
-          if (path24.length) {
-            curNode.part = path24.join(".");
+          if (path25.length) {
+            curNode.part = path25.join(".");
           }
           if (Array.isArray(node[0])) {
             curNode.childNodes = [];
             while (Array.isArray(node[i])) {
-              curNode.childNodes.push(walk(node[i], path24.concat(++part)));
+              curNode.childNodes.push(walk(node[i], path25.concat(++part)));
               i++;
             }
             curNode.type = "multipart/" + ((node[i++] || {}).value || "").toString().toLowerCase();
@@ -85960,7 +86173,7 @@ var require_tools2 = __commonJS({
                   // the encapsulated message shares the part number with its wrapper.
                   // Distinction is via suffixes: path.MIME = wrapper headers,
                   // path.HEADER = encapsulated message headers.
-                  walk(node[i], path24)
+                  walk(node[i], path25)
                 ];
               }
               i++;
@@ -87922,14 +88135,14 @@ var require_select = __commonJS({
       // update into a silent no-op for the rest of the session.
       permanentflags: { key: "permanentFlags", parse: (value) => Array.isArray(value) && new Set(value) }
     });
-    module.exports = async (connection, path24, options) => {
+    module.exports = async (connection, path25, options) => {
       if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
         return;
       }
       options = options || {};
-      path24 = normalizePath(connection, path24);
-      if (!connection.folders.has(path24)) {
-        let folders = await connection.run("LIST", "", path24);
+      path25 = normalizePath(connection, path25);
+      if (!connection.folders.has(path25)) {
+        let folders = await connection.run("LIST", "", path25);
         if (!folders) {
           throw new Error("Failed to fetch folders");
         }
@@ -87937,10 +88150,10 @@ var require_select = __commonJS({
           connection.folders.set(folder.path, folder);
         });
       }
-      let folderListData = connection.folders.has(path24) ? connection.folders.get(path24) : false;
+      let folderListData = connection.folders.has(path25) ? connection.folders.get(path25) : false;
       let response;
       try {
-        let map = { path: path24 };
+        let map = { path: path25 };
         if (folderListData) {
           ["delimiter", "specialUse", "subscribed", "listed"].forEach((key) => {
             if (folderListData[key]) {
@@ -87959,7 +88172,7 @@ var require_select = __commonJS({
           ]);
           map.qresync = true;
         }
-        let encodedPath = encodePath(connection, path24);
+        let encodedPath = encodePath(connection, path25);
         let selectCommand = {
           command: !options.readOnly ? "SELECT" : "EXAMINE",
           /* c8 ignore next */
@@ -88019,12 +88232,12 @@ var require_select = __commonJS({
             // since the client's last known state. Only received when QRESYNC was requested.
             // A dummy mailbox object is passed because the mailbox isn't officially open yet.
             VANISHED: async (untagged) => {
-              await connection.untaggedVanished(untagged, { path: path24, uidNext: false, uidValidity: false });
+              await connection.untaggedVanished(untagged, { path: path25, uidNext: false, uidValidity: false });
             },
             // Untagged FETCH during SELECT/EXAMINE: only occurs with QRESYNC, delivering
             // updated flags for messages that changed since the client's last modseq.
             FETCH: async (untagged) => {
-              await connection.untaggedFetch(untagged, { path: path24, uidNext: false, uidValidity: false });
+              await connection.untaggedFetch(untagged, { path: path25, uidNext: false, uidValidity: false });
             }
           }
         });
@@ -88038,13 +88251,13 @@ var require_select = __commonJS({
         }
         let currentMailbox = connection.mailbox;
         connection.mailbox = false;
-        if (currentMailbox && currentMailbox.path !== path24) {
+        if (currentMailbox && currentMailbox.path !== path25) {
           connection.emit("mailboxClose", currentMailbox);
         }
         connection.mailbox = map;
         connection.currentSelectCommand = selectCommand;
         connection.state = connection.states.SELECTED;
-        if (!currentMailbox || currentMailbox.path !== path24) {
+        if (!currentMailbox || currentMailbox.path !== path25) {
           connection.emit("mailboxOpen", connection.mailbox);
         }
         response.next();
@@ -88259,17 +88472,17 @@ var require_create = __commonJS({
   "node_modules/imapflow/lib/commands/create.js"(exports, module) {
     "use strict";
     var { encodePath, normalizePath, getStatusCode, enhanceCommandError } = require_tools2();
-    module.exports = async (connection, path24) => {
+    module.exports = async (connection, path25) => {
       if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
         return;
       }
-      path24 = normalizePath(connection, path24);
+      path25 = normalizePath(connection, path25);
       let response;
       try {
         let map = {
-          path: path24
+          path: path25
         };
-        response = await connection.exec("CREATE", [{ type: "ATOM", value: encodePath(connection, path24) }]);
+        response = await connection.exec("CREATE", [{ type: "ATOM", value: encodePath(connection, path25) }]);
         let section = response.response.attributes && response.response.attributes[0] && response.response.attributes[0].section && response.response.attributes[0].section.length ? response.response.attributes[0].section : false;
         if (section) {
           let key;
@@ -88295,13 +88508,13 @@ var require_create = __commonJS({
         }
         map.created = true;
         response.next();
-        await connection.run("SUBSCRIBE", path24);
+        await connection.run("SUBSCRIBE", path25);
         return map;
       } catch (err) {
         let errorCode = getStatusCode(err.response);
         if (errorCode === "ALREADYEXISTS") {
           return {
-            path: path24,
+            path: path25,
             created: false
           };
         }
@@ -88318,20 +88531,20 @@ var require_delete = __commonJS({
   "node_modules/imapflow/lib/commands/delete.js"(exports, module) {
     "use strict";
     var { encodePath, normalizePath, enhanceCommandError } = require_tools2();
-    module.exports = async (connection, path24) => {
+    module.exports = async (connection, path25) => {
       if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
         return;
       }
-      path24 = normalizePath(connection, path24);
-      if (connection.state === connection.states.SELECTED && connection.mailbox.path === path24) {
+      path25 = normalizePath(connection, path25);
+      if (connection.state === connection.states.SELECTED && connection.mailbox.path === path25) {
         await connection.run("CLOSE");
       }
       let response;
       try {
         let map = {
-          path: path24
+          path: path25
         };
-        response = await connection.exec("DELETE", [{ type: "ATOM", value: encodePath(connection, path24) }]);
+        response = await connection.exec("DELETE", [{ type: "ATOM", value: encodePath(connection, path25) }]);
         response.next();
         return map;
       } catch (err) {
@@ -88348,23 +88561,23 @@ var require_rename = __commonJS({
   "node_modules/imapflow/lib/commands/rename.js"(exports, module) {
     "use strict";
     var { encodePath, normalizePath, enhanceCommandError } = require_tools2();
-    module.exports = async (connection, path24, newPath) => {
+    module.exports = async (connection, path25, newPath) => {
       if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
         return;
       }
-      path24 = normalizePath(connection, path24);
+      path25 = normalizePath(connection, path25);
       newPath = normalizePath(connection, newPath);
-      if (connection.state === connection.states.SELECTED && connection.mailbox.path === path24) {
+      if (connection.state === connection.states.SELECTED && connection.mailbox.path === path25) {
         await connection.run("CLOSE");
       }
       let response;
       try {
         let map = {
-          path: path24,
+          path: path25,
           newPath
         };
         response = await connection.exec("RENAME", [
-          { type: "ATOM", value: encodePath(connection, path24) },
+          { type: "ATOM", value: encodePath(connection, path25) },
           { type: "ATOM", value: encodePath(connection, newPath) }
         ]);
         response.next();
@@ -88411,14 +88624,14 @@ var require_subscribe = __commonJS({
   "node_modules/imapflow/lib/commands/subscribe.js"(exports, module) {
     "use strict";
     var { encodePath, normalizePath, enhanceCommandError } = require_tools2();
-    module.exports = async (connection, path24) => {
+    module.exports = async (connection, path25) => {
       if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
         return;
       }
-      path24 = normalizePath(connection, path24);
+      path25 = normalizePath(connection, path25);
       let response;
       try {
-        response = await connection.exec("SUBSCRIBE", [{ type: "ATOM", value: encodePath(connection, path24) }]);
+        response = await connection.exec("SUBSCRIBE", [{ type: "ATOM", value: encodePath(connection, path25) }]);
         response.next();
         return true;
       } catch (err) {
@@ -88435,14 +88648,14 @@ var require_unsubscribe = __commonJS({
   "node_modules/imapflow/lib/commands/unsubscribe.js"(exports, module) {
     "use strict";
     var { encodePath, normalizePath, enhanceCommandError } = require_tools2();
-    module.exports = async (connection, path24) => {
+    module.exports = async (connection, path25) => {
       if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
         return;
       }
-      path24 = normalizePath(connection, path24);
+      path25 = normalizePath(connection, path25);
       let response;
       try {
-        response = await connection.exec("UNSUBSCRIBE", [{ type: "ATOM", value: encodePath(connection, path24) }]);
+        response = await connection.exec("UNSUBSCRIBE", [{ type: "ATOM", value: encodePath(connection, path25) }]);
         response.next();
         return true;
       } catch (err) {
@@ -89248,11 +89461,11 @@ var require_status = __commonJS({
     var { encodePath, normalizePath, buildStatusQueryAttributes, isRev2Active } = require_tools2();
     var { parseStatusList } = require_status_fields();
     var MAILBOX_UPDATERS = {
-      messages: (value, connection, path24) => {
+      messages: (value, connection, path25) => {
         let prevCount = connection.mailbox.exists;
         if (prevCount !== value) {
           connection.mailbox.exists = value;
-          connection.emit("exists", { path: path24, count: value, prevCount });
+          connection.emit("exists", { path: path25, count: value, prevCount });
         }
       },
       uidNext: (value, connection) => {
@@ -89262,28 +89475,28 @@ var require_status = __commonJS({
         connection.mailbox.highestModseq = value;
       }
     };
-    module.exports = async (connection, path24, query) => {
-      if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state) || !path24) {
+    module.exports = async (connection, path25, query) => {
+      if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state) || !path25) {
         return false;
       }
-      path24 = normalizePath(connection, path24);
-      let encodedPath = encodePath(connection, path24);
+      path25 = normalizePath(connection, path25);
+      let encodedPath = encodePath(connection, path25);
       let attributes = [{ type: encodedPath.indexOf("&") >= 0 ? "STRING" : "ATOM", value: encodedPath }];
       let queryAttributes = buildStatusQueryAttributes(connection, query);
       let syntheticRecent = query && query.recent && isRev2Active(connection);
       if (!queryAttributes.length) {
-        return syntheticRecent ? { path: path24, recent: 0 } : false;
+        return syntheticRecent ? { path: path25, recent: 0 } : false;
       }
       attributes.push(queryAttributes);
       let response;
       try {
-        let map = { path: path24 };
+        let map = { path: path25 };
         response = await connection.exec("STATUS", attributes, {
           untagged: {
             // STATUS response: * STATUS <mailbox> (<key> <value> <key> <value> ...)
             // Parsed as alternating key-value pairs (i % 2 pattern).
             STATUS: async (untagged) => {
-              let updateCurrent = connection.state === connection.states.SELECTED && path24 === connection.mailbox.path;
+              let updateCurrent = connection.state === connection.states.SELECTED && path25 === connection.mailbox.path;
               let list = untagged.attributes && Array.isArray(untagged.attributes[1]) ? untagged.attributes[1] : false;
               if (!list) {
                 return;
@@ -89291,7 +89504,7 @@ var require_status = __commonJS({
               parseStatusList(list, (key, value) => {
                 map[key] = value;
                 if (updateCurrent && MAILBOX_UPDATERS[key]) {
-                  MAILBOX_UPDATERS[key](value, connection, path24);
+                  MAILBOX_UPDATERS[key](value, connection, path25);
                 }
               });
             }
@@ -89304,9 +89517,9 @@ var require_status = __commonJS({
         return map;
       } catch (err) {
         if (err.responseStatus === "NO") {
-          let folders = await connection.run("LIST", "", path24, { listOnly: true });
+          let folders = await connection.run("LIST", "", path25, { listOnly: true });
           if (folders && !folders.length) {
-            let error2 = new Error(`Mailbox doesn't exist: ${path24}`);
+            let error2 = new Error(`Mailbox doesn't exist: ${path25}`);
             error2.code = "NotFound";
             error2.response = err;
             throw error2;
@@ -89453,15 +89666,15 @@ var require_quota = __commonJS({
   "node_modules/imapflow/lib/commands/quota.js"(exports, module) {
     "use strict";
     var { encodePath, normalizePath, enhanceCommandError, parseUintValue, isUnsafeKey } = require_tools2();
-    module.exports = async (connection, path24) => {
-      if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state) || !path24) {
+    module.exports = async (connection, path25) => {
+      if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state) || !path25) {
         return;
       }
       if (!connection.capabilities.has("QUOTA")) {
         return false;
       }
-      path24 = normalizePath(connection, path24);
-      let map = { path: path24 };
+      path25 = normalizePath(connection, path25);
+      let map = { path: path25 };
       let processQuotaResponse = (untagged) => {
         let attributes = untagged.attributes && untagged.attributes[1];
         if (!attributes || !attributes.length) {
@@ -89501,7 +89714,7 @@ var require_quota = __commonJS({
       let quotaFound = false;
       let response;
       try {
-        response = await connection.exec("GETQUOTAROOT", [{ type: "ATOM", value: encodePath(connection, path24) }], {
+        response = await connection.exec("GETQUOTAROOT", [{ type: "ATOM", value: encodePath(connection, path25) }], {
           untagged: {
             // QUOTAROOT response tells us which quota root applies to this mailbox.
             // A mailbox may have zero or one quota root.
@@ -89644,15 +89857,15 @@ var require_idle = __commonJS({
       }
     }
     async function pollOnce2(connection, session) {
-      let path24 = connection.mailbox && connection.mailbox.path;
+      let path25 = connection.mailbox && connection.mailbox.path;
       switch (connection.missingIdleCommand) {
         case "SELECT":
           connection.log.debug({ src: "c", msg: `Running SELECT to detect changes in folder`, cid: connection.id });
-          await connection.runInternal("SELECT", path24, { readOnly: session.selectCommand.command === "EXAMINE" });
+          await connection.runInternal("SELECT", path25, { readOnly: session.selectCommand.command === "EXAMINE" });
           break;
         case "STATUS": {
           connection.log.debug({ src: "c", msg: `Running STATUS to detect changes in folder`, cid: connection.id });
-          let status = await connection.runInternal("STATUS", path24, {
+          let status = await connection.runInternal("STATUS", path25, {
             messages: true,
             uidNext: true,
             uidValidity: true,
@@ -91339,12 +91552,12 @@ var require_imap_flow = __commonJS({
           this.emit("flags", updateEvent);
         }
       }
-      async ensureSelectedMailbox(path24) {
-        if (!path24) {
+      async ensureSelectedMailbox(path25) {
+        if (!path25) {
           return false;
         }
-        if (!this.mailbox || !comparePaths(this, this.mailbox.path, path24)) {
-          return await this.mailboxOpen(path24);
+        if (!this.mailbox || !comparePaths(this, this.mailbox.path, path25)) {
+          return await this.mailboxOpen(path25);
         }
         return true;
       }
@@ -91759,9 +91972,9 @@ var require_imap_flow = __commonJS({
        * let quota = await client.getQuota();
        * console.log(quota.storage.used, quota.storage.limit)
        */
-      async getQuota(path24) {
-        path24 = path24 || "INBOX";
-        return await this.run("QUOTA", path24);
+      async getQuota(path25) {
+        path25 = path25 || "INBOX";
+        return await this.run("QUOTA", path25);
       }
       /**
        * @typedef {Object} ListResponse
@@ -91871,8 +92084,8 @@ var require_imap_flow = __commonJS({
        * console.log(info.path);
        * // "INBOX.parent.child" // assumes "INBOX." as namespace prefix and "." as delimiter
        */
-      async mailboxCreate(path24) {
-        return await this.run("CREATE", path24);
+      async mailboxCreate(path25) {
+        return await this.run("CREATE", path25);
       }
       /**
        * @typedef {Object} MailboxRenameResponse
@@ -91893,8 +92106,8 @@ var require_imap_flow = __commonJS({
        * console.log(info.newPath);
        * // "INBOX.Important stuff ❗️" // assumes "INBOX." as namespace prefix
        */
-      async mailboxRename(path24, newPath) {
-        return await this.run("RENAME", path24, newPath);
+      async mailboxRename(path25, newPath) {
+        return await this.run("RENAME", path25, newPath);
       }
       /**
        * @typedef {Object} MailboxDeleteResponse
@@ -91913,8 +92126,8 @@ var require_imap_flow = __commonJS({
        * console.log(info.path);
        * // "INBOX.Important stuff ❗️" // assumes "INBOX." as namespace prefix
        */
-      async mailboxDelete(path24) {
-        return await this.run("DELETE", path24);
+      async mailboxDelete(path25) {
+        return await this.run("DELETE", path25);
       }
       /**
        * Subscribes to a mailbox
@@ -91925,8 +92138,8 @@ var require_imap_flow = __commonJS({
        * @example
        * await client.mailboxSubscribe('Important stuff ❗️');
        */
-      async mailboxSubscribe(path24) {
-        return await this.run("SUBSCRIBE", path24);
+      async mailboxSubscribe(path25) {
+        return await this.run("SUBSCRIBE", path25);
       }
       /**
        * Unsubscribes from a mailbox
@@ -91937,8 +92150,8 @@ var require_imap_flow = __commonJS({
        * @example
        * await client.mailboxUnsubscribe('Important stuff ❗️');
        */
-      async mailboxUnsubscribe(path24) {
-        return await this.run("UNSUBSCRIBE", path24);
+      async mailboxUnsubscribe(path25) {
+        return await this.run("UNSUBSCRIBE", path25);
       }
       /**
        * Opens a mailbox to access messages. You can perform message operations only against an opened mailbox.
@@ -91956,8 +92169,8 @@ var require_imap_flow = __commonJS({
        * console.log(mailbox.exists);
        * // 125
        */
-      async mailboxOpen(path24, options) {
-        return await this.run("SELECT", path24, options);
+      async mailboxOpen(path25, options) {
+        return await this.run("SELECT", path25, options);
       }
       /**
        * Closes a previously opened mailbox
@@ -92004,8 +92217,8 @@ var require_imap_flow = __commonJS({
        * console.log(status.unseen);
        * // 123
        */
-      async status(path24, query) {
-        return await this.run("STATUS", path24, query);
+      async status(path25, query) {
+        return await this.run("STATUS", path25, query);
       }
       /**
        * Starts listening for new or deleted messages from the currently opened mailbox. Only required if {@link ImapFlow#disableAutoIdle} is set to `true`
@@ -92259,8 +92472,8 @@ var require_imap_flow = __commonJS({
        * @example
        * await client.append('INBOX', rawMessageBuffer, ['\\Seen'], new Date(2000, 1, 1));
        */
-      async append(path24, content, flags, idate) {
-        return await this.run("APPEND", path24, content, flags, idate) || false;
+      async append(path25, content, flags, idate) {
+        return await this.run("APPEND", path25, content, flags, idate) || false;
       }
       /**
        * @typedef {Object} CopyResponseObject
@@ -93104,7 +93317,7 @@ var require_imap_flow = __commonJS({
               await new Promise((resolve2) => setImmediate(resolve2));
             }
             const lock = this.locks.shift();
-            const { resolve, reject, path: path24, options, lockId } = lock;
+            const { resolve, reject, path: path25, options, lockId } = lock;
             if (lock.acquireTimer) {
               clearTimeout(lock.acquireTimer);
               lock.acquireTimer = null;
@@ -93120,7 +93333,7 @@ var require_imap_flow = __commonJS({
                 this.log.warn({
                   msg: "Mailbox lock held for a long time",
                   lockId: lock.lockId,
-                  path: path24,
+                  path: path25,
                   heldFor: Date.now() - lock.heldAt,
                   /* c8 ignore next */
                   // the held-lock-warning diagnostic with a description set is a timing-dependent log detail
@@ -93156,52 +93369,52 @@ var require_imap_flow = __commonJS({
               }
             };
             if (!this.usable || !this.socket || this.socket.destroyed) {
-              this.log.trace({ msg: "Failed to acquire mailbox lock", path: path24, lockId, idling: this.idling });
+              this.log.trace({ msg: "Failed to acquire mailbox lock", path: path25, lockId, idling: this.idling });
               let error2 = new Error("Connection not available");
               error2.code = "NoConnection";
               reject(error2);
               continue;
             }
-            if (this.mailbox && this.mailbox.path === path24 && !!this.mailbox.readOnly === !!options.readOnly) {
+            if (this.mailbox && this.mailbox.path === path25 && !!this.mailbox.readOnly === !!options.readOnly) {
               this.log.trace({
                 msg: "Mailbox lock acquired [existing]",
-                path: path24,
+                path: path25,
                 lockId,
                 idling: this.idling,
                 ...options.description && { description: options.description }
               });
               this.currentLock = lock;
               armHeldTimer();
-              resolve({ path: path24, release });
+              resolve({ path: path25, release });
               break;
             }
             try {
-              await this.mailboxOpen(path24, options);
+              await this.mailboxOpen(path25, options);
               this.log.trace({
                 msg: "Mailbox lock acquired [selected]",
-                path: path24,
+                path: path25,
                 lockId,
                 idling: this.idling,
                 ...options.description && { description: options.description }
               });
               this.currentLock = lock;
               armHeldTimer();
-              resolve({ path: path24, release });
+              resolve({ path: path25, release });
               break;
             } catch (err) {
               if (err.responseStatus === "NO") {
                 try {
-                  let folders = await this.run("LIST", "", path24, { listOnly: true });
+                  let folders = await this.run("LIST", "", path25, { listOnly: true });
                   if (!folders || !folders.length) {
                     err.mailboxMissing = true;
                   }
                 } catch (E) {
-                  this.log.trace({ msg: "Failed to verify failed mailbox", path: path24, err: E });
+                  this.log.trace({ msg: "Failed to verify failed mailbox", path: path25, err: E });
                 }
               }
               this.log.trace({
                 msg: "Failed to acquire mailbox lock",
-                path: path24,
+                path: path25,
                 lockId,
                 idling: this.idling,
                 ...options.description && { description: options.description },
@@ -93240,13 +93453,13 @@ var require_imap_flow = __commonJS({
        *   lock.release();
        * }
        */
-      getMailboxLock(path24, options) {
+      getMailboxLock(path25, options) {
         options = options || {};
-        path24 = normalizePath(this, path24);
+        path25 = normalizePath(this, path25);
         let lockId = ++this.lockCounter;
         this.log.trace({
           msg: "Requesting lock",
-          path: path24,
+          path: path25,
           lockId,
           ...options.description && { description: options.description },
           activeLock: this.currentLock ? {
@@ -93255,7 +93468,7 @@ var require_imap_flow = __commonJS({
           } : null
         });
         let lockPromise = new Promise((resolve, reject) => {
-          let lockEntry = { resolve, reject, path: path24, options, lockId };
+          let lockEntry = { resolve, reject, path: path25, options, lockId };
           this.locks.push(lockEntry);
           if (Number(options.acquireTimeout) > 0) {
             lockEntry.acquireTimer = setTimeout(() => {
@@ -93344,16 +93557,16 @@ var require_imap_flow = __commonJS({
 });
 
 // src/mail/mail-fetcher.ts
-import fs21 from "node:fs/promises";
-import path22 from "node:path";
+import fs22 from "node:fs/promises";
+import path23 from "node:path";
 async function saveAttachments(attachments, downloadDir) {
   if (attachments.length === 0) return [];
-  await fs21.mkdir(downloadDir, { recursive: true });
+  await fs22.mkdir(downloadDir, { recursive: true });
   const saved = [];
   for (const a of attachments) {
-    const name = path22.basename(a.filename) || "attachment";
-    const savedPath = path22.join(downloadDir, name);
-    await fs21.writeFile(savedPath, a.content);
+    const name = path23.basename(a.filename) || "attachment";
+    const savedPath = path23.join(downloadDir, name);
+    await fs22.writeFile(savedPath, a.content);
     saved.push({ filename: name, savedPath, size: a.content.length });
   }
   return saved;
@@ -93484,7 +93697,7 @@ var init_mail_fetcher = __esm({
 
 // src/tools/fetch-mail.ts
 import os16 from "node:os";
-import path23 from "node:path";
+import path24 from "node:path";
 function registerFetchMailTool(server, deps = {}) {
   const makeFetcher = deps.fetcherFactory ?? ((creds) => new ImapflowMailFetcher(creds));
   server.registerTool(
@@ -93546,7 +93759,7 @@ var init_fetch_mail = __esm({
     init_mail_fetcher();
     init_auth_error();
     init_validate();
-    DEFAULT_DOWNLOAD_DIR = path23.join(os16.homedir(), ".cogent", "mail-downloads");
+    DEFAULT_DOWNLOAD_DIR = path24.join(os16.homedir(), ".cogent", "mail-downloads");
   }
 });