@caspian2026/agent-sdk 0.0.9 → 0.0.12

package/dist/{chunk-pd2vy8hx.js → chunk-yb6xww2x.js}

@@ -44,6 +44,8 @@ import {
   isArray_default,
   isBuffer_default,
   keys_default,
+  setLastAPIRequest,
+  setLastAPIRequestMessages,
   stubArray_default
 } from "./chunk-k8vp0atq.js";
 import {
@@ -70,6 +72,7 @@ import {
   __callDispose,
   __esm,
   __export,
+  __require,
   __using
 } from "./chunk-qp2qdcda.js";
 
@@ -4534,6 +4537,71 @@ var init_errors2 = __esm(() => {
   };
 });
 
+// src/constants/xml.ts
+var COMMAND_NAME_TAG = "command-name", COMMAND_MESSAGE_TAG = "command-message", COMMAND_ARGS_TAG = "command-args", BASH_INPUT_TAG = "bash-input", BASH_STDOUT_TAG = "bash-stdout", BASH_STDERR_TAG = "bash-stderr", LOCAL_COMMAND_STDOUT_TAG = "local-command-stdout", LOCAL_COMMAND_STDERR_TAG = "local-command-stderr", LOCAL_COMMAND_CAVEAT_TAG = "local-command-caveat", TERMINAL_OUTPUT_TAGS, TICK_TAG = "tick", TASK_NOTIFICATION_TAG = "task-notification", TASK_ID_TAG = "task-id", TOOL_USE_ID_TAG = "tool-use-id", TASK_TYPE_TAG = "task-type", OUTPUT_FILE_TAG = "output-file", STATUS_TAG = "status", SUMMARY_TAG = "summary", WORKTREE_TAG = "worktree", WORKTREE_PATH_TAG = "worktreePath", WORKTREE_BRANCH_TAG = "worktreeBranch", REMOTE_REVIEW_TAG = "remote-review", REMOTE_REVIEW_PROGRESS_TAG = "remote-review-progress", TEAMMATE_MESSAGE_TAG = "teammate-message", CHANNEL_TAG = "channel", FORK_BOILERPLATE_TAG = "fork-boilerplate", FORK_DIRECTIVE_PREFIX = "Your directive: ", COMMON_HELP_ARGS, COMMON_INFO_ARGS;
+var init_xml = __esm(() => {
+  TERMINAL_OUTPUT_TAGS = [
+    BASH_INPUT_TAG,
+    BASH_STDOUT_TAG,
+    BASH_STDERR_TAG,
+    LOCAL_COMMAND_STDOUT_TAG,
+    LOCAL_COMMAND_STDERR_TAG,
+    LOCAL_COMMAND_CAVEAT_TAG
+  ];
+  COMMON_HELP_ARGS = ["help", "-h", "--help"];
+  COMMON_INFO_ARGS = [
+    "list",
+    "show",
+    "display",
+    "current",
+    "view",
+    "get",
+    "check",
+    "describe",
+    "print",
+    "version",
+    "about",
+    "status",
+    "?"
+  ];
+});
+
+// src/types/logs.ts
+function sortLogs(logs) {
+  return logs.sort((a, b) => {
+    const modifiedDiff = b.modified.getTime() - a.modified.getTime();
+    if (modifiedDiff !== 0) {
+      return modifiedDiff;
+    }
+    return b.created.getTime() - a.created.getTime();
+  });
+}
+var init_logs = () => {};
+
+// src/utils/privacyLevel.ts
+function getPrivacyLevel() {
+  if (process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC) {
+    return "essential-traffic";
+  }
+  if (process.env.DISABLE_TELEMETRY) {
+    return "no-telemetry";
+  }
+  return "default";
+}
+function isEssentialTrafficOnly() {
+  return getPrivacyLevel() === "essential-traffic";
+}
+function isTelemetryDisabled() {
+  return getPrivacyLevel() !== "default";
+}
+function getEssentialTrafficOnlyReason() {
+  if (process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC) {
+    return "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC";
+  }
+  return null;
+}
+var init_privacyLevel = () => {};
+
 // node_modules/.bun/lodash-es@4.17.23/node_modules/lodash-es/_arrayEach.js
 function arrayEach(array, iteratee) {
   var index = -1, length = array == null ? 0 : array.length;
@@ -5167,6 +5235,377 @@ var init_debugFilter = __esm(() => {
   });
 });
 
