claude-threads 1.32.1 → 1.33.1

package/dist/mcp/mcp-server.js

@@ -3035,10 +3035,12 @@ var require_data = __commonJS((exports, module) => {
 var require_utils = __commonJS((exports, module) => {
   var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
   var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+  var isPort = RegExp.prototype.test.bind(/^\d*$/u);
   var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
   var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
-  var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
-  var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/?]$/iu);
+  var isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
+  var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
+  var isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
   function stringArrayToHexStripped(input) {
     let acc = "";
     let code = 0;
@@ -3063,91 +3065,127 @@ var require_utils = __commonJS((exports, module) => {
     }
     return acc;
   }
+  var isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
+  var isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
+  var isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
   var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
-  function consumeIsZone(buffer) {
-    buffer.length = 0;
-    return true;
+  var nonSimpleDomainChars = RegExp.prototype.test.bind(/[^\d!"$&'()*+,\-.;=_`a-z{}~]/u);
+  var numericLastLabel = RegExp.prototype.test.bind(/(?:^|\.)\d+$/u);
+  function nonSimpleMailtoDomain(domain) {
+    return nonSimpleDomainChars(domain) || numericLastLabel(domain);
   }
-  function consumeHextets(buffer, address, output) {
-    if (buffer.length) {
-      const hex = stringArrayToHexStripped(buffer);
-      if (hex !== "") {
-        address.push(hex);
-      } else {
-        output.error = true;
-        return false;
+  function isZoneIdentifier(zone) {
+    if (zone.length === 0)
+      return false;
+    for (let i = 0;i < zone.length; i++) {
+      if (isZoneCharacter(zone[i]))
+        continue;
+      if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
+        i += 2;
+        continue;
       }
-      buffer.length = 0;
+      return false;
     }
     return true;
   }
-  function getIPV6(input) {
-    let tokenCount = 0;
-    const output = { error: false, address: "", zone: "" };
-    const address = [];
-    const buffer = [];
-    let endipv6Encountered = false;
-    let endIpv6 = false;
-    let consume = consumeHextets;
-    for (let i = 0;i < input.length; i++) {
-      const cursor = input[i];
-      if (cursor === "[" || cursor === "]") {
-        continue;
-      }
-      if (cursor === ":") {
-        if (endipv6Encountered === true) {
-          endIpv6 = true;
-        }
-        if (!consume(buffer, address, output)) {
-          break;
-        }
-        if (++tokenCount > 7) {
-          output.error = true;
-          break;
-        }
-        if (i > 0 && input[i - 1] === ":") {
-          endipv6Encountered = true;
-        }
-        address.push(":");
-        continue;
-      } else if (cursor === "%") {
-        if (!consume(buffer, address, output)) {
-          break;
+  function compressIPv6ZeroRun(hextets) {
+    let bestStart = -1;
+    let bestLength = 0;
+    let runStart = -1;
+    let runLength = 0;
+    for (let i = 0;i < hextets.length; i++) {
+      if (hextets[i] === "0") {
+        if (runStart === -1)
+          runStart = i;
+        runLength++;
+        if (runLength > bestLength) {
+          bestLength = runLength;
+          bestStart = runStart;
         }
-        consume = consumeIsZone;
       } else {
-        buffer.push(cursor);
-        continue;
+        runStart = -1;
+        runLength = 0;
       }
     }
-    if (buffer.length) {
-      if (consume === consumeIsZone) {
-        output.zone = buffer.join("");
-      } else if (endIpv6) {
-        address.push(buffer.join(""));
-      } else {
-        address.push(stringArrayToHexStripped(buffer));
+    if (bestLength < 2)
+      return hextets.join(":");
+    const head = hextets.slice(0, bestStart).join(":");
+    const tail = hextets.slice(bestStart + bestLength).join(":");
+    return head + "::" + tail;
+  }
+  function normalizeIPv6Address(input) {
+    const compression = input.indexOf("::");
+    if (compression !== -1 && input.indexOf("::", compression + 1) !== -1)
+      return;
+    const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
+    const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
+    if (compression !== -1) {
+      if (left.length === 1 && left[0] === "")
+        left.length = 0;
+      if (right.length === 1 && right[0] === "")
+        right.length = 0;
+    }
+    const parts = left.concat(right);
+    let hextetCount = 0;
+    for (let i = 0;i < parts.length; i++) {
+      const part = parts[i];
+      if (part === "")
+        return;
+      if (part.indexOf(".") !== -1) {
+        if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part))
+          return;
+        hextetCount += 2;
+        continue;
       }
+      if (!isHextet(part))
+        return;
+      parts[i] = parseInt(part, 16).toString(16);
+      hextetCount++;
     }
-    output.address = address.join("");
-    return output;
+    if (compression === -1) {
+      if (hextetCount !== 8)
+        return;
+      return compressIPv6ZeroRun(parts);
+    }
+    if (hextetCount >= 8)
+      return;
+    const expanded = parts.slice(0, left.length);
+    for (let i = hextetCount;i < 8; i++)
+      expanded.push("0");
+    for (let i = left.length;i < parts.length; i++)
+      expanded.push(parts[i]);
+    return compressIPv6ZeroRun(expanded);
   }
   function normalizeIPv6(host) {
-    if (findToken(host, ":") < 2) {
-      return { host, isIPV6: false };
-    }
-    const ipv62 = getIPV6(host);
-    if (!ipv62.error) {
-      let newHost = ipv62.address;
-      let escapedHost = ipv62.address;
-      if (ipv62.zone) {
-        newHost += "%" + ipv62.zone;
-        escapedHost += "%25" + ipv62.zone;
-      }
-      return { host: newHost, isIPV6: true, escapedHost };
-    } else {
-      return { host, isIPV6: false };
-    }
+    const bracketed = host[0] === "[" && host[host.length - 1] === "]";
+    const hasBracket = host[0] === "[" || host[host.length - 1] === "]";
+    if (hasBracket && !bracketed)
+      return { host, isIPV6: false, error: true };
+    let input = bracketed ? host.slice(1, -1) : host;
+    if (bracketed && isIPvFuture(input)) {
+      input = input.toLowerCase();
+      return { host: `[${input}]`, escapedHost: input, isIPV6: false, isIPVFuture: true };
+    }
+    if (findToken(input, ":") < 2) {
+      return { host, isIPV6: false, error: bracketed };
+    }
+    let zoneIdentifier = "";
+    const zoneSeparator = input.indexOf("%");
+    if (zoneSeparator !== -1) {
+      const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
+      zoneIdentifier = input.slice(zoneSeparator + separatorLength);
+      if (!isZoneIdentifier(zoneIdentifier))
+        return { host, isIPV6: false, error: true };
+      input = input.slice(0, zoneSeparator);
+    }
+    const address = normalizeIPv6Address(input);
+    if (address === undefined)
+      return { host, isIPV6: false, error: true };
+    return {
+      host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
+      escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
+      isIPV6: true
+    };
   }
   function findToken(str, token) {
     let ind = 0;
@@ -3324,6 +3362,45 @@ var require_utils = __commonJS((exports, module) => {
     }
     return output;
   }
+  function serializePathEncoding(input, pathNoScheme = false) {
+    let output = "";
+    let firstSegment = pathNoScheme && input[0] !== "/";
+    for (let i = 0;i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
+        const hex = input.slice(i + 1, i + 3);
+        if (isHexPair(hex)) {
+          output += "%" + hex.toUpperCase();
+          i += 2;
+          continue;
+        }
+      }
+      if (ch === "/") {
+        firstSegment = false;
+      }
+      if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) {
+        output += ch;
+      } else {
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
+      }
+    }
+    return output;
+  }
   function normalizeQueryFragmentEncoding(input) {
     let output = "";
     for (let i = 0;i < input.length; i++) {
@@ -3365,6 +3442,50 @@ var require_utils = __commonJS((exports, module) => {
     }
     return output;
   }
+  function encodeComponent(input, isAllowed) {
+    let output = "";
+    for (let i = 0;i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
+        const hex = input.slice(i + 1, i + 3);
+        if (isHexPair(hex)) {
+          output += "%" + hex.toUpperCase();
+          i += 2;
+          continue;
+        }
+      }
+      if (isAllowed(ch)) {
+        output += ch;
+      } else {
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
+      }
+    }
+    return output;
+  }
+  function encodeUserinfo(input) {
+    return encodeComponent(input, isUserinfoCharacter);
+  }
+  function encodeQuery(input) {
+    return encodeComponent(input, isQueryFragmentCharacter);
+  }
+  function encodeFragment(input) {
+    return encodeComponent(input, isQueryFragmentCharacter);
+  }
   function escapePreservingEscapes(input) {
     let output = "";
     for (let i = 0;i < input.length; i++) {
@@ -3399,14 +3520,18 @@ var require_utils = __commonJS((exports, module) => {
   function recomposeAuthority(component) {
     const uriTokens = [];
     if (component.userinfo !== undefined) {
-      uriTokens.push(component.userinfo);
+      uriTokens.push(encodeUserinfo(component.userinfo));
       uriTokens.push("@");
     }
     if (component.host !== undefined) {
-      let host = unescape(component.host);
+      let host = component.host;
       if (!isIPv4(host)) {
-        const ipV6res = normalizeIPv6(host);
-        if (ipV6res.isIPV6 === true) {
+        let ipV6res = normalizeIPv6(host);
+        if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+          host = normalizePercentEncoding(host, true);
+          ipV6res = normalizeIPv6(host);
+        }
+        if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) {
           host = `[${ipV6res.escapedHost}]`;
         } else {
           host = reescapeHostDelimiters(host, false);
@@ -3415,18 +3540,29 @@ var require_utils = __commonJS((exports, module) => {
       uriTokens.push(host);
     }
     if (typeof component.port === "number" || typeof component.port === "string") {
+      const port = String(component.port);
+      if (!isPort(port)) {
+        throw new TypeError("URI port is malformed.");
+      }
       uriTokens.push(":");
-      uriTokens.push(String(component.port));
+      uriTokens.push(port);
     }
     return uriTokens.length ? uriTokens.join("") : undefined;
   }
   module.exports = {
+    BYTE_HEX,
+    percentEncodeNonAscii,
     nonSimpleDomain,
+    nonSimpleMailtoDomain,
     recomposeAuthority,
     reescapeHostDelimiters,
     normalizePercentEncoding,
     normalizePathEncoding,
+    serializePathEncoding,
     normalizeQueryFragmentEncoding,
+    encodeUserinfo,
+    encodeQuery,
+    encodeFragment,
     escapePreservingEscapes,
     removeDotSegments,
     isIPv4,
@@ -3438,15 +3574,16 @@ var require_utils = __commonJS((exports, module) => {
 
 // node_modules/fast-uri/lib/schemes.js
 var require_schemes = __commonJS((exports, module) => {
-  var { isUUID } = require_utils();
-  var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+  var { isUUID, BYTE_HEX, percentEncodeNonAscii, nonSimpleMailtoDomain } = require_utils();
+  var URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
   var supportedSchemeNames = [
     "http",
     "https",
     "ws",
     "wss",
     "urn",
-    "urn:uuid"
+    "urn:uuid",
+    "mailto"
   ];
   function isValidSchemeName(name) {
     return supportedSchemeNames.indexOf(name) !== -1;
@@ -3494,9 +3631,10 @@ var require_schemes = __commonJS((exports, module) => {
       wsComponent.secure = undefined;
     }
     if (wsComponent.resourceName) {
-      const [path, query] = wsComponent.resourceName.split("?");
+      const queryIndex = wsComponent.resourceName.indexOf("?");
+      const path = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
       wsComponent.path = path && path !== "/" ? path : undefined;
-      wsComponent.query = query;
+      wsComponent.query = queryIndex === -1 ? undefined : wsComponent.resourceName.slice(queryIndex + 1);
       wsComponent.resourceName = undefined;
     }
     wsComponent.fragment = undefined;
@@ -3508,7 +3646,7 @@ var require_schemes = __commonJS((exports, module) => {
       return urnComponent;
     }
     const matches = urnComponent.path.match(URN_REG);
-    if (matches) {
+    if (matches && matches[0] === urnComponent.path) {
       const scheme = options.scheme || urnComponent.scheme || "urn";
       urnComponent.nid = matches[1].toLowerCase();
       urnComponent.nss = matches[2];
@@ -3590,13 +3728,235 @@ var require_schemes = __commonJS((exports, module) => {
     serialize: urnuuidSerialize,
     skipNormalize: true
   };
+  var LOCAL_PART_ALLOWED = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~!$'()*+=";
+  var HFNAME_ALLOWED = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~!$'()*+,;:@";
+  var DTEXT_ALLOWED = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~!$'()*+;:";
+  function allowSet(chars, allowNonAscii = false) {
+    const table = new Uint8Array(128);
+    for (let i = 0;i < chars.length; i++) {
+      table[chars.charCodeAt(i)] = 1;
+    }
+    const escaped = chars.replace(/[\\\]^-]/gu, "\\$&");
+    const cls = allowNonAscii ? `[${escaped}]|[^\\0-\\x7F\\uD800-\\uDFFF]` : `[${escaped}]`;
+    return { all: new RegExp(`^(?:${cls})*$`, "u"), table, allowNonAscii };
+  }
+  var LOCAL_PART = allowSet(LOCAL_PART_ALLOWED);
+  var HFNAME = allowSet(HFNAME_ALLOWED);
+  var DTEXT = allowSet(DTEXT_ALLOWED);
+  var DTEXT_IRI = allowSet(DTEXT_ALLOWED, true);
+  var HEX_PAIR = /^[\da-f]{2}$/iu;
+  var MAILTO_DOMAIN_LITERAL = /^\[[\x21-\x5A\x5E-\x7E]*\]$/u;
+  var MAILTO_DOMAIN_ERROR = "URI mailto has an invalid recipient domain.";
+  var HAS_SURROGATE = /[\uD800-\uDFFF]/u;
+  function decodeHex(str) {
+    if (typeof str !== "string" || str.indexOf("%") === -1) {
+      return str;
+    }
+    try {
+      return decodeURIComponent(str);
+    } catch {
+      return str;
+    }
+  }
+  function replaceLoneSurrogates(input) {
+    let result = "";
+    for (let i = 0;i < input.length; i++) {
+      const code = input.charCodeAt(i);
+      if (code >= 55296 && code <= 56319 && i + 1 < input.length) {
+        const low = input.charCodeAt(i + 1);
+        if (low >= 56320 && low <= 57343) {
+          result += input[i] + input[i + 1];
+          i++;
+          continue;
+        }
+      }
+      result += code >= 55296 && code <= 57343 ? "�" : input[i];
+    }
+    return result;
+  }
+  function encodeWithAllow(input, set2) {
+    if (set2.all.test(input)) {
+      return input;
+    }
+    const table = set2.table;
+    let result = "";
+    for (let i = 0;i < input.length; i++) {
+      const code = input.charCodeAt(i);
+      if (code < 128) {
+        if (table[code] === 1) {
+          result += input[i];
+        } else if (code === 37 && i + 2 < input.length && HEX_PAIR.test(input.slice(i + 1, i + 3))) {
+          result += "%" + input.slice(i + 1, i + 3).toUpperCase();
+          i += 2;
+        } else {
+          result += BYTE_HEX[code];
+        }
+        continue;
+      }
+      if (code < 55296 || code > 57343) {
+        result += set2.allowNonAscii ? input[i] : percentEncodeNonAscii(code);
+        continue;
+      }
+      if (code <= 56319 && i + 1 < input.length) {
+        const low = input.charCodeAt(i + 1);
+        if (low >= 56320 && low <= 57343) {
+          result += set2.allowNonAscii ? input[i] + input[i + 1] : percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+          i++;
+          continue;
+        }
+      }
+      result += set2.allowNonAscii ? "�" : percentEncodeNonAscii(65533);
+    }
+    return result;
+  }
+  function mailtoNormalizeDomain(domain, options, component) {
+    const normalizedDomain = String(domain).toLowerCase();
+    if (MAILTO_DOMAIN_LITERAL.test(normalizedDomain)) {
+      return normalizedDomain;
+    }
+    if (normalizedDomain !== "" && !nonSimpleMailtoDomain(normalizedDomain)) {
+      return normalizedDomain;
+    }
+    try {
+      const parsedDomain = new URL("http://" + normalizedDomain);
+      if (parsedDomain.username || parsedDomain.password || parsedDomain.port || parsedDomain.pathname !== "/" || parsedDomain.search || parsedDomain.hash || !parsedDomain.hostname) {
+        throw new Error(MAILTO_DOMAIN_ERROR);
+      }
+      return options && options.unicodeSupport ? normalizedDomain : parsedDomain.hostname;
+    } catch {
+      if (component) {
+        component.error = component.error || MAILTO_DOMAIN_ERROR;
+      }
+      return normalizedDomain;
+    }
+  }
+  function mailtoEncodeDomain(domain, options) {
+    const set2 = options && options.unicodeSupport ? DTEXT_IRI : DTEXT;
+    if (domain.length > 1 && domain[0] === "[" && domain[domain.length - 1] === "]") {
+      return "[" + encodeWithAllow(domain.slice(1, -1), set2) + "]";
+    }
+    return encodeWithAllow(domain, set2);
+  }
+  function mailtoParse(component, options) {
+    const mailtoComponent = component;
+    let rawPath = mailtoComponent.path;
+    let rawQuery = mailtoComponent.query;
+    if (rawPath && HAS_SURROGATE.test(rawPath))
+      rawPath = replaceLoneSurrogates(rawPath);
+    if (rawQuery && HAS_SURROGATE.test(rawQuery))
+      rawQuery = replaceLoneSurrogates(rawQuery);
+    const to = rawPath ? rawPath.indexOf(",") === -1 ? [rawPath] : rawPath.split(",") : [];
+    mailtoComponent.path = undefined;
+    if (rawQuery) {
+      let headers = null;
+      let start = 0;
+      while (start <= rawQuery.length) {
+        let end = rawQuery.indexOf("&", start);
+        if (end === -1)
+          end = rawQuery.length;
+        const token = rawQuery.slice(start, end);
+        start = end + 1;
+        const eqIdx = token.indexOf("=");
+        if (eqIdx !== token.lastIndexOf("=")) {
+          mailtoComponent.error = mailtoComponent.error || "URI mailto has malformed header fields.";
+          continue;
+        }
+        const name = eqIdx === -1 ? token : token.slice(0, eqIdx);
+        const value = eqIdx === -1 ? "" : token.slice(eqIdx + 1);
+        if (name === "to") {
+          const addrs = value.split(",");
+          for (let j = 0;j < addrs.length; j++)
+            to.push(addrs[j]);
+          continue;
+        }
+        if (name === "subject") {
+          mailtoComponent.subject = decodeHex(value);
+          continue;
+        }
+        if (name === "body") {
+          mailtoComponent.body = decodeHex(value);
+          continue;
+        }
+        if (headers === null)
+          headers = Object.create(null);
+        headers[decodeHex(name)] = decodeHex(value);
+      }
+      if (headers !== null)
+        mailtoComponent.headers = headers;
+    }
+    mailtoComponent.query = undefined;
+    for (let i = 0;i < to.length; i++) {
+      const rawAddr = to[i];
+      const atIdx = rawAddr.lastIndexOf("@");
+      if (atIdx < 0) {
+        mailtoComponent.error = mailtoComponent.error || MAILTO_DOMAIN_ERROR;
+        to[i] = decodeHex(rawAddr);
+        continue;
+      }
+      const local = decodeHex(rawAddr.slice(0, atIdx));
+      const domain = mailtoNormalizeDomain(decodeHex(rawAddr.slice(atIdx + 1)), options, mailtoComponent);
+      to[i] = local + "@" + domain;
+    }
+    if (to.length)
+      mailtoComponent.to = to;
+    return mailtoComponent;
+  }
+  function mailtoSerialize(component, options) {
+    const mailtoComponent = component;
+    const to = Array.isArray(mailtoComponent.to) ? mailtoComponent.to.slice() : [];
+    if (to.length) {
+      for (let i = 0;i < to.length; i++) {
+        const addr = String(to[i]);
+        const atIdx = addr.lastIndexOf("@");
+        const rawLocal = atIdx >= 0 ? addr.slice(0, atIdx) : addr;
+        const rawDomain = atIdx >= 0 ? addr.slice(atIdx + 1) : "";
+        const local = encodeWithAllow(rawLocal, LOCAL_PART);
+        const decodedDomain = decodeHex(rawDomain);
+        const normalizedDomain = mailtoNormalizeDomain(decodedDomain, options);
+        to[i] = local + "@" + mailtoEncodeDomain(normalizedDomain, options);
+      }
+      mailtoComponent.path = to.join(",");
+      options.skipEscape = true;
+    } else {
+      mailtoComponent.path = undefined;
+    }
+    const headers = mailtoComponent.headers && typeof mailtoComponent.headers === "object" ? Object.assign(Object.create(null), mailtoComponent.headers) : Object.create(null);
+    if (mailtoComponent.subject)
+      headers.subject = mailtoComponent.subject;
+    if (mailtoComponent.body)
+      headers.body = mailtoComponent.body;
+    mailtoComponent.headers = headers;
+    let query = "";
+    let count = 0;
+    for (const name in headers) {
+      if (count++ !== 0)
+        query += "&";
+      query += encodeWithAllow(name, HFNAME) + "=" + encodeWithAllow(String(headers[name]), HFNAME);
+    }
+    if (count !== 0) {
+      mailtoComponent.query = query;
+    } else {
+      mailtoComponent.headers = undefined;
+    }
+    return mailtoComponent;
+  }
+  var mailto = {
+    scheme: "mailto",
+    parse: mailtoParse,
+    serialize: mailtoSerialize,
+    domainHost: false,
+    unicodeSupport: true,
+    skipNormalize: true,
+    absolutePath: true
+  };
   var SCHEMES = {
     http,
     https,
     ws,
     wss,
     urn,
-    "urn:uuid": urnuuid
+    "urn:uuid": urnuuid,
+    mailto
   };
   Object.setPrototypeOf(SCHEMES, null);
   function getSchemeHandler(scheme) {
@@ -3612,8 +3972,17 @@ var require_schemes = __commonJS((exports, module) => {
 
 // node_modules/fast-uri/index.js
 var require_fast_uri = __commonJS((exports, module) => {
-  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, normalizeQueryFragmentEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
+  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
   var { SCHEMES, getSchemeHandler } = require_schemes();
+  var VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
+  var MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
+  function decodeValidScheme(scheme) {
+    const decodedScheme = unescape(String(scheme));
+    if (!VALID_SCHEME.test(decodedScheme)) {
+      throw new TypeError(MALFORMED_SCHEME_ERROR);
+    }
+    return decodedScheme;
+  }
   function normalize(uri, options) {
     if (typeof uri === "string") {
       uri = normalizeString(uri, options);
@@ -3624,12 +3993,34 @@ var require_fast_uri = __commonJS((exports, module) => {
   }
   function resolve(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-    const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
-    const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
-    if (baseMalformed || relativeMalformed) {
+    const {
+      parsed: baseParsed,
+      malformedAuthorityOrPort: baseMalformed,
+      malformedPercentEncoding: baseMalformedPercentEncoding,
+      malformedSchemeSpecific: baseMalformedSchemeSpecific,
+      malformedHost: baseMalformedHost,
+      malformedScheme: baseMalformedScheme
+    } = parseWithStatus(baseURI, schemelessOptions);
+    const {
+      parsed: relativeParsed,
+      malformedAuthorityOrPort: relativeMalformed,
+      malformedPercentEncoding: relativeMalformedPercentEncoding,
+      malformedSchemeSpecific: relativeMalformedSchemeSpecific,
+      malformedHost: relativeMalformedHost,
+      malformedScheme: relativeMalformedScheme
+    } = parseWithStatus(relativeURI, schemelessOptions);
+    if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) {
       throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
     }
     const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
+    const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
+    const resolvedHost = resolved.host;
+    const resolvedHostIsIP = resolvedHost !== undefined && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+    canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+    const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !/\P{ASCII}/u.test(resolvedHost);
+    if (resolved.error && !encodedASCIIHost) {
+      throw new Error(resolved.error);
+    }
     schemelessOptions.skipEscape = true;
     return serialize(resolved, schemelessOptions);
   }
@@ -3689,7 +4080,7 @@ var require_fast_uri = __commonJS((exports, module) => {
   function equal(uriA, uriB, options) {
     const normalizedA = normalizeComparableURI(uriA, options);
     const normalizedB = normalizeComparableURI(uriB, options);
-    return normalizedA !== undefined && normalizedB !== undefined && normalizedA.toLowerCase() === normalizedB.toLowerCase();
+    return normalizedA !== undefined && normalizedB !== undefined && normalizedA === normalizedB;
   }
   function serialize(cmpts, opts) {
     const component = {
@@ -3706,24 +4097,31 @@ var require_fast_uri = __commonJS((exports, module) => {
       reference: cmpts.reference,
       resourceName: cmpts.resourceName,
       secure: cmpts.secure,
+      to: cmpts.to,
+      subject: cmpts.subject,
+      body: cmpts.body,
+      headers: cmpts.headers,
       error: ""
     };
     const options = Object.assign({}, opts);
     const uriTokens = [];
+    if (component.scheme) {
+      component.scheme = decodeValidScheme(component.scheme);
+    }
     const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
     if (schemeHandler && schemeHandler.serialize)
       schemeHandler.serialize(component, options);
+    const hasAuthority = component.userinfo !== undefined || component.host !== undefined || component.port !== undefined;
+    const pathNoScheme = !options.skipEscape && component.scheme === undefined && !hasAuthority;
     if (component.path !== undefined) {
       if (!options.skipEscape) {
-        component.path = escapePreservingEscapes(component.path);
-        if (component.scheme !== undefined) {
-          component.path = component.path.split("%3A").join(":");
-        }
+        component.path = serializePathEncoding(component.path, pathNoScheme);
       } else {
         component.path = normalizePercentEncoding(component.path);
       }
     }
     if (options.reference !== "suffix" && component.scheme) {
+      component.scheme = decodeValidScheme(component.scheme);
       uriTokens.push(component.scheme, ":");
     }
     const authority = recomposeAuthority(component);
@@ -3741,16 +4139,19 @@ var require_fast_uri = __commonJS((exports, module) => {
       if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
         s = removeDotSegments(s);
       }
+      if (pathNoScheme) {
+        s = serializePathEncoding(s, true);
+      }
       if (authority === undefined && s[0] === "/" && s[1] === "/") {
         s = "/%2F" + s.slice(2);
       }
       uriTokens.push(s);
     }
     if (component.query !== undefined) {
-      uriTokens.push("?", component.query);
+      uriTokens.push("?", encodeQuery(component.query));
     }
     if (component.fragment !== undefined) {
-      uriTokens.push("#", component.fragment);
+      uriTokens.push("#", encodeFragment(component.fragment));
     }
     return uriTokens.join("");
   }
@@ -3766,6 +4167,37 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return;
   }
+  function hasMalformedPercentEncoding(component) {
+    if (component === undefined)
+      return false;
+    let percent = component.indexOf("%");
+    while (percent !== -1) {
+      if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) {
+        return true;
+      }
+      percent = component.indexOf("%", percent + 3);
+    }
+    return false;
+  }
+  function isIPLiteral(host) {
+    return host[0] === "[" && host[host.length - 1] === "]";
+  }
+  function hasMalformedComponentPercentEncoding(matches) {
+    const host = matches[4];
+    return hasMalformedPercentEncoding(matches[3]) || host !== undefined && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+  }
+  function canonicalizeHost(parsed, options, schemeHandler, isIP) {
+    const bracketedIPLiteral = parsed.host && parsed.host[0] === "[" && parsed.host[parsed.host.length - 1] === "]";
+    if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && !bracketedIPLiteral && nonSimpleDomain(parsed.host)) {
+      try {
+        parsed.host = new URL("http://" + parsed.host).hostname;
+      } catch (e) {
+        parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+        return true;
+      }
+    }
+    return false;
+  }
   function parseWithStatus(uri, opts) {
     const options = Object.assign({}, opts);
     const parsed = {
@@ -3778,6 +4210,11 @@ var require_fast_uri = __commonJS((exports, module) => {
       fragment: undefined
     };
     let malformedAuthorityOrPort = false;
+    let malformedPercentEncoding = false;
+    let malformedSchemeSpecific = false;
+    let malformedHost = false;
+    let malformedIPLiteral = false;
+    let malformedScheme = false;
     let isIP = false;
     if (options.reference === "suffix") {
       if (options.scheme) {
@@ -3807,13 +4244,26 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     const matches = uri.match(URI_PARSE);
     if (matches) {
-      parsed.scheme = matches[1] === undefined ? undefined : matches[1].toLowerCase();
+      parsed.scheme = matches[1];
       parsed.userinfo = matches[3];
       parsed.host = matches[4];
       parsed.port = parseInt(matches[5], 10);
       parsed.path = matches[6] || "";
       parsed.query = matches[7];
       parsed.fragment = matches[8];
+      if (parsed.scheme !== undefined) {
+        const decodedScheme = unescape(parsed.scheme);
+        if (VALID_SCHEME.test(decodedScheme)) {
+          parsed.scheme = decodedScheme.toLowerCase();
+        } else {
+          parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
+          malformedScheme = true;
+        }
+      }
+      malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+      if (malformedPercentEncoding) {
+        parsed.error = parsed.error || "URI contains malformed percent-encoding.";
+      }
       if (isNaN(parsed.port)) {
         parsed.port = matches[5];
       }
@@ -3825,9 +4275,16 @@ var require_fast_uri = __commonJS((exports, module) => {
       if (parsed.host) {
         const ipv4result = isIPv4(parsed.host);
         if (ipv4result === false) {
+          const bracketedIPLiteral = isIPLiteral(parsed.host);
+          const hasIPLiteralBracket = parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
           const ipv6result = normalizeIPv6(parsed.host);
-          parsed.host = ipv6result.host.toLowerCase();
-          isIP = ipv6result.isIPV6;
+          isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
+          malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
+          parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
+          if (malformedIPLiteral) {
+            parsed.error = parsed.error || "URI host is malformed.";
+            malformedAuthorityOrPort = true;
+          }
         } else {
           isIP = true;
         }
@@ -3845,22 +4302,14 @@ var require_fast_uri = __commonJS((exports, module) => {
         parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
       }
       const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-      if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-        if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
-          try {
-            parsed.host = new URL("http://" + parsed.host).hostname;
-          } catch (e) {
-            parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
-          }
-        }
+      if (!malformedIPLiteral) {
+        malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
       }
       if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
         if (uri.indexOf("%") !== -1) {
-          if (parsed.scheme !== undefined) {
-            parsed.scheme = unescape(parsed.scheme);
-          }
-          if (parsed.host !== undefined) {
-            parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
+          if (parsed.host !== undefined && !malformedIPLiteral) {
+            const host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+            parsed.host = reescapeHostDelimiters(host, isIP);
           }
         }
         if (parsed.path) {
@@ -3875,11 +4324,14 @@ var require_fast_uri = __commonJS((exports, module) => {
       }
       if (schemeHandler && schemeHandler.parse) {
         schemeHandler.parse(parsed, options);
+        if (schemeHandler === SCHEMES.urn && parsed.nid === undefined) {
+          malformedSchemeSpecific = true;
+        }
       }
     } else {
       parsed.error = parsed.error || "URI can not be parsed.";
     }
-    return { parsed, malformedAuthorityOrPort };
+    return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
   }
   function parse6(uri, opts) {
     return parseWithStatus(uri, opts).parsed;
@@ -3888,20 +4340,28 @@ var require_fast_uri = __commonJS((exports, module) => {
     return normalizeStringWithStatus(uri, opts).normalized;
   }
   function normalizeStringWithStatus(uri, opts) {
-    const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+    const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
     return {
-      normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
-      malformedAuthorityOrPort
+      normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
+      malformedAuthorityOrPort,
+      malformedPercentEncoding,
+      malformedSchemeSpecific,
+      malformedHost,
+      malformedScheme
     };
   }
   function normalizeComparableURI(uri, opts) {
-    if (typeof uri === "string") {
-      const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
-      return malformedAuthorityOrPort ? undefined : normalized;
+    if (typeof uri !== "string" && typeof uri !== "object") {
+      return;
     }
-    if (typeof uri === "object") {
-      return serialize(uri, opts);
+    let value;
+    try {
+      value = typeof uri === "string" ? uri : serialize(uri, opts);
+    } catch {
+      return;
     }
+    const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+    return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? undefined : normalized;
   }
   var fastUri = {
     SCHEMES,
@@ -14239,12 +14699,12 @@ var init_spawn = __esm(() => {
 });
 
 // src/claude/quick-query.ts
-var log14;
+var log15;
 var init_quick_query = __esm(() => {
   init_spawn();
   init_version_check();
   init_logger();
-  log14 = createLogger("query");
+  log15 = createLogger("query");
 });
 
 // node_modules/ws/lib/constants.js
@@ -52442,9 +52902,54 @@ var ALLOWED_TRANSITIONS = {
   cancelling: new Set(["ending"]),
   ending: new Set
 };
+// src/persistence/atomic-file.ts
+import { chmodSync as chmodSync2, renameSync, writeFileSync } from "fs";
+
+class SerialQueue {
+  tail = Promise.resolve();
+  run(fn) {
+    const next = this.tail.then(fn, fn);
+    this.tail = next.catch(() => {
+      return;
+    });
+    return next;
+  }
+}
+function writeFileAtomic(file2, content) {
+  const tempFile = `${file2}.tmp`;
+  writeFileSync(tempFile, content, { encoding: "utf-8", mode: 384 });
+  renameSync(tempFile, file2);
+  chmodSync2(file2, 384);
+}
+
+// src/persistence/session-store.ts
+init_logger();
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+
+// src/sponsor.ts
+var SPONSOR_URL = "https://github.com/sponsors/axolotl-systems";
+var MILESTONE_VISIBLE_MS = 24 * 60 * 60 * 1000;
+function formatSponsorFooter(formatter) {
+  return formatter.formatItalic(`♥ Support claude-threads: ${formatter.formatLink("github.com/sponsors/axolotl-systems", SPONSOR_URL)}`);
+}
+
+// src/persistence/session-store.ts
+var log6 = createLogger("persist");
+function resolveEndReason(session) {
+  if (!session.cleanedAt)
+    return;
+  return session.endReason ?? "stopped";
+}
+function isRevivable(session) {
+  return resolveEndReason(session) !== "stopped";
+}
+var DEFAULT_CONFIG_DIR = join3(homedir2(), ".config", "claude-threads");
+var DEFAULT_SESSIONS_FILE = join3(DEFAULT_CONFIG_DIR, "sessions.json");
+
 // src/config/index.ts
 import { resolve as resolve2, dirname as dirname2 } from "path";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
 function getDefaultExportFromCjs(x) {
@@ -55556,7 +56061,7 @@ var jsYamlExports = requireJsYaml();
 var yaml = /* @__PURE__ */ getDefaultExportFromCjs(jsYamlExports);
 
 // src/config/index.ts
-var CONFIG_PATH = resolve2(homedir2(), ".config", "claude-threads", "config.yaml");
+var CONFIG_PATH = resolve2(homedir3(), ".config", "claude-threads", "config.yaml");
 
 // src/utils/battery.ts
 import { exec } from "child_process";
@@ -55665,7 +56170,7 @@ init_logger();
 // src/utils/keep-alive.ts
 init_logger();
 import { spawn } from "child_process";
-var log6 = createLogger("keepalive");
+var log7 = createLogger("keepalive");
 function keepAliveSpawnSpec(platform, parentPid) {
   switch (platform) {
     case "darwin":
@@ -55721,7 +56226,7 @@ class KeepAliveManager {
     if (!enabled && this.keepAliveProcess) {
       this.stopKeepAlive();
     }
-    log6.debug(`Keep-alive ${enabled ? "enabled" : "disabled"}`);
+    log7.debug(`Keep-alive ${enabled ? "enabled" : "disabled"}`);
   }
   isEnabled() {
     return this.enabled;
@@ -55731,7 +56236,7 @@ class KeepAliveManager {
   }
   sessionStarted() {
     this.activeSessionCount++;
-    log6.debug(`Session started (${this.activeSessionCount} active)`);
+    log7.debug(`Session started (${this.activeSessionCount} active)`);
     if (this.activeSessionCount === 1) {
       this.startKeepAlive();
     }
@@ -55740,7 +56245,7 @@ class KeepAliveManager {
     if (this.activeSessionCount > 0) {
       this.activeSessionCount--;
     }
-    log6.debug(`Session ended (${this.activeSessionCount} active)`);
+    log7.debug(`Session ended (${this.activeSessionCount} active)`);
     if (this.activeSessionCount === 0) {
       this.stopKeepAlive();
     }
@@ -55754,11 +56259,11 @@ class KeepAliveManager {
   }
   startKeepAlive() {
     if (!this.enabled) {
-      log6.debug("Keep-alive disabled, skipping");
+      log7.debug("Keep-alive disabled, skipping");
       return;
     }
     if (this.keepAliveProcess) {
-      log6.debug("Keep-alive already running");
+      log7.debug("Keep-alive already running");
       return;
     }
     switch (this.platform) {
@@ -55772,12 +56277,12 @@ class KeepAliveManager {
         this.startWindowsKeepAlive();
         break;
       default:
-        log6.warn(`Keep-alive not supported on ${this.platform}`);
+        log7.warn(`Keep-alive not supported on ${this.platform}`);
     }
   }
   stopKeepAlive() {
     if (this.keepAliveProcess) {
-      log6.debug("Stopping keep-alive");
+      log7.debug("Stopping keep-alive");
       this.keepAliveProcess.kill();
       this.keepAliveProcess = null;
     }
@@ -55792,18 +56297,18 @@ class KeepAliveManager {
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log6.error(`Failed to start caffeinate: ${err.message}`);
+        log7.error(`Failed to start caffeinate: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log6.debug(`caffeinate exited with code ${code}`);
+          log7.debug(`caffeinate exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log6.info("Sleep prevention active (caffeinate)");
+      log7.info("Sleep prevention active (caffeinate)");
     } catch (err) {
-      log6.error(`Failed to start caffeinate: ${err}`);
+      log7.error(`Failed to start caffeinate: ${err}`);
     }
   }
   startLinuxKeepAlive() {
@@ -55816,19 +56321,19 @@ class KeepAliveManager {
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log6.debug(`systemd-inhibit not available: ${err.message}`);
+        log7.debug(`systemd-inhibit not available: ${err.message}`);
         this.keepAliveProcess = null;
         this.startLinuxKeepAliveFallback();
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log6.debug(`systemd-inhibit exited with code ${code}`);
+          log7.debug(`systemd-inhibit exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log6.info("Sleep prevention active (systemd-inhibit)");
+      log7.info("Sleep prevention active (systemd-inhibit)");
     } catch (err) {
-      log6.debug(`Failed to start systemd-inhibit: ${err}`);
+      log7.debug(`Failed to start systemd-inhibit: ${err}`);
       this.startLinuxKeepAliveFallback();
     }
   }
@@ -55839,15 +56344,15 @@ class KeepAliveManager {
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log6.warn(`Linux keep-alive fallback not available: ${err.message}`);
+        log7.warn(`Linux keep-alive fallback not available: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", () => {
         this.keepAliveProcess = null;
       });
-      log6.info("Sleep prevention active (xdg-screensaver)");
+      log7.info("Sleep prevention active (xdg-screensaver)");
     } catch (err) {
-      log6.warn(`Linux keep-alive not available: ${err}`);
+      log7.warn(`Linux keep-alive not available: ${err}`);
     }
   }
   startWindowsKeepAlive() {
@@ -55859,32 +56364,25 @@ class KeepAliveManager {
         windowsHide: true
       });
       this.keepAliveProcess.on("error", (err) => {
-        log6.warn(`Windows keep-alive not available: ${err.message}`);
+        log7.warn(`Windows keep-alive not available: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log6.debug(`PowerShell keep-alive exited with code ${code}`);
+          log7.debug(`PowerShell keep-alive exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log6.info("Sleep prevention active (SetThreadExecutionState)");
+      log7.info("Sleep prevention active (SetThreadExecutionState)");
     } catch (err) {
-      log6.warn(`Windows keep-alive not available: ${err}`);
+      log7.warn(`Windows keep-alive not available: ${err}`);
     }
   }
 }
 var keepAlive = new KeepAliveManager;
 
-// src/sponsor.ts
-var SPONSOR_URL = "https://github.com/sponsors/axolotl-systems";
-var MILESTONE_VISIBLE_MS = 24 * 60 * 60 * 1000;
-function formatSponsorFooter(formatter) {
-  return formatter.formatItalic(`♥ Support claude-threads: ${formatter.formatLink("github.com/sponsors/axolotl-systems", SPONSOR_URL)}`);
-}
-
 // src/operations/sticky-message/handler.ts
-var log7 = createLogger("sticky");
+var log8 = createLogger("sticky");
 var botStartedAt = new Date;
 var stickyPostIds = new Map;
 var needsBump = new Map;
@@ -56127,10 +56625,10 @@ init_version_check();
 
 // src/persistence/thread-logger.ts
 init_logger();
-import { homedir as homedir3 } from "os";
-import { join as join3, dirname as dirname4 } from "path";
-var log8 = createLogger("thread-log");
-var LOGS_BASE_DIR = join3(homedir3(), ".claude-threads", "logs");
+import { homedir as homedir4 } from "os";
+import { join as join4, dirname as dirname4 } from "path";
+var log9 = createLogger("thread-log");
+var LOGS_BASE_DIR = join4(homedir4(), ".claude-threads", "logs");
 
 // src/operations/bug-report/handler.ts
 var piiRedactor = new Redactor({ aggressive: true });
@@ -56153,7 +56651,7 @@ class UsernameAnonymizer {
 // src/mcp/decision-bridge.ts
 import { createServer, createConnection } from "node:net";
 import { tmpdir } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 import { randomUUID } from "node:crypto";
 import { mkdtempSync } from "node:fs";
 import { rm } from "node:fs/promises";
@@ -56164,8 +56662,8 @@ function bridgeSocketPath() {
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\ctb-${randomUUID()}`;
   }
-  const dir = mkdtempSync(join4(tmpdir(), "ctb-"));
-  return join4(dir, "b.sock");
+  const dir = mkdtempSync(join5(tmpdir(), "ctb-"));
+  return join5(dir, "b.sock");
 }
 var MAX_BRIDGE_REQUEST_BYTES = 1024 * 1024;
 
@@ -56242,7 +56740,7 @@ class DecisionBridgeServer {
       });
     } catch (err) {
       if (process.platform !== "win32") {
-        await rm(join4(path, ".."), { recursive: true, force: true }).catch(() => {});
+        await rm(join5(path, ".."), { recursive: true, force: true }).catch(() => {});
       }
       throw err;
     }
@@ -56255,7 +56753,7 @@ class DecisionBridgeServer {
       socket.destroy();
     await new Promise((resolve4) => this.server.close(() => resolve4()));
     if (process.platform !== "win32") {
-      await rm(join4(this.path, ".."), { recursive: true, force: true }).catch(() => {});
+      await rm(join5(this.path, ".."), { recursive: true, force: true }).catch(() => {});
     }
   }
 }
@@ -56313,9 +56811,9 @@ init_version_check();
 import { EventEmitter as EventEmitter2 } from "events";
 import { resolve as resolve4, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { existsSync as existsSync4, readFileSync as readFileSync3, watchFile, unwatchFile, unlinkSync, statSync, readdirSync, writeFileSync } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3, watchFile, unwatchFile, unlinkSync, statSync, readdirSync, writeFileSync as writeFileSync2 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/mcp/outbound-env.ts
 var OUTBOUND_ENV = {
@@ -56415,25 +56913,25 @@ function parseRateLimitEvent(event, now = Date.now()) {
 }
 
 // src/claude/cli.ts
-var log9 = createLogger("claude");
+var log10 = createLogger("claude");
 function cleanupBrowserBridgeSockets() {
   try {
     const tempDir = tmpdir2();
     const files = readdirSync(tempDir);
     for (const file2 of files) {
       if (file2.startsWith("claude-mcp-browser-bridge-")) {
-        const filePath = join5(tempDir, file2);
+        const filePath = join6(tempDir, file2);
         try {
           const stats = statSync(filePath);
           if (stats.isSocket()) {
             unlinkSync(filePath);
-            log9.debug(`Removed stale browser bridge socket: ${file2}`);
+            log10.debug(`Removed stale browser bridge socket: ${file2}`);
           }
         } catch {}
       }
     }
   } catch (err) {
-    log9.debug(`Browser bridge cleanup failed: ${err}`);
+    log10.debug(`Browser bridge cleanup failed: ${err}`);
   }
 }
 function buildClaudeChildEnv(parentEnv, account, opts) {
@@ -56455,9 +56953,13 @@ function buildClaudeChildEnv(parentEnv, account, opts) {
     env.USERPROFILE = account.home;
     delete env.ANTHROPIC_API_KEY;
     delete env.CLAUDE_CODE_OAUTH_TOKEN;
+    delete env.ANTHROPIC_AUTH_TOKEN;
+    delete env.CLAUDE_CONFIG_DIR;
+    delete env.CLAUDE_SECURESTORAGE_CONFIG_DIR;
   } else if (account?.apiKey) {
     env.ANTHROPIC_API_KEY = account.apiKey;
     delete env.CLAUDE_CODE_OAUTH_TOKEN;
+    delete env.ANTHROPIC_AUTH_TOKEN;
   }
   return env;
 }
@@ -56492,8 +56994,8 @@ function materializeMcpConfig(config3, sessionId, opts = {}) {
     return { mode: "inline", value: JSON.stringify(config3) };
   }
   const dir = opts.tmpDirOverride ?? tmpdir2();
-  const path = join5(dir, `claude-threads-mcp-${sessionId ?? process.pid}-${Date.now()}.json`);
-  writeFileSync(path, JSON.stringify(config3), { mode: 384 });
+  const path = join6(dir, `claude-threads-mcp-${sessionId ?? process.pid}-${Date.now()}.json`);
+  writeFileSync2(path, JSON.stringify(config3), { mode: 384 });
   return { mode: "file", path };
 }
 function buildPermissionArgs(opts) {
@@ -56689,7 +57191,7 @@ class ClaudeCli extends EventEmitter2 {
     }
     let statusLineCommand;
     if (this.options.sessionId) {
-      this.statusFilePath = join5(tmpdir2(), `claude-threads-status-${this.options.sessionId}.json`);
+      this.statusFilePath = join6(tmpdir2(), `claude-threads-status-${this.options.sessionId}.json`);
       const statusLineWriterPath = this.getStatusLineWriterPath();
       const runtime = runtimeForScriptPath(statusLineWriterPath);
       statusLineCommand = `${runtime} ${statusLineWriterPath} ${this.options.sessionId}`;
@@ -57659,7 +58161,7 @@ handlers.set("model", createPassthroughHandler("model"));
 handlers.set("effort", createPassthroughHandler("effort"));
 // src/commands/system-prompt-generator.ts
 init_logger();
-var log10 = createLogger("system-prompt");
+var log11 = createLogger("system-prompt");
 function formatUserCommand(cmd) {
   const cmdStr = cmd.args ? `\`!${cmd.command} ${cmd.args}\`` : `\`!${cmd.command}\``;
   const description = cmd.description;
@@ -57751,7 +58253,7 @@ ${avoidCommands.map((c) => `- \`!${c.command}\` - ${c.reason}`).join(`
 }
 // src/utils/error-handler/index.ts
 init_logger();
-var log11 = createLogger("error");
+var log12 = createLogger("error");
 
 // src/session/lifecycle.ts
 init_logger();
@@ -57774,35 +58276,35 @@ init_emoji();
 init_spawn();
 import * as path from "path";
 init_logger();
-import { homedir as homedir4 } from "os";
-var log12 = createLogger("git-wt");
-var WORKTREES_DIR = path.join(homedir4(), ".claude-threads", "worktrees");
-var METADATA_STORE_PATH = path.join(homedir4(), ".claude-threads", "worktree-metadata.json");
+import { homedir as homedir5 } from "os";
+var log13 = createLogger("git-wt");
+var WORKTREES_DIR = path.join(homedir5(), ".claude-threads", "worktrees");
+var METADATA_STORE_PATH = path.join(homedir5(), ".claude-threads", "worktree-metadata.json");
 
 // src/operations/post-helpers/index.ts
-var log13 = createLogger("helpers");
-var sessionLog = createSessionLog(log13);
+var log14 = createLogger("helpers");
+var sessionLog = createSessionLog(log14);
 
 // src/operations/suggestions/title.ts
 init_quick_query();
 init_logger();
-var log15 = createLogger("title");
+var log16 = createLogger("title");
 
 // src/operations/suggestions/tag.ts
 init_quick_query();
 init_logger();
-var log16 = createLogger("tags");
+var log17 = createLogger("tags");
 
 // src/session/metadata-suggestions.ts
 init_logger();
-var log17 = createLogger("session");
-var sessionLog2 = createSessionLog(log17);
+var log18 = createLogger("session");
+var sessionLog2 = createSessionLog(log18);
 
 // src/operations/context-prompt/handler.ts
 init_emoji();
 init_logger();
-var log18 = createLogger("context");
-var sessionLog3 = createSessionLog(log18);
+var log19 = createLogger("context");
+var sessionLog3 = createSessionLog(log19);
 var contextPromptTimeouts = new Map;
 var contextPromptFiles = new Map;
 // src/memory/store.ts
@@ -57813,33 +58315,11 @@ import {
   readFileSync as readFileSync4,
   realpathSync
 } from "fs";
-import { homedir as homedir5 } from "os";
-import { basename as basename3, dirname as dirname7, join as join7, sep as sep2 } from "path";
-
-// src/persistence/atomic-file.ts
-import { chmodSync as chmodSync2, renameSync, writeFileSync as writeFileSync2 } from "fs";
-
-class SerialQueue {
-  tail = Promise.resolve();
-  run(fn) {
-    const next = this.tail.then(fn, fn);
-    this.tail = next.catch(() => {
-      return;
-    });
-    return next;
-  }
-}
-function writeFileAtomic(file2, content) {
-  const tempFile = `${file2}.tmp`;
-  writeFileSync2(tempFile, content, { encoding: "utf-8", mode: 384 });
-  renameSync(tempFile, file2);
-  chmodSync2(file2, 384);
-}
-
-// src/memory/store.ts
+import { homedir as homedir6 } from "os";
+import { basename as basename3, dirname as dirname7, join as join8, sep as sep2 } from "path";
 init_logger();
-var log19 = createLogger("memory");
-var DEFAULT_ROOT = join7(homedir5(), ".config", "claude-threads", "memory");
+var log20 = createLogger("memory");
+var DEFAULT_ROOT = join8(homedir6(), ".config", "claude-threads", "memory");
 var CHANNEL_BLOCK_MAX_LINES = 200;
 var CHANNEL_BLOCK_MAX_BYTES = 25 * 1024;
 var CHANNEL_FILE_MAX_ENTRIES = 400;
@@ -57884,10 +58364,10 @@ class MemoryStore {
     return this.root;
   }
   channelMemoryPath(platformId) {
-    return join7(this.root, platformSegment(platformId), "channel", "MEMORY.md");
+    return join8(this.root, platformSegment(platformId), "channel", "MEMORY.md");
   }
   repoMemoryDir(platformId, repoKey) {
-    const dir = join7(this.root, platformSegment(platformId), "repos", repoKey);
+    const dir = join8(this.root, platformSegment(platformId), "repos", repoKey);
     this.ensureDir(dir);
     return dir;
   }
@@ -57934,7 +58414,7 @@ class MemoryStore {
       if (result.added.length > 0) {
         this.enforceFileCap(lines);
         this.writeLines(platformId, lines);
-        log19.debug(`Channel memory for ${platformId}: +${result.added.length} entries` + (result.duplicates.length ? ` (${result.duplicates.length} duplicates skipped)` : ""));
+        log20.debug(`Channel memory for ${platformId}: +${result.added.length} entries` + (result.duplicates.length ? ` (${result.duplicates.length} duplicates skipped)` : ""));
       }
       return result;
     });
@@ -57973,14 +58453,14 @@ class MemoryStore {
       }
       lines.splice(target.lineIndex, 1);
       this.writeLines(platformId, lines);
-      log19.debug(`Channel memory for ${platformId}: removed one entry`);
+      log20.debug(`Channel memory for ${platformId}: removed one entry`);
       return { ok: true, removed: target.entry };
     });
   }
   clearChannel(platformId) {
     return this.runExclusive(platformId, () => {
       this.writeLines(platformId, []);
-      log19.debug(`Channel memory for ${platformId}: cleared`);
+      log20.debug(`Channel memory for ${platformId}: cleared`);
     });
   }
   buildChannelMemoryBlock(platformId) {
@@ -57988,7 +58468,7 @@ class MemoryStore {
     try {
       lines = this.loadLines(platformId);
     } catch (err) {
-      log19.warn(`Failed to read channel memory for ${platformId}: ${err.message}`);
+      log20.warn(`Failed to read channel memory for ${platformId}: ${err.message}`);
       return null;
     }
     if (lines.length === 0)
@@ -58072,7 +58552,7 @@ _(older entries omitted — \`!memory\` shows all)_` : rendered;
 // src/memory/distiller.ts
 init_quick_query();
 init_logger();
-var log20 = createLogger("memory");
+var log21 = createLogger("memory");
 
 // src/session/registry.ts
 function compositeSessionId(platformId, threadId) {
@@ -58165,7 +58645,8 @@ class SessionRegistry {
     return this.sessionStore.findByThread(platformId, threadId);
   }
   getPersistedByThreadId(threadId, platformId) {
-    return this.sessionStore.findByThreadIdAnyState(threadId, platformId);
+    const persisted = this.sessionStore.findByThreadIdAnyState(threadId, platformId);
+    return persisted && isRevivable(persisted) ? persisted : undefined;
   }
   getSessionStore() {
     return this.sessionStore;
@@ -58191,14 +58672,14 @@ class SessionRegistry {
 init_emoji();
 
 // src/persistence/routines-store.ts
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 init_logger();
 
 // src/persistence/platform-list-store.ts
 import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join8 } from "path";
-var STORES_CONFIG_DIR = join8(homedir6(), ".config", "claude-threads");
+import { homedir as homedir7 } from "os";
+import { join as join9 } from "path";
+var STORES_CONFIG_DIR = join9(homedir7(), ".config", "claude-threads");
 var STORE_VERSION = 1;
 
 class PlatformListStore {
@@ -58211,7 +58692,7 @@ class PlatformListStore {
     this.collectionKey = collectionKey;
     if (filePath) {
       this.file = filePath;
-      this.configDir = join8(filePath, "..");
+      this.configDir = join9(filePath, "..");
     } else {
       this.file = defaultFile;
       this.configDir = STORES_CONFIG_DIR;
@@ -58335,41 +58816,41 @@ class PlatformListStore {
 }
 
 // src/persistence/routines-store.ts
-var log21 = createLogger("routines");
-var DEFAULT_FILE = join9(STORES_CONFIG_DIR, "routines.yaml");
+var log22 = createLogger("routines");
+var DEFAULT_FILE = join10(STORES_CONFIG_DIR, "routines.yaml");
 
 // src/routines/parser.ts
 init_logger();
-var log22 = createLogger("routines");
+var log23 = createLogger("routines");
 
 // src/persistence/watches-store.ts
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 init_logger();
-var log23 = createLogger("watches");
-var DEFAULT_FILE2 = join10(STORES_CONFIG_DIR, "watches.yaml");
+var log24 = createLogger("watches");
+var DEFAULT_FILE2 = join11(STORES_CONFIG_DIR, "watches.yaml");
 
 // src/watches/parser.ts
 init_logger();
-var log24 = createLogger("watches");
+var log25 = createLogger("watches");
 
 // src/operations/commands/guards.ts
 init_logger();
-var log25 = createLogger("commands");
-var sessionLog4 = createSessionLog(log25);
+var log26 = createLogger("commands");
+var sessionLog4 = createSessionLog(log26);
 
 // src/operations/commands/automation.ts
 init_logger();
-var log26 = createLogger("commands");
-var sessionLog5 = createSessionLog(log26);
+var log27 = createLogger("commands");
+var sessionLog5 = createSessionLog(log27);
 
 // src/operations/agent-actions/handler.ts
 init_logger();
-var log27 = createLogger("agent-actions");
-var sessionLog6 = createSessionLog(log27);
+var log28 = createLogger("agent-actions");
+var sessionLog6 = createSessionLog(log28);
 
 // src/session/lifecycle.ts
-var log28 = createLogger("lifecycle");
-var sessionLog7 = createSessionLog(log28);
+var log29 = createLogger("lifecycle");
+var sessionLog7 = createSessionLog(log29);
 var _inFlightSessionStarts = new Map;
 var CHAT_PLATFORM_PROMPT = generateChatPlatformPrompt();
 
@@ -58382,39 +58863,39 @@ init_logger();
 init_quick_query();
 
 // src/persistence/github-emails-store.ts
-import { homedir as homedir7 } from "os";
-import { join as join11 } from "path";
+import { homedir as homedir8 } from "os";
+import { join as join12 } from "path";
 init_logger();
-var log29 = createLogger("gh-emails");
-var DEFAULT_CONFIG_DIR = join11(homedir7(), ".config", "claude-threads");
-var DEFAULT_FILE3 = join11(DEFAULT_CONFIG_DIR, "github-emails.yaml");
+var log30 = createLogger("gh-emails");
+var DEFAULT_CONFIG_DIR2 = join12(homedir8(), ".config", "claude-threads");
+var DEFAULT_FILE3 = join12(DEFAULT_CONFIG_DIR2, "github-emails.yaml");
 
 // src/operations/commands/handler.ts
-var log30 = createLogger("commands");
-var sessionLog8 = createSessionLog(log30);
+var log31 = createLogger("commands");
+var sessionLog8 = createSessionLog(log31);
 // src/operations/commands/memory.ts
 init_logger();
-var log31 = createLogger("commands");
-var sessionLog9 = createSessionLog(log31);
+var log32 = createLogger("commands");
+var sessionLog9 = createSessionLog(log32);
 // src/operations/suggestions/branch.ts
 init_quick_query();
 init_logger();
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec2);
-var log32 = createLogger("branch");
+var log33 = createLogger("branch");
 
 // src/operations/worktree/handler.ts
 init_logger();
-var log33 = createLogger("worktree");
-var sessionLog10 = createSessionLog(log33);
+var log34 = createLogger("worktree");
+var sessionLog10 = createSessionLog(log34);
 // src/operations/events/handler.ts
 init_logger();
-var log34 = createLogger("events");
-var sessionLog11 = createSessionLog(log34);
+var log35 = createLogger("events");
+var sessionLog11 = createSessionLog(log35);
 // src/operations/monitor/handler.ts
 init_logger();
-var log35 = createLogger("monitor");
+var log36 = createLogger("monitor");
 var DEFAULT_INTERVAL_MS = 60 * 1000;
 // src/mcp/mcp-server.ts
 init_logger();
@@ -58503,7 +58984,7 @@ init_logger();
 // src/platform/mattermost/upload.ts
 init_logger();
 import { readFile } from "fs/promises";
-var log36 = createLogger("mm-upload");
+var log37 = createLogger("mm-upload");
 async function uploadFileMattermost(args) {
   const { url: url2, token, channelId, threadId, filePath, filename, caption } = args;
   const buffer = await readFile(filePath);
@@ -58511,7 +58992,7 @@ async function uploadFileMattermost(args) {
   const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
   const formData = new FormData;
   formData.append("files", new Blob([arrayBuffer]), filename);
-  log36.debug(`POST /files (${buffer.length} bytes, ${filename})`);
+  log37.debug(`POST /files (${buffer.length} bytes, ${filename})`);
   const uploadResponse = await fetch(uploadUrl, {
     method: "POST",
     headers: {
@@ -58535,7 +59016,7 @@ async function uploadFileMattermost(args) {
     root_id: resolvePostThreadId(threadId),
     file_ids: [fileInfo.id]
   };
-  log36.debug(`POST /posts (file_ids=[${fileInfo.id}])`);
+  log37.debug(`POST /posts (file_ids=[${fileInfo.id}])`);
   const postResponse = await fetch(postUrl, {
     method: "POST",
     headers: {
@@ -59033,7 +59514,7 @@ ${code}
 // src/platform/slack/upload.ts
 init_logger();
 import { readFile as readFile2 } from "fs/promises";
-var log37 = createLogger("slack-upload");
+var log38 = createLogger("slack-upload");
 var DEFAULT_API_URL = "https://slack.com/api";
 async function uploadFileSlack(args) {
   const { botToken, channelId, threadTs, filePath, filename, caption } = args;
@@ -59041,7 +59522,7 @@ async function uploadFileSlack(args) {
   const buffer = await readFile2(filePath);
   const params = new URLSearchParams({ filename, length: String(buffer.length) });
   const step1Url = `${apiUrl}/files.getUploadURLExternal?${params.toString()}`;
-  log37.debug(`GET files.getUploadURLExternal (${buffer.length} bytes, ${filename})`);
+  log38.debug(`GET files.getUploadURLExternal (${buffer.length} bytes, ${filename})`);
   const step1Response = await fetch(step1Url, {
     method: "GET",
     headers: {
@@ -59059,7 +59540,7 @@ async function uploadFileSlack(args) {
   const uploadUrl = step1Data.upload_url;
   const fileId = step1Data.file_id;
   const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-  log37.debug(`POST <upload_url>`);
+  log38.debug(`POST <upload_url>`);
   const step2Response = await fetch(uploadUrl, {
     method: "POST",
     headers: {
@@ -59079,7 +59560,7 @@ async function uploadFileSlack(args) {
   if (caption !== undefined) {
     step3Body.initial_comment = caption;
   }
-  log37.debug(`POST files.completeUploadExternal (file_id=${fileId}, thread_ts=${threadTs})`);
+  log38.debug(`POST files.completeUploadExternal (file_id=${fileId}, thread_ts=${threadTs})`);
   const step3Response = await fetch(`${apiUrl}/files.completeUploadExternal`, {
     method: "POST",
     headers: {
@@ -59097,7 +59578,7 @@ async function uploadFileSlack(args) {
     throw new Error(`Slack completeUploadExternal error: ${step3Data.error || "unknown"}`);
   }
   if (!step3Data.ts) {
-    log37.warn(`Slack completeUploadExternal returned no ts; using fileId ${fileId} as postId. ` + `Do not use this id for updatePost/addReaction.`);
+    log38.warn(`Slack completeUploadExternal returned no ts; using fileId ${fileId} as postId. ` + `Do not use this id for updatePost/addReaction.`);
   }
   return { fileId, postId: step3Data.ts ?? fileId };
 }