@probelabs/probe 0.6.0-rc299 → 0.6.0-rc300

package/cjs/agent/ProbeAgent.cjs

@@ -24013,6 +24013,35 @@ var init_tokenCounter = __esm({
   }
 });
 
+// src/agent/otelLogBridge.js
+var import_module, _require;
+var init_otelLogBridge = __esm({
+  "src/agent/otelLogBridge.js"() {
+    "use strict";
+    import_module = require("module");
+    _require = (0, import_module.createRequire)("file:///");
+  }
+});
+
+// src/agent/simpleTelemetry.js
+function truncateForSpan(text, maxLen = 4096) {
+  if (!text || text.length <= maxLen) return text || "";
+  const half = Math.floor((maxLen - 40) / 2);
+  const omitted = text.length - half * 2;
+  return text.substring(0, half) + `
+... [${omitted} chars omitted] ...
+` + text.substring(text.length - half);
+}
+var import_fs, import_path;
+var init_simpleTelemetry = __esm({
+  "src/agent/simpleTelemetry.js"() {
+    "use strict";
+    import_fs = require("fs");
+    import_path = require("path");
+    init_otelLogBridge();
+  }
+});
+
 // src/agent/storage/StorageAdapter.js
 var StorageAdapter;
 var init_StorageAdapter = __esm({
@@ -24286,7 +24315,7 @@ async function getPackageBinDir() {
     }
     const binaryPath = process.env.PROBE_BINARY_PATH;
     if (await import_fs_extra.default.pathExists(binaryPath)) {
-      const binDir = import_path.default.dirname(binaryPath);
+      const binDir = import_path2.default.dirname(binaryPath);
       if (await canWriteToDirectory(binDir)) {
         if (debug) {
           console.log(`DEBUG: Using PROBE_BINARY_PATH directory: ${binDir}`);
@@ -24301,7 +24330,7 @@ async function getPackageBinDir() {
     if (debug) {
       console.log(`DEBUG: Checking PROBE_CACHE_DIR: ${process.env.PROBE_CACHE_DIR}`);
     }
-    const cacheDir = import_path.default.join(process.env.PROBE_CACHE_DIR, "bin");
+    const cacheDir = import_path2.default.join(process.env.PROBE_CACHE_DIR, "bin");
     if (await ensureDirectory(cacheDir)) {
       if (debug) {
         console.log(`DEBUG: Using PROBE_CACHE_DIR: ${cacheDir}`);
@@ -24314,7 +24343,7 @@ async function getPackageBinDir() {
     if (debug) {
       console.log(`DEBUG: Found package root: ${packageRoot}`);
     }
-    const packageBinDir = import_path.default.join(packageRoot, "bin");
+    const packageBinDir = import_path2.default.join(packageRoot, "bin");
     if (await ensureDirectory(packageBinDir) && await canWriteToDirectory(packageBinDir)) {
       if (debug) {
         console.log(`DEBUG: Using package bin directory: ${packageBinDir}`);
@@ -24324,7 +24353,7 @@ async function getPackageBinDir() {
       console.log(`DEBUG: Package bin directory ${packageBinDir} not writable, trying fallbacks`);
     }
   }
-  const homeCache = import_path.default.join(import_os.default.homedir(), ".probe", "bin");
+  const homeCache = import_path2.default.join(import_os.default.homedir(), ".probe", "bin");
   if (debug) {
     console.log(`DEBUG: Trying home cache directory: ${homeCache}`);
   }
@@ -24334,7 +24363,7 @@ async function getPackageBinDir() {
     }
     return homeCache;
   }
-  const tempCache = import_path.default.join(import_os.default.tmpdir(), "probe-cache", "bin");
+  const tempCache = import_path2.default.join(import_os.default.tmpdir(), "probe-cache", "bin");
   if (debug) {
     console.log(`DEBUG: Trying temp cache directory: ${tempCache}`);
   }
@@ -24347,7 +24376,7 @@ async function getPackageBinDir() {
   const errorMessage = [
     "Could not find a writable directory for probe binary.",
     "Tried the following locations:",
-    packageRoot ? `- Package bin directory: ${import_path.default.join(packageRoot, "bin")}` : "- Package root not found",
+    packageRoot ? `- Package bin directory: ${import_path2.default.join(packageRoot, "bin")}` : "- Package root not found",
     `- Home cache directory: ${homeCache}`,
     `- Temp cache directory: ${tempCache}`,
     "",
@@ -24360,12 +24389,12 @@ async function getPackageBinDir() {
 async function findPackageRoot() {
   const debug = process.env.DEBUG === "1" || process.env.VERBOSE === "1";
   let currentDir = __dirname;
-  const rootDir = import_path.default.parse(currentDir).root;
+  const rootDir = import_path2.default.parse(currentDir).root;
   if (debug) {
     console.log(`DEBUG: Starting package root search from: ${currentDir}`);
   }
   while (currentDir !== rootDir) {
-    const packageJsonPath = import_path.default.join(currentDir, "package.json");
+    const packageJsonPath = import_path2.default.join(currentDir, "package.json");
     try {
       if (await import_fs_extra.default.pathExists(packageJsonPath)) {
         const packageJson = await import_fs_extra.default.readJson(packageJsonPath);
@@ -24384,7 +24413,7 @@ async function findPackageRoot() {
         console.log(`DEBUG: Error reading package.json at ${packageJsonPath}: ${err.message}`);
       }
     }
-    currentDir = import_path.default.dirname(currentDir);
+    currentDir = import_path2.default.dirname(currentDir);
   }
   if (debug) {
     console.log("DEBUG: Package root not found, reached filesystem root");
@@ -24395,7 +24424,7 @@ async function ensureDirectory(dirPath) {
   const debug = process.env.DEBUG === "1" || process.env.VERBOSE === "1";
   try {
     await import_fs_extra.default.ensureDir(dirPath);
-    const testFile = import_path.default.join(dirPath, ".probe-write-test");
+    const testFile = import_path2.default.join(dirPath, ".probe-write-test");
     await import_fs_extra.default.writeFile(testFile, "test");
     await import_fs_extra.default.remove(testFile);
     if (debug) {
@@ -24419,7 +24448,7 @@ async function canWriteToDirectory(dirPath) {
       }
       return false;
     }
-    const testFile = import_path.default.join(dirPath, ".probe-write-test");
+    const testFile = import_path2.default.join(dirPath, ".probe-write-test");
     await import_fs_extra.default.writeFile(testFile, "test");
     await import_fs_extra.default.remove(testFile);
     if (debug) {
@@ -24433,23 +24462,23 @@ async function canWriteToDirectory(dirPath) {
     return false;
   }
 }
-var import_path, import_os, import_fs_extra, import_url, __filename, __dirname;
+var import_path2, import_os, import_fs_extra, import_url, __filename, __dirname;
 var init_directory_resolver = __esm({
   "src/directory-resolver.js"() {
     "use strict";
-    import_path = __toESM(require("path"), 1);
+    import_path2 = __toESM(require("path"), 1);
     import_os = __toESM(require("os"), 1);
     import_fs_extra = __toESM(require("fs-extra"), 1);
     import_url = require("url");
     __filename = (0, import_url.fileURLToPath)("file:///");
-    __dirname = import_path.default.dirname(__filename);
+    __dirname = import_path2.default.dirname(__filename);
   }
 });
 
 // src/utils/symlink-utils.js
 async function getEntryType(entry, fullPath) {
   try {
-    const stats = await import_fs2.promises.stat(fullPath);
+    const stats = await import_fs3.promises.stat(fullPath);
     return {
       isFile: stats.isFile(),
       isDirectory: stats.isDirectory(),
@@ -24465,7 +24494,7 @@ async function getEntryType(entry, fullPath) {
 }
 function getEntryTypeSync(entry, fullPath) {
   try {
-    const stats = import_fs.default.statSync(fullPath);
+    const stats = import_fs2.default.statSync(fullPath);
     return {
       isFile: stats.isFile(),
       isDirectory: stats.isDirectory(),
@@ -24479,12 +24508,12 @@ function getEntryTypeSync(entry, fullPath) {
     };
   }
 }
-var import_fs, import_fs2;
+var import_fs2, import_fs3;
 var init_symlink_utils = __esm({
   "src/utils/symlink-utils.js"() {
     "use strict";
-    import_fs = __toESM(require("fs"), 1);
-    import_fs2 = require("fs");
+    import_fs2 = __toESM(require("fs"), 1);
+    import_fs3 = require("fs");
   }
 });
 
@@ -24913,7 +24942,7 @@ function findBestAsset(assets, osInfo, archInfo) {
 }
 async function downloadAsset(asset, outputDir) {
   await import_fs_extra2.default.ensureDir(outputDir);
-  const assetPath = import_path2.default.join(outputDir, asset.name);
+  const assetPath = import_path3.default.join(outputDir, asset.name);
   if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
     console.log(`Downloading ${asset.name}...`);
   }
@@ -24927,7 +24956,7 @@ async function downloadAsset(asset, outputDir) {
       console.log(`Downloading checksum...`);
     }
     const checksumResponse = await import_axios.default.get(checksumUrl);
-    checksumPath = import_path2.default.join(outputDir, checksumFileName);
+    checksumPath = import_path3.default.join(outputDir, checksumFileName);
     await import_fs_extra2.default.writeFile(checksumPath, checksumResponse.data);
   } catch (error40) {
     if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
@@ -24960,14 +24989,14 @@ async function verifyChecksum(assetPath, checksumPath) {
 }
 async function extractBinary(assetPath, outputDir) {
   if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
-    console.log(`Extracting ${import_path2.default.basename(assetPath)}...`);
+    console.log(`Extracting ${import_path3.default.basename(assetPath)}...`);
   }
-  const assetName = import_path2.default.basename(assetPath);
+  const assetName = import_path3.default.basename(assetPath);
   const isWindows = import_os2.default.platform() === "win32";
   const binaryName = isWindows ? `${BINARY_NAME}.exe` : `${BINARY_NAME}-binary`;
-  const binaryPath = import_path2.default.join(outputDir, binaryName);
+  const binaryPath = import_path3.default.join(outputDir, binaryName);
   try {
-    const extractDir = import_path2.default.join(outputDir, "temp_extract");
+    const extractDir = import_path3.default.join(outputDir, "temp_extract");
     await import_fs_extra2.default.ensureDir(extractDir);
     if (assetName.endsWith(".tar.gz") || assetName.endsWith(".tgz")) {
       if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
@@ -25006,7 +25035,7 @@ async function extractBinary(assetPath, outputDir) {
     const findBinary = async (dir) => {
       const entries = await import_fs_extra2.default.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = import_path2.default.join(dir, entry.name);
+        const fullPath = import_path3.default.join(dir, entry.name);
         const entryType = await getEntryType(entry, fullPath);
         if (entryType.isDirectory) {
           const result = await findBinary(fullPath);
@@ -25045,7 +25074,7 @@ async function extractBinary(assetPath, outputDir) {
 }
 async function getVersionInfo(binDir) {
   try {
-    const versionInfoPath = import_path2.default.join(binDir, "version-info.json");
+    const versionInfoPath = import_path3.default.join(binDir, "version-info.json");
     if (await import_fs_extra2.default.pathExists(versionInfoPath)) {
       const content = await import_fs_extra2.default.readFile(versionInfoPath, "utf-8");
       return JSON.parse(content);
@@ -25061,7 +25090,7 @@ async function saveVersionInfo(version3, binDir) {
     version: version3,
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const versionInfoPath = import_path2.default.join(binDir, "version-info.json");
+  const versionInfoPath = import_path3.default.join(binDir, "version-info.json");
   await import_fs_extra2.default.writeFile(versionInfoPath, JSON.stringify(versionInfo, null, 2));
   if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
     console.log(`Version info saved: ${version3} at ${versionInfoPath}`);
@@ -25070,9 +25099,9 @@ async function saveVersionInfo(version3, binDir) {
 async function getPackageVersion() {
   try {
     const possiblePaths = [
-      import_path2.default.resolve(__dirname2, "..", "package.json"),
+      import_path3.default.resolve(__dirname2, "..", "package.json"),
       // When installed from npm: src/../package.json
-      import_path2.default.resolve(__dirname2, "..", "..", "package.json")
+      import_path3.default.resolve(__dirname2, "..", "..", "package.json")
       // In development: src/../../package.json
     ];
     for (const packageJsonPath of possiblePaths) {
@@ -25107,7 +25136,7 @@ async function doDownload(version3) {
   }
   const isWindows = import_os2.default.platform() === "win32";
   const binaryName = isWindows ? `${BINARY_NAME}.exe` : `${BINARY_NAME}-binary`;
-  const binaryPath = import_path2.default.join(localDir, binaryName);
+  const binaryPath = import_path3.default.join(localDir, binaryName);
   const { os: osInfo, arch: archInfo } = detectOsArch();
   let versionToUse = version3;
   let bestAsset;
@@ -25159,7 +25188,7 @@ async function downloadProbeBinary(version3) {
     }
     const isWindows = import_os2.default.platform() === "win32";
     const binaryName = isWindows ? `${BINARY_NAME}.exe` : `${BINARY_NAME}-binary`;
-    const binaryPath = import_path2.default.join(localDir, binaryName);
+    const binaryPath = import_path3.default.join(localDir, binaryName);
     if (await import_fs_extra2.default.pathExists(binaryPath)) {
       const versionInfo = await getVersionInfo(localDir);
       if (versionInfo && versionInfo.version === version3) {
@@ -25172,7 +25201,7 @@ async function downloadProbeBinary(version3) {
         console.log(`Existing binary version (${versionInfo?.version || "unknown"}) doesn't match requested version (${version3}). Downloading new version...`);
       }
     }
-    const lockPath = import_path2.default.join(localDir, `.probe-download-${version3}.lock`);
+    const lockPath = import_path3.default.join(localDir, `.probe-download-${version3}.lock`);
     const maxRetries = 3;
     for (let retry = 0; retry < maxRetries; retry++) {
       const lockAcquired = await acquireFileLock(lockPath, version3);
@@ -25209,13 +25238,13 @@ async function downloadProbeBinary(version3) {
     throw sanitizeError(error40);
   }
 }
-var import_axios, import_fs_extra2, import_path2, import_crypto, import_util8, import_child_process, import_tar, import_os2, import_url2, exec, REPO_OWNER, REPO_NAME, BINARY_NAME, __filename2, __dirname2, downloadLocks, LOCK_TIMEOUT_MS, LOCK_POLL_INTERVAL_MS, MAX_LOCK_WAIT_MS;
+var import_axios, import_fs_extra2, import_path3, import_crypto, import_util8, import_child_process, import_tar, import_os2, import_url2, exec, REPO_OWNER, REPO_NAME, BINARY_NAME, __filename2, __dirname2, downloadLocks, LOCK_TIMEOUT_MS, LOCK_POLL_INTERVAL_MS, MAX_LOCK_WAIT_MS;
 var init_downloader = __esm({
   "src/downloader.js"() {
     "use strict";
     import_axios = __toESM(require("axios"), 1);
     import_fs_extra2 = __toESM(require("fs-extra"), 1);
-    import_path2 = __toESM(require("path"), 1);
+    import_path3 = __toESM(require("path"), 1);
     import_crypto = require("crypto");
     import_util8 = require("util");
     import_child_process = require("child_process");
@@ -25230,7 +25259,7 @@ var init_downloader = __esm({
     REPO_NAME = "probe";
     BINARY_NAME = "probe";
     __filename2 = (0, import_url2.fileURLToPath)("file:///");
-    __dirname2 = import_path2.default.dirname(__filename2);
+    __dirname2 = import_path3.default.dirname(__filename2);
     downloadLocks = /* @__PURE__ */ new Map();
     LOCK_TIMEOUT_MS = 5 * 60 * 1e3;
     LOCK_POLL_INTERVAL_MS = 1e3;
@@ -25252,14 +25281,14 @@ async function getBinaryPath(options = {}) {
   }
   const isWindows = process.platform === "win32";
   const binaryName = isWindows ? "probe.exe" : "probe-binary";
-  const localPackageBin = import_path3.default.resolve(__dirname3, "..", "bin");
-  const localBinaryPath = import_path3.default.join(localPackageBin, binaryName);
+  const localPackageBin = import_path4.default.resolve(__dirname3, "..", "bin");
+  const localBinaryPath = import_path4.default.join(localPackageBin, binaryName);
   if (import_fs_extra3.default.existsSync(localBinaryPath) && !forceDownload) {
     probeBinaryPath = localBinaryPath;
     return probeBinaryPath;
   }
   const binDir = await getPackageBinDir();
-  const binaryPath = import_path3.default.join(binDir, binaryName);
+  const binaryPath = import_path4.default.join(binDir, binaryName);
   if (import_fs_extra3.default.existsSync(binaryPath) && !forceDownload) {
     probeBinaryPath = binaryPath;
     return probeBinaryPath;
@@ -25295,17 +25324,17 @@ function escapeString(str) {
     return `'${str.replace(/'/g, "'\\''")}'`;
   }
 }
-var import_path3, import_fs_extra3, import_url3, __filename3, __dirname3, probeBinaryPath;
+var import_path4, import_fs_extra3, import_url3, __filename3, __dirname3, probeBinaryPath;
 var init_utils = __esm({
   "src/utils.js"() {
     "use strict";
-    import_path3 = __toESM(require("path"), 1);
+    import_path4 = __toESM(require("path"), 1);
     import_fs_extra3 = __toESM(require("fs-extra"), 1);
     import_url3 = require("url");
     init_downloader();
     init_directory_resolver();
     __filename3 = (0, import_url3.fileURLToPath)("file:///");
-    __dirname3 = import_path3.default.dirname(__filename3);
+    __dirname3 = import_path4.default.dirname(__filename3);
     probeBinaryPath = "";
   }
 });
@@ -25529,16 +25558,16 @@ var init_error_types = __esm({
 // src/utils/path-validation.js
 function safeRealpath(inputPath) {
   try {
-    return (0, import_fs3.realpathSync)(inputPath);
+    return (0, import_fs4.realpathSync)(inputPath);
   } catch (error40) {
-    const normalized = import_path4.default.normalize(inputPath);
-    const parts = normalized.split(import_path4.default.sep);
+    const normalized = import_path5.default.normalize(inputPath);
+    const parts = normalized.split(import_path5.default.sep);
     for (let i = parts.length - 1; i >= 0; i--) {
-      const ancestorPath = parts.slice(0, i).join(import_path4.default.sep) || import_path4.default.sep;
+      const ancestorPath = parts.slice(0, i).join(import_path5.default.sep) || import_path5.default.sep;
       try {
-        const resolvedAncestor = (0, import_fs3.realpathSync)(ancestorPath);
+        const resolvedAncestor = (0, import_fs4.realpathSync)(ancestorPath);
         const remainingParts = parts.slice(i);
-        return import_path4.default.join(resolvedAncestor, ...remainingParts);
+        return import_path5.default.join(resolvedAncestor, ...remainingParts);
       } catch (ancestorError) {
         continue;
       }
@@ -25548,14 +25577,14 @@ function safeRealpath(inputPath) {
 }
 async function validateCwdPath(inputPath, defaultPath = process.cwd()) {
   const targetPath = inputPath || defaultPath;
-  const normalizedPath = import_path4.default.normalize(import_path4.default.resolve(targetPath));
+  const normalizedPath = import_path5.default.normalize(import_path5.default.resolve(targetPath));
   try {
-    const stats = await import_fs3.promises.stat(normalizedPath);
+    const stats = await import_fs4.promises.stat(normalizedPath);
     if (!stats.isDirectory()) {
       const resolvedPath = safeRealpath(normalizedPath);
-      const dirPath = import_path4.default.dirname(resolvedPath);
+      const dirPath = import_path5.default.dirname(resolvedPath);
       try {
-        const dirStats = await import_fs3.promises.stat(dirPath);
+        const dirStats = await import_fs4.promises.stat(dirPath);
         if (dirStats.isDirectory()) {
           return safeRealpath(dirPath);
         }
@@ -25609,7 +25638,7 @@ function getCommonPrefix(folders) {
     return safeRealpath(folders[0]);
   }
   const normalized = folders.map((f) => safeRealpath(f));
-  const segments = normalized.map((f) => f.split(import_path4.default.sep));
+  const segments = normalized.map((f) => f.split(import_path5.default.sep));
   const minLen = Math.min(...segments.map((s) => s.length));
   const commonSegments = [];
   for (let i = 0; i < minLen; i++) {
@@ -25629,7 +25658,7 @@ function getCommonPrefix(folders) {
   if (commonSegments.length === 1 && commonSegments[0] === "") {
     return normalized[0];
   }
-  return commonSegments.join(import_path4.default.sep);
+  return commonSegments.join(import_path5.default.sep);
 }
 function toRelativePath(absolutePath, workspaceRoot) {
   if (!absolutePath || !workspaceRoot) {
@@ -25637,23 +25666,23 @@ function toRelativePath(absolutePath, workspaceRoot) {
   }
   let normalized = safeRealpath(absolutePath);
   let normalizedRoot = safeRealpath(workspaceRoot);
-  while (normalizedRoot.length > 1 && normalizedRoot.endsWith(import_path4.default.sep)) {
+  while (normalizedRoot.length > 1 && normalizedRoot.endsWith(import_path5.default.sep)) {
     normalizedRoot = normalizedRoot.slice(0, -1);
   }
   if (normalized === normalizedRoot) {
     return ".";
   }
-  if (normalized.startsWith(normalizedRoot + import_path4.default.sep)) {
-    return import_path4.default.relative(normalizedRoot, normalized);
+  if (normalized.startsWith(normalizedRoot + import_path5.default.sep)) {
+    return import_path5.default.relative(normalizedRoot, normalized);
   }
   return absolutePath;
 }
-var import_path4, import_fs3;
+var import_path5, import_fs4;
 var init_path_validation = __esm({
   "src/utils/path-validation.js"() {
     "use strict";
-    import_path4 = __toESM(require("path"), 1);
-    import_fs3 = require("fs");
+    import_path5 = __toESM(require("path"), 1);
+    import_fs4 = require("fs");
     init_error_types();
   }
 });
@@ -27182,8 +27211,8 @@ function parseAndResolvePaths(pathStr, cwd) {
   if (/["']/.test(pathStr)) {
     const paths2 = splitQuotedString(pathStr);
     return paths2.map((p) => {
-      if ((0, import_path5.isAbsolute)(p)) return p;
-      return cwd ? (0, import_path5.resolve)(cwd, p) : p;
+      if ((0, import_path6.isAbsolute)(p)) return p;
+      return cwd ? (0, import_path6.resolve)(cwd, p) : p;
     });
   }
   let paths = pathStr.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
@@ -27195,8 +27224,8 @@ function parseAndResolvePaths(pathStr, cwd) {
     return allLookLikePaths ? parts : [p];
   });
   return paths.map((p) => {
-    if ((0, import_path5.isAbsolute)(p)) return p;
-    return cwd ? (0, import_path5.resolve)(cwd, p) : p;
+    if ((0, import_path6.isAbsolute)(p)) return p;
+    return cwd ? (0, import_path6.resolve)(cwd, p) : p;
   });
 }
 function resolveTargetPath(target, cwd) {
@@ -27214,17 +27243,17 @@ function resolveTargetPath(target, cwd) {
     filePart = target;
     suffix = "";
   }
-  if (!(0, import_path5.isAbsolute)(filePart) && cwd) {
-    filePart = (0, import_path5.resolve)(cwd, filePart);
+  if (!(0, import_path6.isAbsolute)(filePart) && cwd) {
+    filePart = (0, import_path6.resolve)(cwd, filePart);
   }
   return filePart + suffix;
 }
-var import_path5, searchSchema, searchAllSchema, querySchema, extractSchema, delegateSchema, listSkillsSchema, useSkillSchema, listFilesSchema, searchFilesSchema, readImageSchema, bashSchema, analyzeAllSchema, executePlanSchema, cleanupExecutePlanSchema, searchDescription, searchDelegateDescription, queryDescription, extractDescription, delegateDescription, analyzeAllDescription;
+var import_path6, searchSchema, searchAllSchema, querySchema, extractSchema, delegateSchema, listSkillsSchema, useSkillSchema, listFilesSchema, searchFilesSchema, readImageSchema, bashSchema, analyzeAllSchema, executePlanSchema, cleanupExecutePlanSchema, searchDescription, searchDelegateDescription, queryDescription, extractDescription, delegateDescription, analyzeAllDescription;
 var init_common = __esm({
   "src/tools/common.js"() {
     "use strict";
     init_zod();
-    import_path5 = require("path");
+    import_path6 = require("path");
     searchSchema = external_exports2.object({
       query: external_exports2.string().describe("Search query \u2014 natural language questions or Elasticsearch-style keywords both work. For keywords: use quotes for exact phrases, AND/OR for boolean logic, - for negation. Probe handles stemming and camelCase/snake_case splitting automatically, so do NOT try case or style variations of the same keyword."),
       path: external_exports2.string().optional().default(".").describe('Path to search in. For dependencies use "go:github.com/owner/repo", "js:package_name", or "rust:cargo_name" etc.'),
@@ -27639,7 +27668,7 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
     "Remember: if your search returned relevant results, use nextPage=true to check for more before outputting."
   ].join("\n");
 }
-var import_ai, import_fs4, CODE_SEARCH_SCHEMA, searchTool, queryTool, extractTool, delegateTool, analyzeAllTool;
+var import_ai, import_fs5, CODE_SEARCH_SCHEMA, searchTool, queryTool, extractTool, delegateTool, analyzeAllTool;
 var init_vercel = __esm({
   "src/tools/vercel.js"() {
     "use strict";
@@ -27650,9 +27679,10 @@ var init_vercel = __esm({
     init_delegate();
     init_analyzeAll();
     init_common();
-    import_fs4 = require("fs");
+    import_fs5 = require("fs");
     init_error_types();
     init_hashline();
+    init_simpleTelemetry();
     CODE_SEARCH_SCHEMA = {
       type: "object",
       properties: {
@@ -27818,6 +27848,12 @@ var init_vercel = __esm({
             const delegateResult = options.tracer?.withSpan ? await options.tracer.withSpan("search.delegate", runDelegation, {
               "search.query": searchQuery,
               "search.path": searchPath
+            }, (span, result) => {
+              const text = typeof result === "string" ? result : "";
+              span.setAttributes({
+                "search.delegate.output": truncateForSpan(text),
+                "search.delegate.output_length": text.length
+              });
             }) : await runDelegation();
             const targets = parseDelegatedTargets(delegateResult);
             if (!targets.length) {
@@ -27837,7 +27873,7 @@ var init_vercel = __esm({
             const validatedTargets = [];
             for (const target of resolvedTargets) {
               const { filePart, suffix } = splitTargetSuffix(target);
-              if ((0, import_fs4.existsSync)(filePart)) {
+              if ((0, import_fs5.existsSync)(filePart)) {
                 validatedTargets.push(target);
                 continue;
               }
@@ -27846,7 +27882,7 @@ var init_vercel = __esm({
               for (let i = 0; i < parts.length - 1; i++) {
                 if (parts[i] === parts[i + 1]) {
                   const candidate = "/" + [...parts.slice(0, i), ...parts.slice(i + 1)].join("/");
-                  if ((0, import_fs4.existsSync)(candidate)) {
+                  if ((0, import_fs5.existsSync)(candidate)) {
                     validatedTargets.push(candidate + suffix);
                     if (debug) console.error(`[search-delegate] Fixed doubled path segment: ${filePart} \u2192 ${candidate}`);
                     fixed = true;
@@ -27859,7 +27895,7 @@ var init_vercel = __esm({
                 if (altBase === delegateBase) continue;
                 const altResolved = resolveTargetPath(target, altBase);
                 const { filePart: altFile } = splitTargetSuffix(altResolved);
-                if ((0, import_fs4.existsSync)(altFile)) {
+                if ((0, import_fs5.existsSync)(altFile)) {
                   validatedTargets.push(altResolved);
                   if (debug) console.error(`[search-delegate] Resolved with alt base: ${filePart} \u2192 ${altFile}`);
                   fixed = true;
@@ -27984,13 +28020,13 @@ var init_vercel = __esm({
                 const { join: pathJoin, sep: pathSep } = await import("path");
                 extractFiles = extractFiles.map((target) => {
                   const { filePart, suffix } = splitTargetSuffix(target);
-                  if ((0, import_fs4.existsSync)(filePart)) return target;
+                  if ((0, import_fs5.existsSync)(filePart)) return target;
                   const cwdPrefix = effectiveCwd.endsWith(pathSep) ? effectiveCwd : effectiveCwd + pathSep;
                   const relativePart = filePart.startsWith(cwdPrefix) ? filePart.slice(cwdPrefix.length) : null;
                   if (relativePart) {
                     for (const folder of options.allowedFolders) {
                       const candidate = pathJoin(folder, relativePart);
-                      if ((0, import_fs4.existsSync)(candidate)) {
+                      if ((0, import_fs5.existsSync)(candidate)) {
                         if (debug) console.error(`[extract] Auto-fixed path: ${filePart} \u2192 ${candidate}`);
                         return candidate + suffix;
                       }
@@ -28003,7 +28039,7 @@ var init_vercel = __esm({
                     if (filePart.startsWith(wsParent)) {
                       const tail = filePart.slice(wsParent.length);
                       const candidate = pathJoin(folderPrefix, tail);
-                      if (candidate !== filePart && (0, import_fs4.existsSync)(candidate)) {
+                      if (candidate !== filePart && (0, import_fs5.existsSync)(candidate)) {
                         if (debug) console.error(`[extract] Auto-fixed path via workspace: ${filePart} \u2192 ${candidate}`);
                         return candidate + suffix;
                       }
@@ -29601,8 +29637,8 @@ async function executeBashCommand(command, options = {}) {
   } = options;
   let cwd = workingDirectory;
   try {
-    cwd = (0, import_path6.resolve)(cwd);
-    if (!(0, import_fs5.existsSync)(cwd)) {
+    cwd = (0, import_path7.resolve)(cwd);
+    if (!(0, import_fs6.existsSync)(cwd)) {
       throw new Error(`Working directory does not exist: ${cwd}`);
     }
   } catch (error40) {
@@ -29858,7 +29894,7 @@ function validateExecutionOptions(options = {}) {
   if (options.workingDirectory) {
     if (typeof options.workingDirectory !== "string") {
       errors.push("workingDirectory must be a string");
-    } else if (!(0, import_fs5.existsSync)(options.workingDirectory)) {
+    } else if (!(0, import_fs6.existsSync)(options.workingDirectory)) {
       errors.push(`workingDirectory does not exist: ${options.workingDirectory}`);
     }
   }
@@ -29871,24 +29907,24 @@ function validateExecutionOptions(options = {}) {
     warnings
   };
 }
-var import_child_process6, import_path6, import_fs5;
+var import_child_process6, import_path7, import_fs6;
 var init_bashExecutor = __esm({
   "src/agent/bashExecutor.js"() {
     "use strict";
     import_child_process6 = require("child_process");
-    import_path6 = require("path");
-    import_fs5 = require("fs");
+    import_path7 = require("path");
+    import_fs6 = require("fs");
     init_bashCommandUtils();
   }
 });
 
 // src/tools/bash.js
-var import_ai2, import_path7, bashTool;
+var import_ai2, import_path8, bashTool;
 var init_bash = __esm({
   "src/tools/bash.js"() {
     "use strict";
     import_ai2 = require("ai");
-    import_path7 = require("path");
+    import_path8 = require("path");
     init_bashPermissions();
     init_bashExecutor();
     init_path_validation();
@@ -30005,12 +30041,12 @@ For code exploration, try these safe alternatives:
 - npm list, pip list for package information`;
             }
             const defaultDir = getDefaultWorkingDirectory();
-            const workingDir = workingDirectory ? (0, import_path7.isAbsolute)(workingDirectory) ? (0, import_path7.resolve)(workingDirectory) : (0, import_path7.resolve)(defaultDir, workingDirectory) : defaultDir;
+            const workingDir = workingDirectory ? (0, import_path8.isAbsolute)(workingDirectory) ? (0, import_path8.resolve)(workingDirectory) : (0, import_path8.resolve)(defaultDir, workingDirectory) : defaultDir;
             if (allowedFolders && allowedFolders.length > 0) {
               const resolvedWorkingDir = safeRealpath(workingDir);
               const isAllowed = allowedFolders.some((folder) => {
                 const resolvedFolder = safeRealpath(folder);
-                return resolvedWorkingDir === resolvedFolder || resolvedWorkingDir.startsWith(resolvedFolder + import_path7.sep);
+                return resolvedWorkingDir === resolvedFolder || resolvedWorkingDir.startsWith(resolvedFolder + import_path8.sep);
               });
               if (!isAllowed) {
                 const relativeDir = toRelativePath(workingDir, workspaceRoot);
@@ -30422,12 +30458,12 @@ function isPathAllowed(filePath, allowedFolders) {
   if (!allowedFolders || allowedFolders.length === 0) {
     const resolvedPath2 = safeRealpath(filePath);
     const cwd = safeRealpath(process.cwd());
-    return resolvedPath2 === cwd || resolvedPath2.startsWith(cwd + import_path8.sep);
+    return resolvedPath2 === cwd || resolvedPath2.startsWith(cwd + import_path9.sep);
   }
   const resolvedPath = safeRealpath(filePath);
   return allowedFolders.some((folder) => {
     const allowedPath = safeRealpath(folder);
-    return resolvedPath === allowedPath || resolvedPath.startsWith(allowedPath + import_path8.sep);
+    return resolvedPath === allowedPath || resolvedPath.startsWith(allowedPath + import_path9.sep);
   });
 }
 function parseFileToolOptions(options = {}) {
@@ -30467,7 +30503,7 @@ Example: <edit><file_path>${file_path}</file_path><symbol>${allMatches[0].qualif
       return `Error editing ${file_path}: Symbol "${symbol17}" has changed since you last read it. Use the extract tool with targets="${file_path}#${symbol17}" to re-read the current content, then retry.`;
     }
   }
-  const content = await import_fs6.promises.readFile(resolvedPath, "utf-8");
+  const content = await import_fs7.promises.readFile(resolvedPath, "utf-8");
   const lines = content.split("\n");
   if (position) {
     const refIndent = detectBaseIndent(symbolInfo.code);
@@ -30478,7 +30514,7 @@ Example: <edit><file_path>${file_path}</file_path><symbol>${allMatches[0].qualif
     } else {
       lines.splice(symbolInfo.startLine - 1, 0, ...newLines, "");
     }
-    await import_fs6.promises.writeFile(resolvedPath, lines.join("\n"), "utf-8");
+    await import_fs7.promises.writeFile(resolvedPath, lines.join("\n"), "utf-8");
     if (fileTracker) {
       const updated = await findSymbol(resolvedPath, symbol17, cwd || process.cwd());
       if (updated) {
@@ -30496,7 +30532,7 @@ Example: <edit><file_path>${file_path}</file_path><symbol>${allMatches[0].qualif
     const reindented = reindent(new_string, originalIndent);
     const newLines = reindented.split("\n");
     lines.splice(symbolInfo.startLine - 1, symbolInfo.endLine - symbolInfo.startLine + 1, ...newLines);
-    await import_fs6.promises.writeFile(resolvedPath, lines.join("\n"), "utf-8");
+    await import_fs7.promises.writeFile(resolvedPath, lines.join("\n"), "utf-8");
     if (fileTracker) {
       const updated = await findSymbol(resolvedPath, symbol17, cwd || process.cwd());
       if (updated) {
@@ -30551,7 +30587,7 @@ async function handleLineEdit({ resolvedPath, file_path, start_line, end_line, n
   if (position !== void 0 && position !== null && position !== "before" && position !== "after") {
     return 'Error editing file: Invalid position - must be "before" or "after". Use position="before" to insert before the line, or position="after" to insert after it.';
   }
-  const content = await import_fs6.promises.readFile(resolvedPath, "utf-8");
+  const content = await import_fs7.promises.readFile(resolvedPath, "utf-8");
   const fileLines = content.split("\n");
   if (startLine > fileLines.length) {
     return `Error editing file: Line ${startLine} is beyond file length (${fileLines.length} lines). Use 'extract' to read the current file content.`;
@@ -30580,20 +30616,20 @@ async function handleLineEdit({ resolvedPath, file_path, start_line, end_line, n
   const newLines = cleaned === "" ? [] : cleaned.split("\n");
   if (position === "after") {
     fileLines.splice(startLine, 0, ...newLines);
-    await import_fs6.promises.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
+    await import_fs7.promises.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
     if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath);
     const action = `${newLines.length} line${newLines.length !== 1 ? "s" : ""} inserted after line ${startLine}`;
     return buildLineEditResponse(file_path, startLine, startLine, newLines.length, fileLines, startLine, action, modifications);
   } else if (position === "before") {
     fileLines.splice(startLine - 1, 0, ...newLines);
-    await import_fs6.promises.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
+    await import_fs7.promises.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
     if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath);
     const action = `${newLines.length} line${newLines.length !== 1 ? "s" : ""} inserted before line ${startLine}`;
     return buildLineEditResponse(file_path, startLine, startLine, newLines.length, fileLines, startLine - 1, action, modifications);
   } else {
     const replacedCount = endLine - startLine + 1;
     fileLines.splice(startLine - 1, replacedCount, ...newLines);
-    await import_fs6.promises.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
+    await import_fs7.promises.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
     if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath);
     let action;
     if (newLines.length === 0) {
@@ -30606,14 +30642,14 @@ async function handleLineEdit({ resolvedPath, file_path, start_line, end_line, n
     return buildLineEditResponse(file_path, startLine, endLine, newLines.length, fileLines, startLine - 1, action, modifications);
   }
 }
-var import_ai3, import_fs6, import_path8, import_fs7, editTool, createTool, multiEditTool, editSchema, createSchema, multiEditSchema, editDescription, createDescription, multiEditDescription, editToolDefinition, createToolDefinition, multiEditToolDefinition;
+var import_ai3, import_fs7, import_path9, import_fs8, editTool, createTool, multiEditTool, editSchema, createSchema, multiEditSchema, editDescription, createDescription, multiEditDescription, editToolDefinition, createToolDefinition, multiEditToolDefinition;
 var init_edit = __esm({
   "src/tools/edit.js"() {
     "use strict";
     import_ai3 = require("ai");
-    import_fs6 = require("fs");
-    import_path8 = require("path");
     import_fs7 = require("fs");
+    import_path9 = require("path");
+    import_fs8 = require("fs");
     init_path_validation();
     init_fuzzyMatch();
     init_symbolEdit();
@@ -30689,7 +30725,7 @@ Parameters:
               return `Error editing file: Invalid new_string - must be a string. Provide the replacement content as a string value (empty string "" is valid for deletions).`;
             }
             const effectiveCwd = workingDirectory || cwd || process.cwd();
-            const resolvedPath = (0, import_path8.isAbsolute)(file_path) ? file_path : (0, import_path8.resolve)(effectiveCwd, file_path);
+            const resolvedPath = (0, import_path9.isAbsolute)(file_path) ? file_path : (0, import_path9.resolve)(effectiveCwd, file_path);
             if (debug) {
               console.error(`[Edit] Attempting to edit file: ${resolvedPath}`);
             }
@@ -30697,7 +30733,7 @@ Parameters:
               const relativePath = toRelativePath(resolvedPath, workspaceRoot);
               return `Error editing file: Permission denied - ${relativePath} is outside allowed directories. Use a file path within the project workspace.`;
             }
-            if (!(0, import_fs7.existsSync)(resolvedPath)) {
+            if (!(0, import_fs8.existsSync)(resolvedPath)) {
               return `Error editing file: File not found - ${file_path}. Verify the path is correct and the file exists. Use 'search' to find files by name, or 'create' to make a new file.`;
             }
             if (options.fileTracker && !options.fileTracker.isFileSeen(resolvedPath)) {
@@ -30725,7 +30761,7 @@ Parameters:
 Use the extract tool with targets="${displayPath}" to re-read the file, then retry.`;
               }
             }
-            const content = await import_fs6.promises.readFile(resolvedPath, "utf-8");
+            const content = await import_fs7.promises.readFile(resolvedPath, "utf-8");
             let matchTarget = old_string;
             let matchStrategy = "exact";
             if (!content.includes(old_string)) {
@@ -30757,7 +30793,7 @@ Use the extract tool with targets="${displayPath}" to re-read the file, then ret
             if (newContent === content) {
               return `Error editing file: No changes made - the replacement result is identical to the original. Verify that old_string and new_string are actually different. If fuzzy matching was used, the matched text may already equal new_string.`;
             }
-            await import_fs6.promises.writeFile(resolvedPath, newContent, "utf-8");
+            await import_fs7.promises.writeFile(resolvedPath, newContent, "utf-8");
             if (options.fileTracker) {
               await options.fileTracker.trackFileAfterWrite(resolvedPath);
               options.fileTracker.recordTextEdit(resolvedPath);
@@ -30820,7 +30856,7 @@ Important:
               return `Error creating file: Invalid content - must be a string. Provide the file content as a string value (empty string "" is valid for an empty file).`;
             }
             const effectiveCwd = workingDirectory || cwd || process.cwd();
-            const resolvedPath = (0, import_path8.isAbsolute)(file_path) ? file_path : (0, import_path8.resolve)(effectiveCwd, file_path);
+            const resolvedPath = (0, import_path9.isAbsolute)(file_path) ? file_path : (0, import_path9.resolve)(effectiveCwd, file_path);
             if (debug) {
               console.error(`[Create] Attempting to create file: ${resolvedPath}`);
             }
@@ -30828,13 +30864,13 @@ Important:
               const relativePath = toRelativePath(resolvedPath, workspaceRoot);
               return `Error creating file: Permission denied - ${relativePath} is outside allowed directories. Use a file path within the project workspace.`;
             }
-            if ((0, import_fs7.existsSync)(resolvedPath) && !overwrite) {
+            if ((0, import_fs8.existsSync)(resolvedPath) && !overwrite) {
               return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
             }
-            const existed = (0, import_fs7.existsSync)(resolvedPath);
-            const dir = (0, import_path8.dirname)(resolvedPath);
-            await import_fs6.promises.mkdir(dir, { recursive: true });
-            await import_fs6.promises.writeFile(resolvedPath, content, "utf-8");
+            const existed = (0, import_fs8.existsSync)(resolvedPath);
+            const dir = (0, import_path9.dirname)(resolvedPath);
+            await import_fs7.promises.mkdir(dir, { recursive: true });
+            await import_fs7.promises.writeFile(resolvedPath, content, "utf-8");
             if (options.fileTracker) await options.fileTracker.trackFileAfterWrite(resolvedPath);
             const action = existed && overwrite ? "overwrote" : "created";
             const bytes = Buffer.byteLength(content, "utf-8");
@@ -45181,22 +45217,22 @@ var init_esm3 = __esm({
 });
 
 // node_modules/path-scurry/dist/esm/index.js
-var import_node_path, import_node_url, import_fs8, actualFS, import_promises, realpathSync2, defaultFS, fsFromOption, uncDriveRegexp, uncToDrive, eitherSep, UNKNOWN, IFIFO, IFCHR, IFDIR, IFBLK, IFREG, IFLNK, IFSOCK, IFMT, IFMT_UNKNOWN, READDIR_CALLED, LSTAT_CALLED, ENOTDIR, ENOENT, ENOREADLINK, ENOREALPATH, ENOCHILD, TYPEMASK, entToType, normalizeCache, normalize, normalizeNocaseCache, normalizeNocase, ResolveCache, ChildrenCache, setAsCwd, PathBase, PathWin32, PathPosix, PathScurryBase, PathScurryWin32, PathScurryPosix, PathScurryDarwin, Path, PathScurry;
+var import_node_path, import_node_url, import_fs9, actualFS, import_promises, realpathSync2, defaultFS, fsFromOption, uncDriveRegexp, uncToDrive, eitherSep, UNKNOWN, IFIFO, IFCHR, IFDIR, IFBLK, IFREG, IFLNK, IFSOCK, IFMT, IFMT_UNKNOWN, READDIR_CALLED, LSTAT_CALLED, ENOTDIR, ENOENT, ENOREADLINK, ENOREALPATH, ENOCHILD, TYPEMASK, entToType, normalizeCache, normalize, normalizeNocaseCache, normalizeNocase, ResolveCache, ChildrenCache, setAsCwd, PathBase, PathWin32, PathPosix, PathScurryBase, PathScurryWin32, PathScurryPosix, PathScurryDarwin, Path, PathScurry;
 var init_esm4 = __esm({
   "node_modules/path-scurry/dist/esm/index.js"() {
     init_esm2();
     import_node_path = require("node:path");
     import_node_url = require("node:url");
-    import_fs8 = require("fs");
+    import_fs9 = require("fs");
     actualFS = __toESM(require("node:fs"), 1);
     import_promises = require("node:fs/promises");
     init_esm3();
-    realpathSync2 = import_fs8.realpathSync.native;
+    realpathSync2 = import_fs9.realpathSync.native;
     defaultFS = {
-      lstatSync: import_fs8.lstatSync,
-      readdir: import_fs8.readdir,
-      readdirSync: import_fs8.readdirSync,
-      readlinkSync: import_fs8.readlinkSync,
+      lstatSync: import_fs9.lstatSync,
+      readdir: import_fs9.readdir,
+      readdirSync: import_fs9.readdirSync,
+      readlinkSync: import_fs9.readlinkSync,
       realpathSync: realpathSync2,
       promises: {
         lstat: import_promises.lstat,
@@ -48725,10 +48761,10 @@ async function listFilesByLevel(options) {
     maxFiles = 100,
     respectGitignore = true
   } = options;
-  if (!import_fs9.default.existsSync(directory)) {
+  if (!import_fs10.default.existsSync(directory)) {
     throw new Error(`Directory does not exist: ${directory}`);
   }
-  const gitDirExists = import_fs9.default.existsSync(import_path9.default.join(directory, ".git"));
+  const gitDirExists = import_fs10.default.existsSync(import_path10.default.join(directory, ".git"));
   if (gitDirExists && respectGitignore) {
     try {
       return await listFilesUsingGit(directory, maxFiles);
@@ -48743,8 +48779,8 @@ async function listFilesUsingGit(directory, maxFiles) {
   const { stdout } = await execAsync3("git ls-files", { cwd: directory });
   const files = stdout.split("\n").filter(Boolean);
   const sortedFiles = files.sort((a, b) => {
-    const depthA = a.split(import_path9.default.sep).length;
-    const depthB = b.split(import_path9.default.sep).length;
+    const depthA = a.split(import_path10.default.sep).length;
+    const depthB = b.split(import_path10.default.sep).length;
     return depthA - depthB;
   });
   return sortedFiles.slice(0, maxFiles);
@@ -48759,25 +48795,25 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   while (queue.length > 0 && result.length < maxFiles) {
     const { dir, level } = queue.shift();
     try {
-      const entries = import_fs9.default.readdirSync(dir, { withFileTypes: true });
+      const entries = import_fs10.default.readdirSync(dir, { withFileTypes: true });
       const files = entries.filter((entry) => {
-        const fullPath = import_path9.default.join(dir, entry.name);
+        const fullPath = import_path10.default.join(dir, entry.name);
         return getEntryTypeSync(entry, fullPath).isFile;
       });
       for (const file2 of files) {
         if (result.length >= maxFiles) break;
-        const filePath = import_path9.default.join(dir, file2.name);
-        const relativePath = import_path9.default.relative(directory, filePath);
+        const filePath = import_path10.default.join(dir, file2.name);
+        const relativePath = import_path10.default.relative(directory, filePath);
         if (shouldIgnore(relativePath, ignorePatterns)) continue;
         result.push(relativePath);
       }
       const dirs = entries.filter((entry) => {
-        const fullPath = import_path9.default.join(dir, entry.name);
+        const fullPath = import_path10.default.join(dir, entry.name);
         return getEntryTypeSync(entry, fullPath).isDirectory;
       });
       for (const subdir of dirs) {
-        const subdirPath = import_path9.default.join(dir, subdir.name);
-        const relativeSubdirPath = import_path9.default.relative(directory, subdirPath);
+        const subdirPath = import_path10.default.join(dir, subdir.name);
+        const relativeSubdirPath = import_path10.default.relative(directory, subdirPath);
         if (shouldIgnore(relativeSubdirPath, ignorePatterns)) continue;
         if (subdir.name === "node_modules" || subdir.name === ".git") continue;
         queue.push({ dir: subdirPath, level: level + 1 });
@@ -48789,12 +48825,12 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   return result;
 }
 function loadGitignorePatterns(directory) {
-  const gitignorePath = import_path9.default.join(directory, ".gitignore");
-  if (!import_fs9.default.existsSync(gitignorePath)) {
+  const gitignorePath = import_path10.default.join(directory, ".gitignore");
+  if (!import_fs10.default.existsSync(gitignorePath)) {
     return [];
   }
   try {
-    const content = import_fs9.default.readFileSync(gitignorePath, "utf8");
+    const content = import_fs10.default.readFileSync(gitignorePath, "utf8");
     return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   } catch (error40) {
     console.error(`Warning: Could not read .gitignore: ${error40.message}`);
@@ -48812,12 +48848,12 @@ function shouldIgnore(filePath, ignorePatterns) {
   }
   return false;
 }
-var import_fs9, import_path9, import_util13, import_child_process7, execAsync3;
+var import_fs10, import_path10, import_util13, import_child_process7, execAsync3;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
-    import_fs9 = __toESM(require("fs"), 1);
-    import_path9 = __toESM(require("path"), 1);
+    import_fs10 = __toESM(require("fs"), 1);
+    import_path10 = __toESM(require("path"), 1);
     import_util13 = require("util");
     import_child_process7 = require("child_process");
     init_symlink_utils();
@@ -48828,7 +48864,7 @@ var init_file_lister = __esm({
 // src/tools/fileTracker.js
 function normalizePath(filePath) {
   if (!filePath) return filePath;
-  return (0, import_path10.resolve)(filePath);
+  return (0, import_path11.resolve)(filePath);
 }
 function computeContentHash(content) {
   const normalized = (content || "").split("\n").map((l) => l.trimEnd()).join("\n");
@@ -48868,12 +48904,12 @@ function parseFilePathsFromOutput(output) {
   }
   return paths;
 }
-var import_crypto3, import_path10, FileTracker;
+var import_crypto3, import_path11, FileTracker;
 var init_fileTracker = __esm({
   "src/tools/fileTracker.js"() {
     "use strict";
     import_crypto3 = require("crypto");
-    import_path10 = require("path");
+    import_path11 = require("path");
     init_symbolEdit();
     FileTracker = class {
       /**
@@ -48974,7 +49010,7 @@ var init_fileTracker = __esm({
         const symbolPromises = [];
         for (const target of targets) {
           const filePath = extractFilePath(target);
-          const resolved = (0, import_path10.isAbsolute)(filePath) ? filePath : (0, import_path10.resolve)(cwd, filePath);
+          const resolved = (0, import_path11.isAbsolute)(filePath) ? filePath : (0, import_path11.resolve)(cwd, filePath);
           if (!seenPaths.has(resolved)) {
             seenPaths.add(resolved);
             this.markFileSeen(resolved);
@@ -49014,7 +49050,7 @@ var init_fileTracker = __esm({
       async trackFilesFromOutput(output, cwd) {
         const paths = parseFilePathsFromOutput(output);
         for (const filePath of paths) {
-          const resolved = (0, import_path10.isAbsolute)(filePath) ? filePath : (0, import_path10.resolve)(cwd, filePath);
+          const resolved = (0, import_path11.isAbsolute)(filePath) ? filePath : (0, import_path11.resolve)(cwd, filePath);
           this.markFileSeen(resolved);
         }
       }
@@ -49122,27 +49158,6 @@ var init_fileTracker = __esm({
   }
 });
 
-// src/agent/otelLogBridge.js
-var import_module, _require;
-var init_otelLogBridge = __esm({
-  "src/agent/otelLogBridge.js"() {
-    "use strict";
-    import_module = require("module");
-    _require = (0, import_module.createRequire)("file:///");
-  }
-});
-
-// src/agent/simpleTelemetry.js
-var import_fs10, import_path11;
-var init_simpleTelemetry = __esm({
-  "src/agent/simpleTelemetry.js"() {
-    "use strict";
-    import_fs10 = require("fs");
-    import_path11 = require("path");
-    init_otelLogBridge();
-  }
-});
-
 // src/agent/probeTool.js
 function isSessionCancelled(sessionId) {
   return activeToolExecutions.get(sessionId)?.cancelled || false;
@@ -100006,6 +100021,7 @@ var init_ProbeAgent = __esm({
     import_promises6 = require("fs/promises");
     import_path18 = require("path");
     init_tokenCounter();
+    init_simpleTelemetry();
     init_InMemoryStorageAdapter();
     init_HookManager();
     init_imageConfig();
@@ -103344,7 +103360,7 @@ Double-check your response based on the criteria above. If everything looks good
               };
               let aiResult;
               if (this.tracer) {
-                const inputPreview = message.length > 1e3 ? message.substring(0, 1e3) + "... [truncated]" : message;
+                const inputPreview = truncateForSpan(message, 4096);
                 aiResult = await this.tracer.withSpan("ai.request", executeAIRequest, {
                   "ai.model": this.model,
                   "ai.provider": this.clientApiProvider || "auto",
@@ -103354,6 +103370,12 @@ Double-check your response based on the criteria above. If everything looks good
                   "max_tokens": maxResponseTokens,
                   "temperature": 0.3,
                   "message_count": currentMessages.length
+                }, (span, result) => {
+                  const text = result?.finalText || "";
+                  span.setAttributes({
+                    "ai.output": truncateForSpan(text),
+                    "ai.output_length": text.length
+                  });
                 });
               } else {
                 aiResult = await executeAIRequest();