+// node_modules/.bun/is-safe-filename@0.1.1/node_modules/is-safe-filename/index.js
+function isSafeFilename(filename) {
+  if (typeof filename !== "string") {
+    return false;
+  }
+  const trimmed = filename.trim();
+  return trimmed !== "" && trimmed !== "." && trimmed !== ".." && !filename.includes("/") && !filename.includes("\\") && !filename.includes("\x00");
+}
+function assertSafeFilename(filename) {
+  if (typeof filename !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  if (!isSafeFilename(filename)) {
+    throw new Error(`Unsafe filename: ${JSON.stringify(filename)}`);
+  }
+}
+var unsafeFilenameFixtures;
+var init_is_safe_filename = __esm(() => {
+  unsafeFilenameFixtures = Object.freeze([
+    "",
+    "   ",
+    ".",
+    "..",
+    " .",
+    ". ",
+    " ..",
+    ".. ",
+    "../",
+    "../foo",
+    "foo/../bar",
+    "foo/bar",
+    "foo\\bar",
+    "foo\x00bar"
+  ]);
+});
+
+// node_modules/.bun/env-paths@4.0.0/node_modules/env-paths/index.js
+import path2 from "path";
+import os from "os";
+import process2 from "process";
+function envPaths(name, { suffix = "nodejs" } = {}) {
+  assertSafeFilename(name);
+  if (suffix) {
+    name += `-${suffix}`;
+  }
+  assertSafeFilename(name);
+  if (process2.platform === "darwin") {
+    return macos(name);
+  }
+  if (process2.platform === "win32") {
+    return windows(name);
+  }
+  return linux(name);
+}
+var homedir, tmpdir, env, macos = (name) => {
+  const library = path2.join(homedir, "Library");
+  return {
+    data: path2.join(library, "Application Support", name),
+    config: path2.join(library, "Preferences", name),
+    cache: path2.join(library, "Caches", name),
+    log: path2.join(library, "Logs", name),
+    temp: path2.join(tmpdir, name)
+  };
+}, windows = (name) => {
+  const appData = env.APPDATA || path2.join(homedir, "AppData", "Roaming");
+  const localAppData = env.LOCALAPPDATA || path2.join(homedir, "AppData", "Local");
+  return {
+    data: path2.join(localAppData, name, "Data"),
+    config: path2.join(appData, name, "Config"),
+    cache: path2.join(localAppData, name, "Cache"),
+    log: path2.join(localAppData, name, "Log"),
+    temp: path2.join(tmpdir, name)
+  };
+}, linux = (name) => {
+  const username = path2.basename(homedir);
+  return {
+    data: path2.join(env.XDG_DATA_HOME || path2.join(homedir, ".local", "share"), name),
+    config: path2.join(env.XDG_CONFIG_HOME || path2.join(homedir, ".config"), name),
+    cache: path2.join(env.XDG_CACHE_HOME || path2.join(homedir, ".cache"), name),
+    log: path2.join(env.XDG_STATE_HOME || path2.join(homedir, ".local", "state"), name),
+    temp: path2.join(tmpdir, username, name)
+  };
+};
+var init_env_paths = __esm(() => {
+  init_is_safe_filename();
+  homedir = os.homedir();
+  tmpdir = os.tmpdir();
+  ({ env } = process2);
+});
+
+// src/utils/hash.ts
+function djb2Hash(str) {
+  let hash = 0;
+  for (let i = 0;i < str.length; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i) | 0;
+  }
+  return hash;
+}
+function hashContent(content) {
+  if (typeof Bun !== "undefined") {
+    return Bun.hash(content).toString();
+  }
+  const crypto = __require("crypto");
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+function hashPair(a, b) {
+  if (typeof Bun !== "undefined") {
+    return Bun.hash(b, Bun.hash(a)).toString();
+  }
+  const crypto = __require("crypto");
+  return crypto.createHash("sha256").update(a).update("\x00").update(b).digest("hex");
+}
+var init_hash = () => {};
+
+// src/utils/cachePaths.ts
+import { join } from "path";
+function sanitizePath(name) {
+  const sanitized = name.replace(/[^a-zA-Z0-9]/g, "-");
+  if (sanitized.length <= MAX_SANITIZED_LENGTH) {
+    return sanitized;
+  }
+  return `${sanitized.slice(0, MAX_SANITIZED_LENGTH)}-${Math.abs(djb2Hash(name)).toString(36)}`;
+}
+function getProjectDir(cwd) {
+  return sanitizePath(cwd);
+}
+var paths, MAX_SANITIZED_LENGTH = 200, CACHE_PATHS;
+var init_cachePaths = __esm(() => {
+  init_env_paths();
+  init_fsOperations();
+  init_hash();
+  paths = envPaths("claude-cli");
+  CACHE_PATHS = {
+    baseLogs: () => join(paths.cache, getProjectDir(getFsImplementation().cwd())),
+    errors: () => join(paths.cache, getProjectDir(getFsImplementation().cwd()), "errors"),
+    messages: () => join(paths.cache, getProjectDir(getFsImplementation().cwd()), "messages"),
+    mcpLogs: (serverName) => join(paths.cache, getProjectDir(getFsImplementation().cwd()), `mcp-logs-${sanitizePath(serverName)}`)
+  };
+});
+
+// src/utils/displayTags.ts
+function stripDisplayTags(text) {
+  const result = text.replace(XML_TAG_BLOCK_PATTERN, "").trim();
+  return result || text;
+}
+function stripDisplayTagsAllowEmpty(text) {
+  return text.replace(XML_TAG_BLOCK_PATTERN, "").trim();
+}
+function stripIdeContextTags(text) {
+  return text.replace(IDE_CONTEXT_TAGS_PATTERN, "").trim();
+}
+var XML_TAG_BLOCK_PATTERN, IDE_CONTEXT_TAGS_PATTERN;
+var init_displayTags = __esm(() => {
+  XML_TAG_BLOCK_PATTERN = /<([a-z][\w-]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>\n?/g;
+  IDE_CONTEXT_TAGS_PATTERN = /<(ide_opened_file|ide_selection)(?:\s[^>]*)?>[\s\S]*?<\/\1>\n?/g;
+});
+
+// src/utils/log.ts
+function getLogDisplayTitle(log, defaultTitle) {
+  const isAutonomousPrompt = log.firstPrompt?.startsWith(`<${TICK_TAG}>`);
+  const strippedFirstPrompt = log.firstPrompt ? stripDisplayTagsAllowEmpty(log.firstPrompt) : "";
+  const useFirstPrompt = strippedFirstPrompt && !isAutonomousPrompt;
+  const title = log.agentName || log.customTitle || log.summary || (useFirstPrompt ? strippedFirstPrompt : undefined) || defaultTitle || (isAutonomousPrompt ? "Autonomous session" : undefined) || (log.sessionId ? log.sessionId.slice(0, 8) : "") || "";
+  return stripDisplayTags(title).trim();
+}
+function dateToFilename(date) {
+  return date.toISOString().replace(/[:.]/g, "-");
+}
+function addToInMemoryErrorLog(errorInfo) {
+  if (inMemoryErrorLog.length >= MAX_IN_MEMORY_ERRORS) {
+    inMemoryErrorLog.shift();
+  }
+  inMemoryErrorLog.push(errorInfo);
+}
+function attachErrorLogSink(newSink) {
+  if (errorLogSink !== null) {
+    return;
+  }
+  errorLogSink = newSink;
+  if (errorQueue.length > 0) {
+    const queuedEvents = [...errorQueue];
+    errorQueue.length = 0;
+    for (const event of queuedEvents) {
+      switch (event.type) {
+        case "error":
+          errorLogSink.logError(event.error);
+          break;
+        case "mcpError":
+          errorLogSink.logMCPError(event.serverName, event.error);
+          break;
+        case "mcpDebug":
+          errorLogSink.logMCPDebug(event.serverName, event.message);
+          break;
+      }
+    }
+  }
+}
+function logError(error2) {
+  const err = toError(error2);
+  if (false) {}
+  try {
+    if (process.env.DISABLE_ERROR_REPORTING || isEssentialTrafficOnly()) {
+      return;
+    }
+    const errorStr = err.stack || err.message;
+    const errorInfo = {
+      error: errorStr,
+      timestamp: new Date().toISOString()
+    };
+    addToInMemoryErrorLog(errorInfo);
+    if (errorLogSink === null) {
+      errorQueue.push({ type: "error", error: err });
+      return;
+    }
+    errorLogSink.logError(err);
+  } catch {}
+}
+function getInMemoryErrors() {
+  return [...inMemoryErrorLog];
+}
+function logMCPError(serverName, error2) {
+  try {
+    if (errorLogSink === null) {
+      errorQueue.push({ type: "mcpError", serverName, error: error2 });
+      return;
+    }
+    errorLogSink.logMCPError(serverName, error2);
+  } catch {}
+}
+function logMCPDebug(serverName, message) {
+  try {
+    if (errorLogSink === null) {
+      errorQueue.push({ type: "mcpDebug", serverName, message });
+      return;
+    }
+    errorLogSink.logMCPDebug(serverName, message);
+  } catch {}
+}
+function captureAPIRequest(params, querySource) {
+  if (!querySource || !querySource.startsWith("repl_main_thread")) {
+    return;
+  }
+  const { messages, ...paramsWithoutMessages } = params;
+  setLastAPIRequest(paramsWithoutMessages);
+  setLastAPIRequestMessages(process.env.USER_TYPE === "ant" ? messages : null);
+}
+var MAX_IN_MEMORY_ERRORS = 100, inMemoryErrorLog, errorQueue, errorLogSink = null, isHardFailMode;
+var init_log2 = __esm(() => {
+  init_memoize();
+  init_state();
+  init_xml();
+  init_logs();
+  init_cachePaths();
+  init_displayTags();
+  init_errors2();
+  init_privacyLevel();
+  init_slowOperations();
+  inMemoryErrorLog = [];
+  errorQueue = [];
+  isHardFailMode = memoize_default(() => {
+    return process.argv.includes("--hard-fail");
+  });
+});
+
+// src/utils/platform.ts
+import { readdir, readFile } from "fs/promises";
+import { release as osRelease } from "os";
+async function detectVcs(dir) {
+  const detected = new Set;
+  if (process.env.P4PORT) {
+    detected.add("perforce");
+  }
+  try {
+    const targetDir = dir ?? getFsImplementation().cwd();
+    const entries = new Set(await readdir(targetDir));
+    for (const [marker, vcs] of VCS_MARKERS) {
+      if (entries.has(marker)) {
+        detected.add(vcs);
+      }
+    }
+  } catch {}
+  return [...detected];
+}
+var SUPPORTED_PLATFORMS, getPlatform, getWslVersion, getLinuxDistroInfo, VCS_MARKERS;
+var init_platform = __esm(() => {
+  init_memoize();
+  init_fsOperations();
+  init_log2();
+  SUPPORTED_PLATFORMS = ["macos", "wsl"];
+  getPlatform = memoize_default(() => {
+    try {
+      if (process.platform === "darwin") {
+        return "macos";
+      }
+      if (process.platform === "win32") {
+        return "windows";
+      }
+      if (process.platform === "linux") {
+        try {
+          const procVersion = getFsImplementation().readFileSync("/proc/version", { encoding: "utf8" });
+          if (procVersion.toLowerCase().includes("microsoft") || procVersion.toLowerCase().includes("wsl")) {
+            return "wsl";
+          }
+        } catch (error2) {
+          logError(error2);
+        }
+        return "linux";
+      }
+      return "unknown";
+    } catch (error2) {
+      logError(error2);
+      return "unknown";
+    }
+  });
+  getWslVersion = memoize_default(() => {
+    if (process.platform !== "linux") {
+      return;
+    }
+    try {
+      const procVersion = getFsImplementation().readFileSync("/proc/version", {
+        encoding: "utf8"
+      });
+      const wslVersionMatch = procVersion.match(/WSL(\d+)/i);
+      if (wslVersionMatch && wslVersionMatch[1]) {
+        return wslVersionMatch[1];
+      }
+      if (procVersion.toLowerCase().includes("microsoft")) {
+        return "1";
+      }
+      return;
+    } catch (error2) {
+      logError(error2);
+      return;
+    }
+  });
+  getLinuxDistroInfo = memoize_default(async () => {
+    if (process.platform !== "linux") {
+      return;
+    }
+    const result = {
+      linuxKernel: osRelease()
+    };
+    try {
+      const content = await readFile("/etc/os-release", "utf8");
+      for (const line of content.split(`
+`)) {
+        const match = line.match(/^(ID|VERSION_ID)=(.*)$/);
+        if (match && match[1] && match[2]) {
+          const value = match[2].replace(/^"|"$/g, "");
+          if (match[1] === "ID") {
+            result.linuxDistroId = value;
+          } else {
+            result.linuxDistroVersion = value;
+          }
+        }
+      }
+    } catch {}
+    return result;
+  });
+  VCS_MARKERS = [
+    [".git", "git"],
+    [".hg", "mercurial"],
+    [".svn", "svn"],
+    [".p4config", "perforce"],
+    ["$tf", "tfs"],
+    [".tfvc", "tfs"],
+    [".jj", "jujutsu"],
+    [".sl", "sapling"]
+  ];
+});
+
 // src/utils/fsOperations.ts
 import * as fs from "fs";
 import {
@@ -5180,8 +5619,37 @@ import {
   stat as statPromise,
   unlink as unlinkPromise
 } from "fs/promises";
-import { homedir } from "os";
+import { homedir as homedir2 } from "os";
 import * as nodePath from "path";
+function countReplacementChars(s) {
+  let count = 0;
+  for (let i = 0;i < s.length; i++) {
+    if (s.charCodeAt(i) === 65533)
+      count++;
+  }
+  return count;
+}
+function decodeBuffer(buffer, length) {
+  const slice = buffer.subarray(0, length);
+  if (getPlatform() !== "windows") {
+    return slice.toString("utf8");
+  }
+  const utf8Str = slice.toString("utf8");
+  const utf8Bad = countReplacementChars(utf8Str);
+  if (utf8Bad < 3) {
+    return utf8Str;
+  }
+  try {
+    if (!gbkDecoder) {
+      gbkDecoder = new TextDecoder("gbk");
+    }
+    const gbkStr = gbkDecoder.decode(slice);
+    const gbkBad = countReplacementChars(gbkStr);
+    return gbkBad < utf8Bad ? gbkStr : utf8Str;
+  } catch {
+    return utf8Str;
+  }
+}
 function safeResolvePath(fs2, filePath) {
   if (filePath.startsWith("//") || filePath.startsWith("\\\\")) {
     return { resolvedPath: filePath, isSymlink: false, isCanonical: false };
@@ -5242,20 +5710,20 @@ function resolveDeepestExistingAncestorSync(fs2, absolutePath) {
   return;
 }
 function getPathsForPermissionCheck(inputPath) {
-  let path2 = inputPath;
-  if (path2 === "~") {
-    path2 = homedir().normalize("NFC");
-  } else if (path2.startsWith("~/")) {
-    path2 = nodePath.join(homedir().normalize("NFC"), path2.slice(2));
+  let path3 = inputPath;
+  if (path3 === "~") {
+    path3 = homedir2().normalize("NFC");
+  } else if (path3.startsWith("~/")) {
+    path3 = nodePath.join(homedir2().normalize("NFC"), path3.slice(2));
   }
   const pathSet = new Set;
   const fsImpl = getFsImplementation();
-  pathSet.add(path2);
-  if (path2.startsWith("//") || path2.startsWith("\\\\")) {
+  pathSet.add(path3);
+  if (path3.startsWith("//") || path3.startsWith("\\\\")) {
     return Array.from(pathSet);
   }
   try {
-    let currentPath = path2;
+    let currentPath = path3;
     const visited = new Set;
     const maxDepth = 40;
     for (let depth = 0;depth < maxDepth; depth++) {
@@ -5264,8 +5732,8 @@ function getPathsForPermissionCheck(inputPath) {
       }
       visited.add(currentPath);
       if (!fsImpl.existsSync(currentPath)) {
-        if (currentPath === path2) {
-          const resolved = resolveDeepestExistingAncestorSync(fsImpl, path2);
+        if (currentPath === path3) {
+          const resolved = resolveDeepestExistingAncestorSync(fsImpl, path3);
           if (resolved !== undefined) {
             pathSet.add(resolved);
           }
@@ -5285,8 +5753,8 @@ function getPathsForPermissionCheck(inputPath) {
       currentPath = absoluteTarget;
     }
   } catch {}
-  const { resolvedPath, isSymlink } = safeResolvePath(fsImpl, path2);
-  if (isSymlink && resolvedPath !== path2) {
+  const { resolvedPath, isSymlink } = safeResolvePath(fsImpl, path3);
+  if (isSymlink && resolvedPath !== path3) {
     pathSet.add(resolvedPath);
   }
   return Array.from(pathSet);
@@ -5294,10 +5762,10 @@ function getPathsForPermissionCheck(inputPath) {
 function getFsImplementation() {
   return activeFs;
 }
-async function readFileRange(path2, offset, maxBytes) {
+async function readFileRange(path3, offset, maxBytes) {
   let __stack = [];
   try {
-    const fh = __using(__stack, await open(path2, "r"), 1);
+    const fh = __using(__stack, await open(path3, "r"), 1);
     const size = (await fh.stat()).size;
     if (size <= offset) {
       return null;
@@ -5313,7 +5781,7 @@ async function readFileRange(path2, offset, maxBytes) {
       totalRead += bytesRead;
     }
     return {
-      content: buffer.toString("utf8", 0, totalRead),
+      content: decodeBuffer(buffer, totalRead),
       bytesRead: totalRead,
       bytesTotal: size
     };
@@ -5324,10 +5792,10 @@ async function readFileRange(path2, offset, maxBytes) {
     _promise && await _promise;
   }
 }
-async function tailFile(path2, maxBytes) {
+async function tailFile(path3, maxBytes) {
   let __stack = [];
   try {
-    const fh = __using(__stack, await open(path2, "r"), 1);
+    const fh = __using(__stack, await open(path3, "r"), 1);
     const size = (await fh.stat()).size;
     if (size === 0) {
       return { content: "", bytesRead: 0, bytesTotal: 0 };
@@ -5344,7 +5812,7 @@ async function tailFile(path2, maxBytes) {
       totalRead += bytesRead;
     }
     return {
-      content: buffer.toString("utf8", 0, totalRead),
+      content: decodeBuffer(buffer, totalRead),
       bytesRead: totalRead,
       bytesTotal: size
     };
@@ -5355,9 +5823,9 @@ async function tailFile(path2, maxBytes) {
     _promise && await _promise;
   }
 }
-async function* readLinesReverse(path2) {
+async function* readLinesReverse(path3) {
   const CHUNK_SIZE = 1024 * 4;
-  const fileHandle = await open(path2, "r");
+  const fileHandle = await open(path3, "r");
   try {
     const stats = await fileHandle.stat();
     let position = stats.size;
@@ -5393,9 +5861,10 @@ async function* readLinesReverse(path2) {
     await fileHandle.close();
   }
 }
-var NodeFsOperations, activeFs;
+var gbkDecoder = null, NodeFsOperations, activeFs;
 var init_fsOperations = __esm(() => {
   init_errors2();
+  init_platform();
   init_slowOperations();
   NodeFsOperations = {
     cwd() {
@@ -5505,13 +5974,13 @@ var init_fsOperations = __esm(() => {
         __callDispose(__stack, _err, _hasErr);
       }
     },
-    appendFileSync(path2, data, options) {
+    appendFileSync(path3, data, options) {
       let __stack = [];
       try {
-        const _ = __using(__stack, slowLogging`fs.appendFileSync(${path2}, ${data.length} chars)`, 0);
+        const _ = __using(__stack, slowLogging`fs.appendFileSync(${path3}, ${data.length} chars)`, 0);
         if (options?.mode !== undefined) {
           try {
-            const fd = fs.openSync(path2, "ax", options.mode);
+            const fd = fs.openSync(path3, "ax", options.mode);
             try {
               fs.appendFileSync(fd, data);
             } finally {
@@ -5523,7 +5992,7 @@ var init_fsOperations = __esm(() => {
               throw e;
           }
         }
-        fs.appendFileSync(path2, data);
+        fs.appendFileSync(path3, data);
       } catch (_catch) {
         var _err = _catch, _hasErr = 1;
       } finally {
@@ -5541,11 +6010,11 @@ var init_fsOperations = __esm(() => {
         __callDispose(__stack, _err, _hasErr);
       }
     },
-    unlinkSync(path2) {
+    unlinkSync(path3) {
       let __stack = [];
       try {
-        const _ = __using(__stack, slowLogging`fs.unlinkSync(${path2})`, 0);
-        fs.unlinkSync(path2);
+        const _ = __using(__stack, slowLogging`fs.unlinkSync(${path3})`, 0);
+        fs.unlinkSync(path3);
       } catch (_catch) {
         var _err = _catch, _hasErr = 1;
       } finally {
@@ -5563,44 +6032,44 @@ var init_fsOperations = __esm(() => {
         __callDispose(__stack, _err, _hasErr);
       }
     },
-    linkSync(target, path2) {
+    linkSync(target, path3) {
       let __stack = [];
       try {
-        const _ = __using(__stack, slowLogging`fs.linkSync(${target} \u2192 ${path2})`, 0);
-        fs.linkSync(target, path2);
+        const _ = __using(__stack, slowLogging`fs.linkSync(${target} \u2192 ${path3})`, 0);
+        fs.linkSync(target, path3);
       } catch (_catch) {
         var _err = _catch, _hasErr = 1;
       } finally {
         __callDispose(__stack, _err, _hasErr);
       }
     },
-    symlinkSync(target, path2, type) {
+    symlinkSync(target, path3, type) {
       let __stack = [];
       try {
-        const _ = __using(__stack, slowLogging`fs.symlinkSync(${target} \u2192 ${path2})`, 0);
-        fs.symlinkSync(target, path2, type);
+        const _ = __using(__stack, slowLogging`fs.symlinkSync(${target} \u2192 ${path3})`, 0);
+        fs.symlinkSync(target, path3, type);
       } catch (_catch) {
         var _err = _catch, _hasErr = 1;
       } finally {
         __callDispose(__stack, _err, _hasErr);
       }
     },
-    readlinkSync(path2) {
+    readlinkSync(path3) {
       let __stack = [];
       try {
-        const _ = __using(__stack, slowLogging`fs.readlinkSync(${path2})`, 0);
-        return fs.readlinkSync(path2);
+        const _ = __using(__stack, slowLogging`fs.readlinkSync(${path3})`, 0);
+        return fs.readlinkSync(path3);
       } catch (_catch) {
         var _err = _catch, _hasErr = 1;
       } finally {
         __callDispose(__stack, _err, _hasErr);
       }
     },
-    realpathSync(path2) {
+    realpathSync(path3) {
       let __stack = [];
       try {
-        const _ = __using(__stack, slowLogging`fs.realpathSync(${path2})`, 0);
-        return fs.realpathSync(path2).normalize("NFC");
+        const _ = __using(__stack, slowLogging`fs.realpathSync(${path3})`, 0);
+        return fs.realpathSync(path3).normalize("NFC");
       } catch (_catch) {
         var _err = _catch, _hasErr = 1;
       } finally {
@@ -5674,19 +6143,19 @@ var init_fsOperations = __esm(() => {
         __callDispose(__stack, _err, _hasErr);
       }
     },
-    rmSync(path2, options) {
+    rmSync(path3, options) {
       let __stack = [];
       try {
-        const _ = __using(__stack, slowLogging`fs.rmSync(${path2})`, 0);
-        fs.rmSync(path2, options);
+        const _ = __using(__stack, slowLogging`fs.rmSync(${path3})`, 0);
+        fs.rmSync(path3, options);
       } catch (_catch) {
         var _err = _catch, _hasErr = 1;
       } finally {
         __callDispose(__stack, _err, _hasErr);
       }
     },
-    createWriteStream(path2) {
-      return fs.createWriteStream(path2);
+    createWriteStream(path3) {
+      return fs.createWriteStream(path3);
     },
     async readFileBytes(fsPath, maxBytes) {
       if (maxBytes === undefined) {
@@ -5715,7 +6184,7 @@ var init_fsOperations = __esm(() => {
 
 // src/utils/debug.ts
 import { appendFile, mkdir, symlink, unlink } from "fs/promises";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname as dirname2, join as join3 } from "path";
 function enableDebugLogging() {
   const wasActive = isDebugMode() || process.env.USER_TYPE === "ant";
   runtimeDebugEnabled = true;
@@ -5736,11 +6205,11 @@ function shouldLogDebugMessage(message) {
 function setHasFormattedOutput(value) {
   hasFormattedOutput = value;
 }
-async function appendAsync(needMkdir, dir, path2, content) {
+async function appendAsync(needMkdir, dir, path3, content) {
   if (needMkdir) {
     await mkdir(dir, { recursive: true }).catch(() => {});
   }
-  await appendFile(path2, content);
+  await appendFile(path3, content);
   updateLatestDebugLogSymlink();
 }
 function noop2() {}
@@ -5749,8 +6218,8 @@ function getDebugWriter() {
     let ensuredDir = null;
     debugWriter = createBufferedWriter({
       writeFn: (content) => {
-        const path2 = getDebugLogPath();
-        const dir = dirname2(path2);
+        const path3 = getDebugLogPath();
+        const dir = dirname2(path3);
         const needMkdir = ensuredDir !== dir;
         ensuredDir = dir;
         if (isDebugMode()) {
@@ -5759,11 +6228,11 @@ function getDebugWriter() {
               getFsImplementation().mkdirSync(dir);
             } catch {}
           }
-          getFsImplementation().appendFileSync(path2, content);
+          getFsImplementation().appendFileSync(path3, content);
           updateLatestDebugLogSymlink();
           return;
         }
-        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path2, content)).catch(noop2);
+        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path3, content)).catch(noop2);
       },
       flushIntervalMs: 1000,
       maxBufferSize: 100,
@@ -5799,7 +6268,7 @@ function logForDebugging(message, { level } = {
   getDebugWriter().write(output);
 }
 function getDebugLogPath() {
-  return getDebugFilePath() ?? process.env.CLAUDE_CODE_DEBUG_LOGS_DIR ?? join2(getClaudeConfigHomeDir(), "debug", `${getSessionId()}.txt`);
+  return getDebugFilePath() ?? process.env.CLAUDE_CODE_DEBUG_LOGS_DIR ?? join3(getClaudeConfigHomeDir(), "debug", `${getSessionId()}.txt`);
 }
 function logAntError(context, error2) {
   if (process.env.USER_TYPE !== "ant") {
@@ -5868,7 +6337,7 @@ var init_debug = __esm(() => {
     try {
       const debugLogPath = getDebugLogPath();
       const debugLogsDir = dirname2(debugLogPath);
-      const latestSymlinkPath = join2(debugLogsDir, "latest");
+      const latestSymlinkPath = join3(debugLogsDir, "latest");
       await unlink(latestSymlinkPath).catch(() => {});
       await symlink(debugLogPath, latestSymlinkPath);
     } catch {}
@@ -5968,4 +6437,4 @@ var init_slowOperations = __esm(() => {
   slowLogging = slowLoggingExternal;
 });
 
-export { createBufferedWriter, init_bufferedWriter, registerCleanup, runCleanupFunctions, init_cleanupRegistry, APIError, APIUserAbortError, APIConnectionError, APIConnectionTimeoutError, AuthenticationError, NotFoundError, init_error2 as init_error, Anthropic, init_sdk, ClaudeError, MalformedCommandError, AbortError, isAbortError2 as isAbortError, ConfigParseError, ShellError, TeleportOperationError, TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, hasExactErrorMessage, toError, errorMessage, getErrnoCode, isENOENT, getErrnoPath, isFsInaccessible, classifyAxiosError, init_errors2 as init_errors, _defineProperty_default, init__defineProperty, _baseAssignValue_default, init__baseAssignValue, _assignValue_default, init__assignValue, _copyObject_default, init__copyObject, keysIn_default, init_keysIn, _cloneBuffer_default, init__cloneBuffer, _copyArray_default, init__copyArray, _getPrototype_default, init__getPrototype, _getAllKeysIn_default, init__getAllKeysIn, _cloneTypedArray_default, init__cloneTypedArray, _initCloneObject_default, init__initCloneObject, _baseClone_default, init__baseClone, cloneDeep_default, init_cloneDeep, slowLogging, jsonStringify, jsonParse, clone, writeFileSync_DEPRECATED, init_slowOperations, safeResolvePath, isDuplicatePath, getPathsForPermissionCheck, getFsImplementation, readFileRange, tailFile, readLinesReverse, init_fsOperations, isDebugMode, enableDebugLogging, isDebugToStdErr, setHasFormattedOutput, logForDebugging, getDebugLogPath, logAntError, init_debug };
+export { createBufferedWriter, init_bufferedWriter, registerCleanup, runCleanupFunctions, init_cleanupRegistry, APIError, APIUserAbortError, APIConnectionError, APIConnectionTimeoutError, AuthenticationError, NotFoundError, init_error2 as init_error, Anthropic, init_sdk, ClaudeError, MalformedCommandError, AbortError, isAbortError2 as isAbortError, ConfigParseError, ShellError, TeleportOperationError, TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, hasExactErrorMessage, toError, errorMessage, getErrnoCode, isENOENT, getErrnoPath, isFsInaccessible, classifyAxiosError, init_errors2 as init_errors, COMMAND_NAME_TAG, COMMAND_MESSAGE_TAG, COMMAND_ARGS_TAG, BASH_INPUT_TAG, BASH_STDOUT_TAG, BASH_STDERR_TAG, LOCAL_COMMAND_STDOUT_TAG, LOCAL_COMMAND_STDERR_TAG, LOCAL_COMMAND_CAVEAT_TAG, TERMINAL_OUTPUT_TAGS, TICK_TAG, TASK_NOTIFICATION_TAG, TASK_ID_TAG, TOOL_USE_ID_TAG, TASK_TYPE_TAG, OUTPUT_FILE_TAG, STATUS_TAG, SUMMARY_TAG, WORKTREE_TAG, WORKTREE_PATH_TAG, WORKTREE_BRANCH_TAG, REMOTE_REVIEW_TAG, REMOTE_REVIEW_PROGRESS_TAG, TEAMMATE_MESSAGE_TAG, CHANNEL_TAG, FORK_BOILERPLATE_TAG, FORK_DIRECTIVE_PREFIX, COMMON_HELP_ARGS, COMMON_INFO_ARGS, init_xml, sortLogs, init_logs, djb2Hash, hashContent, hashPair, init_hash, CACHE_PATHS, init_cachePaths, stripDisplayTags, stripIdeContextTags, init_displayTags, isEssentialTrafficOnly, isTelemetryDisabled, getEssentialTrafficOnlyReason, init_privacyLevel, _defineProperty_default, init__defineProperty, _baseAssignValue_default, init__baseAssignValue, _assignValue_default, init__assignValue, _copyObject_default, init__copyObject, keysIn_default, init_keysIn, _cloneBuffer_default, init__cloneBuffer, _copyArray_default, init__copyArray, _getPrototype_default, init__getPrototype, _getAllKeysIn_default, init__getAllKeysIn, _cloneTypedArray_default, init__cloneTypedArray, _initCloneObject_default, init__initCloneObject, _baseClone_default, init__baseClone, cloneDeep_default, init_cloneDeep, slowLogging, jsonStringify, jsonParse, clone, writeFileSync_DEPRECATED, init_slowOperations, getLogDisplayTitle, dateToFilename, attachErrorLogSink, logError, getInMemoryErrors, logMCPError, logMCPDebug, captureAPIRequest, init_log2 as init_log, SUPPORTED_PLATFORMS, getPlatform, getWslVersion, getLinuxDistroInfo, detectVcs, init_platform, safeResolvePath, isDuplicatePath, getPathsForPermissionCheck, getFsImplementation, readFileRange, tailFile, readLinesReverse, init_fsOperations, isDebugMode, enableDebugLogging, isDebugToStdErr, setHasFormattedOutput, logForDebugging, getDebugLogPath, logAntError, init_debug };