@probelabs/probe 0.6.0-rc253 → 0.6.0-rc255

package/cjs/index.cjs

@@ -720,7 +720,7 @@ async function waitForFileLock(lockPath, binaryPath) {
       }
     } catch {
     }
-    await new Promise((resolve7) => setTimeout(resolve7, LOCK_POLL_INTERVAL_MS));
+    await new Promise((resolve8) => setTimeout(resolve8, LOCK_POLL_INTERVAL_MS));
   }
   if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
     console.log(`Timeout waiting for file lock`);
@@ -2075,7 +2075,7 @@ Cwd: ${cwd}`;
   }
 }
 function extractWithStdin(binaryPath, cliArgs, content, options, cwd) {
-  return new Promise((resolve7, reject2) => {
+  return new Promise((resolve8, reject2) => {
     const childProcess = (0, import_child_process4.spawn)(binaryPath, ["extract", ...cliArgs], {
       stdio: ["pipe", "pipe", "pipe"],
       cwd
@@ -2098,7 +2098,7 @@ function extractWithStdin(binaryPath, cliArgs, content, options, cwd) {
       }
       try {
         const result = processExtractOutput(stdout, options);
-        resolve7(result);
+        resolve8(result);
       } catch (error2) {
         reject2(error2);
       }
@@ -4186,7 +4186,7 @@ var require_headStream = __commonJS({
       if ((0, stream_type_check_1.isReadableStream)(stream2)) {
         return (0, headStream_browser_1.headStream)(stream2, bytes);
       }
-      return new Promise((resolve7, reject2) => {
+      return new Promise((resolve8, reject2) => {
         const collector = new Collector();
         collector.limit = bytes;
         stream2.pipe(collector);
@@ -4197,7 +4197,7 @@ var require_headStream = __commonJS({
         collector.on("error", reject2);
         collector.on("finish", function() {
           const bytes2 = new Uint8Array(Buffer.concat(this.buffers));
-          resolve7(bytes2);
+          resolve8(bytes2);
         });
       });
     };
@@ -4385,21 +4385,21 @@ var require_dist_cjs15 = __commonJS({
       let sendBody = true;
       if (!externalAgent && expect === "100-continue") {
         sendBody = await Promise.race([
-          new Promise((resolve7) => {
-            timeoutId = Number(timing.setTimeout(() => resolve7(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
+          new Promise((resolve8) => {
+            timeoutId = Number(timing.setTimeout(() => resolve8(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
           }),
-          new Promise((resolve7) => {
+          new Promise((resolve8) => {
             httpRequest.on("continue", () => {
               timing.clearTimeout(timeoutId);
-              resolve7(true);
+              resolve8(true);
             });
             httpRequest.on("response", () => {
               timing.clearTimeout(timeoutId);
-              resolve7(false);
+              resolve8(false);
             });
             httpRequest.on("error", () => {
               timing.clearTimeout(timeoutId);
-              resolve7(false);
+              resolve8(false);
             });
           })
         ]);
@@ -4471,13 +4471,13 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         return socketWarningTimestamp;
       }
       constructor(options) {
-        this.configProvider = new Promise((resolve7, reject2) => {
+        this.configProvider = new Promise((resolve8, reject2) => {
           if (typeof options === "function") {
             options().then((_options) => {
-              resolve7(this.resolveDefaultConfig(_options));
+              resolve8(this.resolveDefaultConfig(_options));
             }).catch(reject2);
           } else {
-            resolve7(this.resolveDefaultConfig(options));
+            resolve8(this.resolveDefaultConfig(options));
           }
         });
       }
@@ -4520,7 +4520,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
           const config = this.config;
           let writeRequestBodyPromise = void 0;
           const timeouts = [];
-          const resolve7 = async (arg) => {
+          const resolve8 = async (arg) => {
             await writeRequestBodyPromise;
             timeouts.forEach(timing.clearTimeout);
             _resolve(arg);
@@ -4586,7 +4586,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
               headers: getTransformedHeaders(res.headers),
               body: res
             });
-            resolve7({ response: httpResponse });
+            resolve8({ response: httpResponse });
           });
           req.on("error", (err) => {
             if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) {
@@ -4766,13 +4766,13 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         return new _NodeHttp2Handler(instanceOrOptions);
       }
       constructor(options) {
-        this.configProvider = new Promise((resolve7, reject2) => {
+        this.configProvider = new Promise((resolve8, reject2) => {
           if (typeof options === "function") {
             options().then((opts) => {
-              resolve7(opts || {});
+              resolve8(opts || {});
             }).catch(reject2);
           } else {
-            resolve7(options || {});
+            resolve8(options || {});
           }
         });
       }
@@ -4792,7 +4792,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         return new Promise((_resolve, _reject) => {
           let fulfilled = false;
           let writeRequestBodyPromise = void 0;
-          const resolve7 = async (arg) => {
+          const resolve8 = async (arg) => {
             await writeRequestBodyPromise;
             _resolve(arg);
           };
@@ -4848,7 +4848,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
               body: req
             });
             fulfilled = true;
-            resolve7({ response: httpResponse });
+            resolve8({ response: httpResponse });
             if (disableConcurrentStreams) {
               session.close();
               this.connectionManager.deleteSession(authority, session);
@@ -4925,7 +4925,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
       if (isReadableStreamInstance(stream3)) {
         return collectReadableStream(stream3);
       }
-      return new Promise((resolve7, reject2) => {
+      return new Promise((resolve8, reject2) => {
         const collector = new Collector();
         stream3.pipe(collector);
         stream3.on("error", (err) => {
@@ -4935,7 +4935,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         collector.on("error", reject2);
         collector.on("finish", function() {
           const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes));
-          resolve7(bytes);
+          resolve8(bytes);
         });
       });
     };
@@ -4979,7 +4979,7 @@ var require_dist_cjs16 = __commonJS({
       return new Request(url, requestOptions);
     }
     function requestTimeout(timeoutInMs = 0) {
-      return new Promise((resolve7, reject2) => {
+      return new Promise((resolve8, reject2) => {
         if (timeoutInMs) {
           setTimeout(() => {
             const timeoutError = new Error(`Request did not complete within ${timeoutInMs} ms`);
@@ -5097,7 +5097,7 @@ var require_dist_cjs16 = __commonJS({
           requestTimeout(requestTimeoutInMs)
         ];
         if (abortSignal) {
-          raceOfPromises.push(new Promise((resolve7, reject2) => {
+          raceOfPromises.push(new Promise((resolve8, reject2) => {
             const onAbort = () => {
               const abortError = new Error("Request aborted");
               abortError.name = "AbortError";
@@ -5161,7 +5161,7 @@ var require_dist_cjs16 = __commonJS({
       return collected;
     }
     function readToBase64(blob) {
-      return new Promise((resolve7, reject2) => {
+      return new Promise((resolve8, reject2) => {
         const reader = new FileReader();
         reader.onloadend = () => {
           if (reader.readyState !== 2) {
@@ -5170,7 +5170,7 @@ var require_dist_cjs16 = __commonJS({
           const result = reader.result ?? "";
           const commaIndex = result.indexOf(",");
           const dataOffset = commaIndex > -1 ? commaIndex + 1 : result.length;
-          resolve7(result.substring(dataOffset));
+          resolve8(result.substring(dataOffset));
         };
         reader.onabort = () => reject2(new Error("Read aborted"));
         reader.onerror = () => reject2(reader.error);
@@ -6838,11 +6838,11 @@ function __metadata(metadataKey, metadataValue) {
 }
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve7) {
-      resolve7(value);
+    return value instanceof P ? value : new P(function(resolve8) {
+      resolve8(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve7, reject2) {
+  return new (P || (P = Promise))(function(resolve8, reject2) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -6858,7 +6858,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve7(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve8(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -7049,14 +7049,14 @@ function __asyncValues(o5) {
   }, i5);
   function verb(n5) {
     i5[n5] = o5[n5] && function(v5) {
-      return new Promise(function(resolve7, reject2) {
-        v5 = o5[n5](v5), settle(resolve7, reject2, v5.done, v5.value);
+      return new Promise(function(resolve8, reject2) {
+        v5 = o5[n5](v5), settle(resolve8, reject2, v5.done, v5.value);
       });
     };
   }
-  function settle(resolve7, reject2, d5, v5) {
+  function settle(resolve8, reject2, d5, v5) {
     Promise.resolve(v5).then(function(v6) {
-      resolve7({ value: v6, done: d5 });
+      resolve8({ value: v6, done: d5 });
     }, reject2);
   }
 }
@@ -17457,7 +17457,7 @@ var require_dist_cjs37 = __commonJS({
         this.sockets[url] = (this.sockets[url] ?? []).filter((socket) => ![WebSocket.CLOSING, WebSocket.CLOSED].includes(socket.readyState));
       }
       waitForReady(socket, connectionTimeout) {
-        return new Promise((resolve7, reject2) => {
+        return new Promise((resolve8, reject2) => {
           const timeout = setTimeout(() => {
             this.removeNotUsableSockets(socket.url);
             reject2({
@@ -17469,7 +17469,7 @@ var require_dist_cjs37 = __commonJS({
           }, connectionTimeout);
           socket.onopen = () => {
             clearTimeout(timeout);
-            resolve7();
+            resolve8();
           };
         });
       }
@@ -17522,8 +17522,8 @@ var require_dist_cjs37 = __commonJS({
                 }
                 return { done: item.done, value: item.value };
               }
-              return new Promise((resolve7, reject2) => {
-                pendingResolve = resolve7;
+              return new Promise((resolve8, reject2) => {
+                pendingResolve = resolve8;
                 pendingReject = reject2;
               });
             }
@@ -18736,7 +18736,7 @@ var require_dist_cjs46 = __commonJS({
         this.refillTokenBucket();
         if (amount > this.currentCapacity) {
           const delay = (amount - this.currentCapacity) / this.fillRate * 1e3;
-          await new Promise((resolve7) => _DefaultRateLimiter.setTimeoutFn(resolve7, delay));
+          await new Promise((resolve8) => _DefaultRateLimiter.setTimeoutFn(resolve8, delay));
         }
         this.currentCapacity = this.currentCapacity - amount;
       }
@@ -19071,7 +19071,7 @@ var require_dist_cjs47 = __commonJS({
               const delayFromResponse = getDelayFromRetryAfterHeader(err.$response);
               const delay = Math.max(delayFromResponse || 0, delayFromDecider);
               totalDelay += delay;
-              await new Promise((resolve7) => setTimeout(resolve7, delay));
+              await new Promise((resolve8) => setTimeout(resolve8, delay));
               continue;
             }
             if (!err.$metadata) {
@@ -19229,7 +19229,7 @@ var require_dist_cjs47 = __commonJS({
             attempts = retryToken.getRetryCount();
             const delay = retryToken.getRetryDelay();
             totalRetryDelay += delay;
-            await new Promise((resolve7) => setTimeout(resolve7, delay));
+            await new Promise((resolve8) => setTimeout(resolve8, delay));
           }
         }
       } else {
@@ -19381,7 +19381,7 @@ var require_package2 = __commonJS({
     module2.exports = {
       name: "@aws-sdk/client-bedrock-runtime",
       description: "AWS SDK for JavaScript Bedrock Runtime Client for Node.js, Browser and React Native",
-      version: "3.994.0",
+      version: "3.995.0",
       scripts: {
         build: "concurrently 'yarn:build:types' 'yarn:build:es' && yarn build:cjs",
         "build:cjs": "node ../../scripts/compilation/inline client-bedrock-runtime",
@@ -19411,11 +19411,11 @@ var require_package2 = __commonJS({
         "@aws-sdk/middleware-user-agent": "^3.972.11",
         "@aws-sdk/middleware-websocket": "^3.972.6",
         "@aws-sdk/region-config-resolver": "^3.972.3",
-        "@aws-sdk/token-providers": "3.994.0",
+        "@aws-sdk/token-providers": "3.995.0",
         "@aws-sdk/types": "^3.973.1",
-        "@aws-sdk/util-endpoints": "3.994.0",
+        "@aws-sdk/util-endpoints": "3.995.0",
         "@aws-sdk/util-user-agent-browser": "^3.972.3",
-        "@aws-sdk/util-user-agent-node": "^3.972.9",
+        "@aws-sdk/util-user-agent-node": "^3.972.10",
         "@smithy/config-resolver": "^4.4.6",
         "@smithy/core": "^3.23.2",
         "@smithy/eventstream-serde-browser": "^4.2.8",
@@ -19544,7 +19544,7 @@ var require_dist_cjs49 = __commonJS({
     var nodeConfigProvider = require_dist_cjs43();
     var urlParser = require_dist_cjs22();
     function httpRequest(options) {
-      return new Promise((resolve7, reject2) => {
+      return new Promise((resolve8, reject2) => {
         const req = http.request({
           method: "GET",
           ...options,
@@ -19569,7 +19569,7 @@ var require_dist_cjs49 = __commonJS({
             chunks.push(chunk);
           });
           res.on("end", () => {
-            resolve7(buffer.Buffer.concat(chunks));
+            resolve8(buffer.Buffer.concat(chunks));
             req.destroy();
           });
         });
@@ -19989,7 +19989,7 @@ var require_retry_wrapper = __commonJS({
           try {
             return await toRetry();
           } catch (e5) {
-            await new Promise((resolve7) => setTimeout(resolve7, delayMs));
+            await new Promise((resolve8) => setTimeout(resolve8, delayMs));
           }
         }
         return await toRetry();
@@ -20297,6 +20297,15 @@ var require_dist_cjs51 = __commonJS({
     var os4 = require("os");
     var process2 = require("process");
     var middlewareUserAgent = require_dist_cjs29();
+    var getRuntimeUserAgentPair = () => {
+      const runtimesToCheck = ["deno", "bun", "llrt"];
+      for (const runtime of runtimesToCheck) {
+        if (process2.versions[runtime]) {
+          return [`md/${runtime}`, process2.versions[runtime]];
+        }
+      }
+      return ["md/nodejs", process2.versions.node];
+    };
     var crtAvailability = {
       isCrtAvailable: false
     };
@@ -20307,13 +20316,14 @@ var require_dist_cjs51 = __commonJS({
       return null;
     };
     var createDefaultUserAgentProvider5 = ({ serviceId, clientVersion }) => {
+      const runtimeUserAgentPair = getRuntimeUserAgentPair();
       return async (config) => {
         const sections = [
           ["aws-sdk-js", clientVersion],
           ["ua", "2.1"],
           [`os/${os4.platform()}`, os4.release()],
           ["lang/js"],
-          ["md/nodejs", `${process2.versions.node}`]
+          runtimeUserAgentPair
         ];
         const crtAvailable = isCrtAvailable();
         if (crtAvailable) {
@@ -25876,8 +25886,8 @@ var require_dist_cjs66 = __commonJS({
           systemClockOffsetProvider: this.systemClockOffsetProvider
         });
         let resolvePipeline;
-        const pipelineError = new Promise((resolve7, reject2) => {
-          resolvePipeline = () => resolve7(void 0);
+        const pipelineError = new Promise((resolve8, reject2) => {
+          resolvePipeline = () => resolve8(void 0);
           node_stream.pipeline(payloadStream, signingStream, request.body, (err) => {
             if (err) {
               reject2(new Error(`Pipeline error in @aws-sdk/eventstream-handler-node: ${err.message}`, { cause: err }));
@@ -25983,7 +25993,7 @@ var init_package2 = __esm({
   "node_modules/@aws-sdk/token-providers/node_modules/@aws-sdk/nested-clients/package.json"() {
     package_default2 = {
       name: "@aws-sdk/nested-clients",
-      version: "3.994.0",
+      version: "3.995.0",
       description: "Nested clients for AWS SDK packages.",
       main: "./dist-cjs/index.js",
       module: "./dist-es/index.js",
@@ -26019,9 +26029,9 @@ var init_package2 = __esm({
         "@aws-sdk/middleware-user-agent": "^3.972.11",
         "@aws-sdk/region-config-resolver": "^3.972.3",
         "@aws-sdk/types": "^3.973.1",
-        "@aws-sdk/util-endpoints": "3.994.0",
+        "@aws-sdk/util-endpoints": "3.995.0",
         "@aws-sdk/util-user-agent-browser": "^3.972.3",
-        "@aws-sdk/util-user-agent-node": "^3.972.9",
+        "@aws-sdk/util-user-agent-node": "^3.972.10",
         "@smithy/config-resolver": "^4.4.6",
         "@smithy/core": "^3.23.2",
         "@smithy/fetch-http-handler": "^5.3.9",
@@ -27431,7 +27441,7 @@ var require_dist_cjs69 = __commonJS({
         streamEnded = true;
       });
       while (!generationEnded) {
-        const value = await new Promise((resolve7) => setTimeout(() => resolve7(records.shift()), 0));
+        const value = await new Promise((resolve8) => setTimeout(() => resolve8(records.shift()), 0));
         if (value) {
           yield value;
         }
@@ -37471,6 +37481,400 @@ var init_zod = __esm({
   }
 });
 
+// src/tools/fuzzyMatch.js
+function findFuzzyMatch(content, searchString) {
+  if (!searchString || searchString.trim().length === 0) {
+    return null;
+  }
+  const normalizedContent = content.replace(/\r\n/g, "\n");
+  const normalizedSearch = searchString.replace(/\r\n/g, "\n");
+  const contentLines = normalizedContent.split("\n");
+  const searchLines = normalizedSearch.split("\n");
+  const trimmed = lineTrimmedMatch(contentLines, searchLines);
+  if (trimmed) return { ...trimmed, strategy: "line-trimmed" };
+  const normalized = whitespaceNormalizedMatch(normalizedContent, normalizedSearch);
+  if (normalized) return { ...normalized, strategy: "whitespace-normalized" };
+  const indentFlex = indentFlexibleMatch(contentLines, searchLines);
+  if (indentFlex) return { ...indentFlex, strategy: "indent-flexible" };
+  return null;
+}
+function lineTrimmedMatch(contentLines, searchLines) {
+  if (searchLines.length === 0) return null;
+  const trimmedSearchLines = searchLines.map((line) => line.trim());
+  if (trimmedSearchLines.every((line) => line === "")) return null;
+  const windowSize = searchLines.length;
+  const matches = [];
+  for (let i5 = 0; i5 <= contentLines.length - windowSize; i5++) {
+    let allMatch = true;
+    for (let j5 = 0; j5 < windowSize; j5++) {
+      if (contentLines[i5 + j5].trim() !== trimmedSearchLines[j5]) {
+        allMatch = false;
+        break;
+      }
+    }
+    if (allMatch) {
+      const matchedText = contentLines.slice(i5, i5 + windowSize).join("\n");
+      matches.push(matchedText);
+    }
+  }
+  if (matches.length === 0) return null;
+  return {
+    matchedText: matches[0],
+    count: matches.length
+  };
+}
+function whitespaceNormalizedMatch(content, search2) {
+  if (!search2 || search2.trim().length === 0) return null;
+  const { normalized: normContent, indexMap: contentMap } = buildNormalizedMap(content);
+  const { normalized: normSearch } = buildNormalizedMap(search2);
+  if (normSearch.length === 0) return null;
+  const matches = [];
+  let searchStart = 0;
+  while (searchStart <= normContent.length - normSearch.length) {
+    const idx = normContent.indexOf(normSearch, searchStart);
+    if (idx === -1) break;
+    const originalStart = contentMap[idx];
+    const originalEnd = contentMap[idx + normSearch.length - 1];
+    let actualEnd = originalEnd + 1;
+    while (actualEnd < content.length && /[ \t]/.test(content[actualEnd]) && (actualEnd === originalEnd + 1 || /[ \t]/.test(content[actualEnd - 1]))) {
+      if (contentMap.indexOf(actualEnd) > idx + normSearch.length - 1 || contentMap.indexOf(actualEnd) === -1) {
+        break;
+      }
+      actualEnd++;
+    }
+    const matchedText = content.substring(originalStart, actualEnd);
+    matches.push(matchedText);
+    searchStart = idx + 1;
+  }
+  if (matches.length === 0) return null;
+  return {
+    matchedText: matches[0],
+    count: matches.length
+  };
+}
+function buildNormalizedMap(str) {
+  const normalized = [];
+  const indexMap = [];
+  let i5 = 0;
+  while (i5 < str.length) {
+    const ch = str[i5];
+    if (ch === " " || ch === "	") {
+      normalized.push(" ");
+      indexMap.push(i5);
+      while (i5 < str.length && (str[i5] === " " || str[i5] === "	")) {
+        i5++;
+      }
+    } else {
+      normalized.push(ch);
+      indexMap.push(i5);
+      i5++;
+    }
+  }
+  return {
+    normalized: normalized.join(""),
+    indexMap
+  };
+}
+function indentFlexibleMatch(contentLines, searchLines) {
+  if (searchLines.length === 0) return null;
+  if (searchLines.every((line) => line.trim() === "")) return null;
+  const searchMinIndent = getMinIndent(searchLines);
+  const strippedSearch = searchLines.map((line) => stripIndent(line, searchMinIndent));
+  const windowSize = searchLines.length;
+  const matches = [];
+  for (let i5 = 0; i5 <= contentLines.length - windowSize; i5++) {
+    const windowLines = contentLines.slice(i5, i5 + windowSize);
+    const windowMinIndent = getMinIndent(windowLines);
+    const strippedWindow = windowLines.map((line) => stripIndent(line, windowMinIndent));
+    let allMatch = true;
+    for (let j5 = 0; j5 < windowSize; j5++) {
+      if (strippedWindow[j5] !== strippedSearch[j5]) {
+        allMatch = false;
+        break;
+      }
+    }
+    if (allMatch) {
+      const matchedText = windowLines.join("\n");
+      matches.push(matchedText);
+    }
+  }
+  if (matches.length === 0) return null;
+  return {
+    matchedText: matches[0],
+    count: matches.length
+  };
+}
+function getMinIndent(lines) {
+  let min = Infinity;
+  for (const line of lines) {
+    if (line.trim() === "") continue;
+    const match2 = line.match(/^([ \t]*)/);
+    if (match2) {
+      min = Math.min(min, match2[1].length);
+    }
+  }
+  return min === Infinity ? 0 : min;
+}
+function stripIndent(line, amount) {
+  if (line.trim() === "") return "";
+  if (amount <= 0) return line;
+  return line.substring(Math.min(amount, line.length));
+}
+var init_fuzzyMatch = __esm({
+  "src/tools/fuzzyMatch.js"() {
+    "use strict";
+  }
+});
+
+// src/tools/symbolEdit.js
+async function findSymbol(filePath, symbolName, cwd) {
+  try {
+    const result = await extract({
+      files: [`${filePath}#${symbolName}`],
+      format: "json",
+      json: true,
+      cwd
+    });
+    if (!result || !result.results || result.results.length === 0) {
+      return null;
+    }
+    const match2 = result.results[0];
+    return {
+      startLine: match2.lines[0],
+      // 1-indexed
+      endLine: match2.lines[1],
+      // 1-indexed
+      code: match2.code,
+      nodeType: match2.node_type,
+      file: match2.file
+    };
+  } catch (error2) {
+    if (process.env.DEBUG === "1") {
+      console.error(`[SymbolEdit] findSymbol error for "${symbolName}" in ${filePath}: ${error2.message}`);
+    }
+    return null;
+  }
+}
+async function findAllSymbols(filePath, symbolName, cwd) {
+  try {
+    const result = await extract({
+      files: [`${filePath}#${symbolName}`],
+      format: "json",
+      json: true,
+      cwd
+    });
+    if (!result || !result.results || result.results.length === 0) {
+      return [];
+    }
+    return result.results.map((match2) => ({
+      startLine: match2.lines[0],
+      endLine: match2.lines[1],
+      code: match2.code,
+      nodeType: match2.node_type,
+      file: match2.file,
+      qualifiedName: match2.symbol_signature || symbolName
+    }));
+  } catch (error2) {
+    if (process.env.DEBUG === "1") {
+      console.error(`[SymbolEdit] findAllSymbols error for "${symbolName}" in ${filePath}: ${error2.message}`);
+    }
+    return [];
+  }
+}
+function detectBaseIndent(code) {
+  const lines = code.split("\n");
+  for (const line of lines) {
+    if (line.trim().length > 0) {
+      const match2 = line.match(/^(\s*)/);
+      return match2 ? match2[1] : "";
+    }
+  }
+  return "";
+}
+function reindent(newContent, targetIndent) {
+  const lines = newContent.split("\n");
+  const sourceIndent = detectBaseIndent(newContent);
+  return lines.map((line) => {
+    if (line.trim().length === 0) {
+      return "";
+    }
+    if (line.startsWith(sourceIndent)) {
+      return targetIndent + line.slice(sourceIndent.length);
+    }
+    return line;
+  }).join("\n");
+}
+var init_symbolEdit = __esm({
+  "src/tools/symbolEdit.js"() {
+    "use strict";
+    init_extract();
+  }
+});
+
+// src/tools/hashline.js
+function computeLineHash(line) {
+  const stripped = (line || "").replace(/\s+/g, "");
+  let h5 = 5381;
+  for (let i5 = 0; i5 < stripped.length; i5++) {
+    h5 = (h5 << 5) + h5 + stripped.charCodeAt(i5) & 4294967295;
+  }
+  return ((h5 >>> 0) % 256).toString(16).padStart(2, "0");
+}
+function parseLineRef(ref2) {
+  if (ref2 === void 0 || ref2 === null) return null;
+  const str = String(ref2).trim();
+  if (!str) return null;
+  const hashMatch = str.match(/^(\d+):([0-9a-fA-F]{2})$/);
+  if (hashMatch) {
+    const line = parseInt(hashMatch[1], 10);
+    if (line < 1 || !isFinite(line)) return null;
+    return { line, hash: hashMatch[2].toLowerCase() };
+  }
+  const lineMatch = str.match(/^(\d+)$/);
+  if (lineMatch) {
+    const line = parseInt(lineMatch[1], 10);
+    if (line < 1 || !isFinite(line)) return null;
+    return { line, hash: null };
+  }
+  return null;
+}
+function validateLineHash(lineNum, hash, fileLines) {
+  const idx = lineNum - 1;
+  if (idx < 0 || idx >= fileLines.length) {
+    return { valid: false, actualHash: "", actualContent: "" };
+  }
+  const actualContent = fileLines[idx];
+  const actualHash = computeLineHash(actualContent);
+  return {
+    valid: actualHash === hash.toLowerCase(),
+    actualHash,
+    actualContent
+  };
+}
+function annotateOutputWithHashes(output) {
+  if (!output || typeof output !== "string") return output;
+  return output.split("\n").map((line) => {
+    const cleanLine = line.endsWith("\r") ? line.slice(0, -1) : line;
+    const match2 = cleanLine.match(/^(\s*)(\d+)(\s*\|)(.*)$/);
+    if (!match2) return line;
+    const [, prefix, lineNum, pipeSection, content] = match2;
+    const hash = computeLineHash(content);
+    const cr = line.endsWith("\r") ? "\r" : "";
+    return `${prefix}${lineNum}:${hash}${pipeSection}${content}${cr}`;
+  }).join("\n");
+}
+function stripHashlinePrefixes(text) {
+  if (!text || typeof text !== "string") return { cleaned: text || "", stripped: false };
+  const lines = text.split("\n");
+  if (lines.length === 0) return { cleaned: "", stripped: false };
+  const nonEmptyLines = lines.filter((l5) => l5.trim().length > 0);
+  if (nonEmptyLines.length === 0) return { cleaned: text, stripped: false };
+  const prefixPattern = /^\s*\d+(?::[0-9a-fA-F]{2})?\s*\|\s?/;
+  const matchCount = nonEmptyLines.filter((l5) => prefixPattern.test(l5)).length;
+  if (matchCount / nonEmptyLines.length <= 0.5) {
+    return { cleaned: text, stripped: false };
+  }
+  const cleaned = lines.map((line) => {
+    if (line.trim().length === 0) return line;
+    return line.replace(prefixPattern, "");
+  }).join("\n");
+  return { cleaned, stripped: true };
+}
+var init_hashline = __esm({
+  "src/tools/hashline.js"() {
+    "use strict";
+  }
+});
+
+// src/tools/lineEditHeuristics.js
+function stripEchoedBoundaries(newStr, fileLines, startLine, endLine, position) {
+  const modifications = [];
+  let lines = newStr.split("\n");
+  if (lines.length === 0) return { result: newStr, modifications };
+  if (position === "after") {
+    const anchorIdx = startLine - 1;
+    if (anchorIdx >= 0 && anchorIdx < fileLines.length) {
+      const anchorTrimmed = fileLines[anchorIdx].trim();
+      if (anchorTrimmed.length > 0 && lines.length > 0 && lines[0].trim() === anchorTrimmed) {
+        lines = lines.slice(1);
+        modifications.push("stripped echoed anchor line (insert-after)");
+      }
+    }
+  } else if (position === "before") {
+    const anchorIdx = startLine - 1;
+    if (anchorIdx >= 0 && anchorIdx < fileLines.length) {
+      const anchorTrimmed = fileLines[anchorIdx].trim();
+      if (anchorTrimmed.length > 0 && lines.length > 0 && lines[lines.length - 1].trim() === anchorTrimmed) {
+        lines = lines.slice(0, -1);
+        modifications.push("stripped echoed anchor line (insert-before)");
+      }
+    }
+  } else {
+    const beforeIdx = startLine - 2;
+    if (beforeIdx >= 0 && beforeIdx < fileLines.length) {
+      const beforeTrimmed = fileLines[beforeIdx].trim();
+      if (beforeTrimmed.length > 0 && lines.length > 0 && lines[0].trim() === beforeTrimmed) {
+        lines = lines.slice(1);
+        modifications.push("stripped echoed line before range");
+      }
+    }
+    const afterIdx = endLine;
+    if (afterIdx >= 0 && afterIdx < fileLines.length) {
+      const afterTrimmed = fileLines[afterIdx].trim();
+      if (afterTrimmed.length > 0 && lines.length > 0 && lines[lines.length - 1].trim() === afterTrimmed) {
+        lines = lines.slice(0, -1);
+        modifications.push("stripped echoed line after range");
+      }
+    }
+  }
+  return { result: lines.join("\n"), modifications };
+}
+function restoreIndentation(newStr, originalLines) {
+  const modifications = [];
+  if (!newStr || !originalLines || originalLines.length === 0) {
+    return { result: newStr || "", modifications };
+  }
+  const originalCode = originalLines.join("\n");
+  const targetIndent = detectBaseIndent(originalCode);
+  const newIndent = detectBaseIndent(newStr);
+  if (targetIndent !== newIndent) {
+    const reindented = reindent(newStr, targetIndent);
+    if (reindented !== newStr) {
+      modifications.push(`reindented from "${newIndent}" to "${targetIndent}"`);
+      return { result: reindented, modifications };
+    }
+  }
+  return { result: newStr, modifications };
+}
+function cleanNewString(newStr, fileLines, startLine, endLine, position) {
+  const modifications = [];
+  if (!newStr && newStr !== "") return { cleaned: "", modifications };
+  const { cleaned: afterPrefixes, stripped } = stripHashlinePrefixes(newStr);
+  if (stripped) modifications.push("stripped line-number prefixes");
+  const { result: afterEchoes, modifications: echoMods } = stripEchoedBoundaries(
+    afterPrefixes,
+    fileLines,
+    startLine,
+    endLine,
+    position
+  );
+  modifications.push(...echoMods);
+  if (!position) {
+    const originalLines = fileLines.slice(startLine - 1, endLine);
+    const { result: afterIndent, modifications: indentMods } = restoreIndentation(afterEchoes, originalLines);
+    modifications.push(...indentMods);
+    return { cleaned: afterIndent, modifications };
+  }
+  return { cleaned: afterEchoes, modifications };
+}
+var init_lineEditHeuristics = __esm({
+  "src/tools/lineEditHeuristics.js"() {
+    "use strict";
+    init_symbolEdit();
+    init_hashline();
+  }
+});
+
 // src/tools/edit.js
 function isPathAllowed(filePath, allowedFolders) {
   if (!allowedFolders || allowedFolders.length === 0) {
@@ -37494,6 +37898,174 @@ function parseFileToolOptions(options = {}) {
     workspaceRoot: options.workspaceRoot || options.cwd || allowedFolders.length > 0 && allowedFolders[0] || process.cwd()
   };
 }
+async function handleSymbolEdit({ resolvedPath: resolvedPath2, file_path, symbol: symbol15, new_string, position, debug, cwd, fileTracker }) {
+  if (typeof symbol15 !== "string" || symbol15.trim() === "") {
+    return 'Error editing file: Invalid symbol - must be a non-empty string. Provide the name of a function, class, method, or other named code definition (e.g. "myFunction" or "MyClass.myMethod"). To edit by text matching instead, use old_string + new_string.';
+  }
+  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 code above the symbol, or position="after" to insert code below it. Omit position entirely to replace the symbol with new_string.';
+  }
+  const allMatches = await findAllSymbols(resolvedPath2, symbol15, cwd || process.cwd());
+  if (allMatches.length === 0) {
+    return `Error editing file: Symbol "${symbol15}" not found in ${file_path}. Verify the symbol name matches a top-level function, class, method, or other named definition exactly as declared in the source. Use 'search' or 'extract' to inspect the file and find the correct symbol name. Alternatively, use old_string + new_string for text-based editing instead.`;
+  }
+  if (allMatches.length > 1) {
+    const suggestions = allMatches.map(
+      (m5) => `  - ${m5.qualifiedName} (${m5.nodeType}, line ${m5.startLine})`
+    ).join("\n");
+    return `Error editing ${file_path}: Found ${allMatches.length} symbols named "${symbol15}". Use a qualified name to specify which one:
+${suggestions}
+
+Example: <edit><file_path>${file_path}</file_path><symbol>${allMatches[0].qualifiedName}</symbol><new_string>...</new_string></edit>`;
+  }
+  const symbolInfo = allMatches[0];
+  if (fileTracker) {
+    const check = fileTracker.checkSymbolContent(resolvedPath2, symbol15, symbolInfo.code);
+    if (!check.ok && check.reason === "stale") {
+      return `Error editing ${file_path}: Symbol "${symbol15}" has changed since you last read it. Use extract to re-read the current content, then retry.
+
+Example: <extract><targets>${file_path}#${symbol15}</targets></extract>`;
+    }
+  }
+  const content = await import_fs4.promises.readFile(resolvedPath2, "utf-8");
+  const lines = content.split("\n");
+  if (position) {
+    const refIndent = detectBaseIndent(symbolInfo.code);
+    const reindented = reindent(new_string, refIndent);
+    const newLines = reindented.split("\n");
+    if (position === "after") {
+      lines.splice(symbolInfo.endLine, 0, "", ...newLines);
+    } else {
+      lines.splice(symbolInfo.startLine - 1, 0, ...newLines, "");
+    }
+    await import_fs4.promises.writeFile(resolvedPath2, lines.join("\n"), "utf-8");
+    if (fileTracker) {
+      const updated = await findSymbol(resolvedPath2, symbol15, cwd || process.cwd());
+      if (updated) {
+        fileTracker.trackSymbolAfterWrite(resolvedPath2, symbol15, updated.code, updated.startLine, updated.endLine);
+      }
+      fileTracker.markFileSeen(resolvedPath2);
+    }
+    const insertLine = position === "after" ? symbolInfo.endLine + 1 : symbolInfo.startLine;
+    if (debug) {
+      console.error(`[Edit] Successfully inserted ${newLines.length} lines ${position} "${symbol15}" at line ${insertLine} in ${resolvedPath2}`);
+    }
+    return `Successfully inserted ${newLines.length} lines ${position} symbol "${symbol15}" in ${file_path} (at line ${insertLine})`;
+  } else {
+    const originalIndent = detectBaseIndent(symbolInfo.code);
+    const reindented = reindent(new_string, originalIndent);
+    const newLines = reindented.split("\n");
+    lines.splice(symbolInfo.startLine - 1, symbolInfo.endLine - symbolInfo.startLine + 1, ...newLines);
+    await import_fs4.promises.writeFile(resolvedPath2, lines.join("\n"), "utf-8");
+    if (fileTracker) {
+      const updated = await findSymbol(resolvedPath2, symbol15, cwd || process.cwd());
+      if (updated) {
+        fileTracker.trackSymbolAfterWrite(resolvedPath2, symbol15, updated.code, updated.startLine, updated.endLine);
+      }
+      fileTracker.markFileSeen(resolvedPath2);
+    }
+    if (debug) {
+      console.error(`[Edit] Successfully replaced symbol "${symbol15}" in ${resolvedPath2} (lines ${symbolInfo.startLine}-${symbolInfo.endLine})`);
+    }
+    return `Successfully replaced symbol "${symbol15}" in ${file_path} (was lines ${symbolInfo.startLine}-${symbolInfo.endLine}, now ${newLines.length} lines)`;
+  }
+}
+function buildLineEditResponse(file_path, startLine, endLine, newLineCount, updatedLines, insertOffset, action, heuristicMods) {
+  const contextBefore = 1;
+  const contextAfter = 1;
+  const contextStart = Math.max(0, insertOffset - contextBefore);
+  const contextEnd = Math.min(updatedLines.length, insertOffset + newLineCount + contextAfter);
+  let context = "Context:\n";
+  for (let i5 = contextStart; i5 < contextEnd; i5++) {
+    const lineNum = i5 + 1;
+    const hash = computeLineHash(updatedLines[i5]);
+    const isNew = i5 >= insertOffset && i5 < insertOffset + newLineCount;
+    const marker15 = isNew ? ">" : " ";
+    context += `${marker15} ${lineNum}:${hash} | ${updatedLines[i5]}
+`;
+  }
+  let msg = `Successfully edited ${file_path} (${action})`;
+  if (heuristicMods.length > 0) {
+    msg += ` [auto-corrected: ${heuristicMods.join(", ")}]`;
+  }
+  msg += "\n" + context;
+  return msg;
+}
+async function handleLineEdit({ resolvedPath: resolvedPath2, file_path, start_line, end_line, new_string, position, debug, fileTracker }) {
+  const startRef = parseLineRef(start_line);
+  if (!startRef) {
+    return `Error editing file: Invalid start_line '${start_line}'. Use a line number (e.g. "42") or line:hash (e.g. "42:ab"). Line numbers are 1-indexed.`;
+  }
+  let endRef = null;
+  if (end_line !== void 0 && end_line !== null) {
+    endRef = parseLineRef(end_line);
+    if (!endRef) {
+      return `Error editing file: Invalid end_line '${end_line}'. Use a line number (e.g. "55") or line:hash (e.g. "55:cd"). Must be >= start_line.`;
+    }
+  }
+  const startLine = startRef.line;
+  const endLine = endRef ? endRef.line : startLine;
+  if (endLine < startLine) {
+    return `Error editing file: end_line (${endLine}) must be >= start_line (${startLine}).`;
+  }
+  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_fs4.promises.readFile(resolvedPath2, "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.`;
+  }
+  if (endLine > fileLines.length) {
+    return `Error editing file: Line ${endLine} is beyond file length (${fileLines.length} lines). Use 'extract' to read the current file content.`;
+  }
+  if (startRef.hash) {
+    const validation = validateLineHash(startLine, startRef.hash, fileLines);
+    if (!validation.valid) {
+      return `Error editing file: Line ${startLine} has changed since last read. Expected hash '${startRef.hash}' but content is now: ${startLine}:${validation.actualHash} | ${validation.actualContent}. Use '${startLine}:${validation.actualHash}' instead.`;
+    }
+  }
+  if (endRef && endRef.hash) {
+    const validation = validateLineHash(endLine, endRef.hash, fileLines);
+    if (!validation.valid) {
+      return `Error editing file: Line ${endLine} has changed since last read. Expected hash '${endRef.hash}' but content is now: ${endLine}:${validation.actualHash} | ${validation.actualContent}. Use '${endLine}:${validation.actualHash}' instead.`;
+    }
+  }
+  const { cleaned, modifications } = cleanNewString(new_string, fileLines, startLine, endLine, position);
+  if (debug) {
+    if (modifications.length > 0) {
+      console.error(`[Edit] Heuristic corrections: ${modifications.join(", ")}`);
+    }
+  }
+  const newLines = cleaned === "" ? [] : cleaned.split("\n");
+  if (position === "after") {
+    fileLines.splice(startLine, 0, ...newLines);
+    await import_fs4.promises.writeFile(resolvedPath2, fileLines.join("\n"), "utf-8");
+    if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath2);
+    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_fs4.promises.writeFile(resolvedPath2, fileLines.join("\n"), "utf-8");
+    if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath2);
+    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_fs4.promises.writeFile(resolvedPath2, fileLines.join("\n"), "utf-8");
+    if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath2);
+    let action;
+    if (newLines.length === 0) {
+      action = `${replacedCount} line${replacedCount !== 1 ? "s" : ""} deleted (lines ${startLine}-${endLine})`;
+    } else if (startLine === endLine) {
+      action = `line ${startLine} replaced with ${newLines.length} line${newLines.length !== 1 ? "s" : ""}`;
+    } else {
+      action = `lines ${startLine}-${endLine} replaced with ${newLines.length} line${newLines.length !== 1 ? "s" : ""}`;
+    }
+    return buildLineEditResponse(file_path, startLine, endLine, newLines.length, fileLines, startLine - 1, action, modifications);
+  }
+}
 var import_ai, import_fs4, import_path5, import_fs5, editTool, createTool, editSchema, createSchema, editDescription, createDescription, editToolDefinition, createToolDefinition;
 var init_edit = __esm({
   "src/tools/edit.js"() {
@@ -37503,24 +38075,31 @@ var init_edit = __esm({
     import_path5 = require("path");
     import_fs5 = require("fs");
     init_path_validation();
+    init_fuzzyMatch();
+    init_symbolEdit();
+    init_hashline();
+    init_lineEditHeuristics();
     editTool = (options = {}) => {
       const { debug, allowedFolders, cwd, workspaceRoot } = parseFileToolOptions(options);
       return (0, import_ai.tool)({
         name: "edit",
-        description: `Edit files using exact string replacement (Claude Code style).
+        description: `Edit files using text replacement, AST-aware symbol operations, or line-targeted editing.
 
-This tool performs exact string replacements in files. It requires the old_string to match exactly what's in the file, including all whitespace and indentation.
+Modes:
+1. Text edit: Provide old_string + new_string to find and replace text (with fuzzy matching fallback)
+2. Symbol replace: Provide symbol + new_string to replace an entire function/class/method by name
+3. Symbol insert: Provide symbol + new_string + position to insert code before/after a symbol
+4. Line-targeted edit: Provide start_line + new_string to edit by line number (from extract/search output)
 
 Parameters:
 - file_path: Path to the file to edit (absolute or relative)
-- old_string: Exact text to find and replace (must be unique in the file unless replace_all is true)
-- new_string: Text to replace with
-- replace_all: (optional) Replace all occurrences instead of requiring uniqueness
-
-Important:
-- The old_string must match EXACTLY including whitespace
-- If old_string appears multiple times and replace_all is false, the edit will fail
-- Use larger context around the string to ensure uniqueness when needed`,
+- new_string: Replacement text or new code content
+- old_string: (optional) Text to find and replace. If omitted, symbol or start_line must be provided.
+- replace_all: (optional) Replace all occurrences (text mode only)
+- symbol: (optional) Symbol name for AST-aware editing (e.g. "myFunction", "MyClass.myMethod")
+- position: (optional) "before" or "after" \u2014 insert code near a symbol or line instead of replacing it
+- start_line: (optional) Line reference (e.g. "42" or "42:ab") for line-targeted editing
+- end_line: (optional) End of line range, inclusive (e.g. "55" or "55:cd")`,
         inputSchema: {
           type: "object",
           properties: {
@@ -37530,30 +38109,44 @@ Important:
             },
             old_string: {
               type: "string",
-              description: "Exact text to find and replace"
+              description: "Text to find and replace (for text-based editing)"
             },
             new_string: {
               type: "string",
-              description: "Text to replace with"
+              description: "Replacement text or new code content"
             },
             replace_all: {
               type: "boolean",
-              description: "Replace all occurrences (default: false)",
+              description: "Replace all occurrences (default: false, text mode only)",
               default: false
+            },
+            symbol: {
+              type: "string",
+              description: 'Symbol name for AST-aware editing (e.g. "myFunction", "MyClass.myMethod")'
+            },
+            position: {
+              type: "string",
+              enum: ["before", "after"],
+              description: "Insert before/after symbol or line (requires symbol or start_line, omit to replace)"
+            },
+            start_line: {
+              type: "string",
+              description: 'Line reference for line-targeted editing (e.g. "42" or "42:ab" with hash)'
+            },
+            end_line: {
+              type: "string",
+              description: 'End of line range, inclusive (e.g. "55" or "55:cd"). Defaults to start_line.'
             }
           },
-          required: ["file_path", "old_string", "new_string"]
+          required: ["file_path", "new_string"]
         },
-        execute: async ({ file_path, old_string, new_string, replace_all = false }) => {
+        execute: async ({ file_path, old_string, new_string, replace_all = false, symbol: symbol15, position, start_line, end_line }) => {
           try {
             if (!file_path || typeof file_path !== "string" || file_path.trim() === "") {
-              return `Error editing file: Invalid file_path - must be a non-empty string`;
-            }
-            if (old_string === void 0 || old_string === null || typeof old_string !== "string") {
-              return `Error editing file: Invalid old_string - must be a string`;
+              return `Error editing file: Invalid file_path - must be a non-empty string. Provide an absolute path or a path relative to the working directory (e.g. "src/main.js").`;
             }
             if (new_string === void 0 || new_string === null || typeof new_string !== "string") {
-              return `Error editing file: Invalid new_string - must be a string`;
+              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 resolvedPath2 = (0, import_path5.isAbsolute)(file_path) ? file_path : (0, import_path5.resolve)(cwd || process.cwd(), file_path);
             if (debug) {
@@ -37561,34 +38154,64 @@ Important:
             }
             if (!isPathAllowed(resolvedPath2, allowedFolders)) {
               const relativePath = toRelativePath(resolvedPath2, workspaceRoot);
-              return `Error editing file: Permission denied - ${relativePath} is outside allowed directories`;
+              return `Error editing file: Permission denied - ${relativePath} is outside allowed directories. Use a file path within the project workspace.`;
             }
             if (!(0, import_fs5.existsSync)(resolvedPath2)) {
-              return `Error editing file: File not found - ${file_path}`;
+              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(resolvedPath2)) {
+              const displayPath = toRelativePath(resolvedPath2, workspaceRoot);
+              return `Error editing ${displayPath}: This file has not been read yet in this session. Use 'extract' to read the file first, then retry your edit. This ensures you are working with the current file content.
+
+Example: <extract><targets>${displayPath}</targets></extract>`;
+            }
+            if (symbol15 !== void 0 && symbol15 !== null) {
+              return await handleSymbolEdit({ resolvedPath: resolvedPath2, file_path, symbol: symbol15, new_string, position, debug, cwd, fileTracker: options.fileTracker });
+            }
+            if (start_line !== void 0 && start_line !== null) {
+              return await handleLineEdit({ resolvedPath: resolvedPath2, file_path, start_line, end_line, new_string, position, debug, fileTracker: options.fileTracker });
+            }
+            if (old_string === void 0 || old_string === null) {
+              return 'Error editing file: Must provide either old_string (for text edit), symbol (for AST-aware edit), or start_line (for line-targeted edit). For text editing: set old_string to the exact text to find and new_string to its replacement. For symbol editing: set symbol to a function/class/method name (e.g. "myFunction"). For line-targeted editing: set start_line to a line number from extract/search output (e.g. "42" or "42:ab").';
+            }
+            if (typeof old_string !== "string") {
+              return `Error editing file: Invalid old_string - must be a string. Provide the exact text to find in the file, or use the symbol parameter instead for AST-aware editing by name.`;
             }
             const content = await import_fs4.promises.readFile(resolvedPath2, "utf-8");
+            let matchTarget = old_string;
+            let matchStrategy = "exact";
             if (!content.includes(old_string)) {
-              return `Error editing file: String not found - the specified old_string was not found in ${file_path}`;
+              const fuzzy = findFuzzyMatch(content, old_string);
+              if (!fuzzy) {
+                return `Error editing file: String not found - the specified old_string was not found in ${file_path}. The text may have changed or differ from what you expected. Try: (1) Use 'search' or 'extract' to read the current file content and copy the exact text. (2) Use the symbol parameter to edit by function/class name instead. (3) Verify the file_path is correct.`;
+              }
+              matchTarget = fuzzy.matchedText;
+              matchStrategy = fuzzy.strategy;
+              if (debug) {
+                console.error(`[Edit] Exact match failed, used ${matchStrategy} matching`);
+              }
             }
-            const occurrences = content.split(old_string).length - 1;
+            const occurrences = content.split(matchTarget).length - 1;
             if (!replace_all && occurrences > 1) {
-              return `Error editing file: Multiple occurrences found - the old_string appears ${occurrences} times. Use replace_all: true to replace all occurrences, or provide more context to make the string unique.`;
+              return `Error editing file: Multiple occurrences found - the old_string appears ${occurrences} times in ${file_path}. To fix: (1) Set replace_all=true to replace all occurrences, or (2) Include more surrounding lines in old_string to make the match unique (add the full line or adjacent lines for context).`;
             }
             let newContent;
             if (replace_all) {
-              newContent = content.replaceAll(old_string, new_string);
+              newContent = content.replaceAll(matchTarget, new_string);
             } else {
-              newContent = content.replace(old_string, new_string);
+              newContent = content.replace(matchTarget, new_string);
             }
             if (newContent === content) {
-              return `Error editing file: No changes made - old_string and new_string might be the same`;
+              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_fs4.promises.writeFile(resolvedPath2, newContent, "utf-8");
+            if (options.fileTracker) await options.fileTracker.trackFileAfterWrite(resolvedPath2);
             const replacedCount = replace_all ? occurrences : 1;
             if (debug) {
               console.error(`[Edit] Successfully edited ${resolvedPath2}, replaced ${replacedCount} occurrence(s)`);
             }
-            return `Successfully edited ${file_path} (${replacedCount} replacement${replacedCount !== 1 ? "s" : ""})`;
+            const strategyNote = matchStrategy !== "exact" ? `, matched via ${matchStrategy}` : "";
+            return `Successfully edited ${file_path} (${replacedCount} replacement${replacedCount !== 1 ? "s" : ""}${strategyNote})`;
           } catch (error2) {
             console.error("[Edit] Error:", error2);
             return `Error editing file: ${error2.message}`;
@@ -37635,10 +38258,10 @@ Important:
         execute: async ({ file_path, content, overwrite = false }) => {
           try {
             if (!file_path || typeof file_path !== "string" || file_path.trim() === "") {
-              return `Error creating file: Invalid file_path - must be a non-empty string`;
+              return `Error creating file: Invalid file_path - must be a non-empty string. Provide an absolute path or a path relative to the working directory (e.g. "src/newFile.js").`;
             }
             if (content === void 0 || content === null || typeof content !== "string") {
-              return `Error creating file: Invalid content - must be a string`;
+              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 resolvedPath2 = (0, import_path5.isAbsolute)(file_path) ? file_path : (0, import_path5.resolve)(cwd || process.cwd(), file_path);
             if (debug) {
@@ -37646,15 +38269,17 @@ Important:
             }
             if (!isPathAllowed(resolvedPath2, allowedFolders)) {
               const relativePath = toRelativePath(resolvedPath2, workspaceRoot);
-              return `Error creating file: Permission denied - ${relativePath} is outside allowed directories`;
+              return `Error creating file: Permission denied - ${relativePath} is outside allowed directories. Use a file path within the project workspace.`;
             }
             if ((0, import_fs5.existsSync)(resolvedPath2) && !overwrite) {
               return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
             }
+            const existed = (0, import_fs5.existsSync)(resolvedPath2);
             const dir = (0, import_path5.dirname)(resolvedPath2);
             await import_fs4.promises.mkdir(dir, { recursive: true });
             await import_fs4.promises.writeFile(resolvedPath2, content, "utf-8");
-            const action = (0, import_fs5.existsSync)(resolvedPath2) && overwrite ? "overwrote" : "created";
+            if (options.fileTracker) await options.fileTracker.trackFileAfterWrite(resolvedPath2);
+            const action = existed && overwrite ? "overwrote" : "created";
             const bytes = Buffer.byteLength(content, "utf-8");
             if (debug) {
               console.error(`[Create] Successfully ${action} ${resolvedPath2}`);
@@ -37676,18 +38301,35 @@ Important:
         },
         old_string: {
           type: "string",
-          description: "Exact text to find and replace"
+          description: "Text to find and replace (for text-based editing)"
         },
         new_string: {
           type: "string",
-          description: "Text to replace with"
+          description: "Replacement text or new code content"
         },
         replace_all: {
           type: "boolean",
-          description: "Replace all occurrences (default: false)"
+          description: "Replace all occurrences (default: false, text mode only)"
+        },
+        symbol: {
+          type: "string",
+          description: 'Symbol name for AST-aware editing (e.g. "myFunction", "MyClass.myMethod")'
+        },
+        position: {
+          type: "string",
+          enum: ["before", "after"],
+          description: "Insert before/after symbol or line (requires symbol or start_line, omit to replace)"
+        },
+        start_line: {
+          type: "string",
+          description: 'Line reference for line-targeted editing (e.g. "42" or "42:ab" with hash)'
+        },
+        end_line: {
+          type: "string",
+          description: 'End of line range, inclusive (e.g. "55" or "55:cd"). Defaults to start_line.'
         }
       },
-      required: ["file_path", "old_string", "new_string"]
+      required: ["file_path", "new_string"]
     };
     createSchema = {
       type: "object",
@@ -37707,50 +38349,123 @@ Important:
       },
       required: ["file_path", "content"]
     };
-    editDescription = "Edit files using exact string replacement. Requires exact match including whitespace.";
+    editDescription = "Edit files using text replacement, AST-aware symbol operations, or line-targeted editing. Supports fuzzy matching for text edits and optional hash-based integrity verification for line edits.";
     createDescription = "Create new files with specified content. Will create parent directories if needed.";
     editToolDefinition = `
 ## edit
 Description: ${editDescription}
 
-When to use:
-- For precise, surgical edits to existing files
-- When you need to change specific lines or blocks of code
-- For renaming functions, variables, or updating configuration values
-- When the exact text to replace is known and unique (or use replace_all for multiple occurrences)
+Four editing modes \u2014 choose based on the scope of your change:
 
-When NOT to use:
-- For creating new files (use 'create' tool instead)
-- When you cannot determine the exact text to replace
-- When changes span multiple locations that would be better handled together
+1. **Text edit** (old_string + new_string): For small, precise changes \u2014 fix a condition, rename a variable, update a value. Provide old_string copied verbatim from the file and new_string with the replacement. Fuzzy matching handles minor whitespace/indentation differences automatically, but always try to copy the exact text.
+
+2. **Symbol replace** (symbol + new_string): For replacing an entire function, class, or method by name. No need to quote the old code \u2014 just provide the symbol name and the full new implementation. Indentation is automatically adjusted to match the original. Prefer this mode when rewriting whole definitions.
+
+3. **Symbol insert** (symbol + new_string + position): For adding new code before or after an existing symbol. Set position to "before" or "after".
+
+4. **Line-targeted edit** (start_line + new_string): For precise edits using line numbers from extract/search output. Use start_line with a line number (e.g. "42") or line:hash (e.g. "42:ab") for integrity verification. Add end_line for multi-line ranges. Use position="before" or "after" to insert instead of replace.
 
 Parameters:
 - file_path: (required) Path to the file to edit
-- old_string: (required) Exact text to find and replace (must match including whitespace, newlines, and indentation)
-- new_string: (required) Text to replace with
-- replace_all: (optional, default: false) Replace all occurrences if the string appears multiple times
-
-Important notes:
-- The old_string MUST match EXACTLY, including all whitespace, indentation, and line breaks
-- If old_string appears multiple times and replace_all is false, the tool will fail
-- Always verify the exact formatting of the text you want to replace
+- new_string: (required) Replacement text or new code content
+- old_string: (optional) Text to find and replace \u2014 copy verbatim from the file, do not paraphrase or reformat
+- replace_all: (optional, default: false) Replace all occurrences of old_string (text mode only)
+- symbol: (optional) Name of a code symbol (e.g. "myFunction", "MyClass.myMethod") \u2014 must match a function, class, or method definition
+- position: (optional) "before" or "after" \u2014 insert new_string near the symbol or line instead of replacing it
+- start_line: (optional) Line reference for line-targeted editing (e.g. "42" or "42:ab")
+- end_line: (optional) End of line range, inclusive (e.g. "55" or "55:cd"). Defaults to start_line.
+
+Mode selection rules (priority order):
+- If symbol is provided, symbol mode is used (old_string and start_line are ignored)
+- If start_line is provided (without symbol), line-targeted mode is used
+- If old_string is provided (without symbol or start_line), text mode is used
+- If none are provided, the tool returns an error with guidance
+
+When to use each mode:
+- Small edits (a line or a few lines): use text mode with old_string
+- Replacing entire functions/classes/methods: use symbol mode \u2014 no exact text matching needed
+- Editing specific lines from extract/search output: use line-targeted mode with start_line
+- Editing inside large functions without rewriting them entirely: first use extract with the symbol target (e.g. "file.js#myFunction") to see the function with line numbers, then use start_line/end_line to edit specific lines within it
+
+Error handling:
+- If an edit fails, read the error message carefully \u2014 it contains specific instructions for how to fix the call and retry
+- Common fixes: use 'search'/'extract' to get exact file content, add more context to old_string, switch between text and symbol modes
+- Line-targeted hash mismatch: the file changed since last read; the error provides updated line:hash references
 
 Examples:
+
+Text edit (find and replace):
 <edit>
 <file_path>src/main.js</file_path>
-<old_string>function oldName() {
-  return 42;
-}</old_string>
-<new_string>function newName() {
-  return 42;
-}</new_string>
+<old_string>return false;</old_string>
+<new_string>return true;</new_string>
 </edit>
 
+Text edit with replace_all:
 <edit>
 <file_path>config.json</file_path>
 <old_string>"debug": false</old_string>
 <new_string>"debug": true</new_string>
 <replace_all>true</replace_all>
+</edit>
+
+Symbol replace (rewrite entire function by name):
+<edit>
+<file_path>src/utils.js</file_path>
+<symbol>calculateTotal</symbol>
+<new_string>function calculateTotal(items) {
+  return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
+}</new_string>
+</edit>
+
+Symbol insert (add new function after existing one):
+<edit>
+<file_path>src/utils.js</file_path>
+<symbol>calculateTotal</symbol>
+<position>after</position>
+<new_string>function calculateTax(total, rate) {
+  return total * rate;
+}</new_string>
+</edit>
+
+Line-targeted edit (replace a line):
+<edit>
+<file_path>src/main.js</file_path>
+<start_line>42</start_line>
+<new_string>  return processItems(order.items);</new_string>
+</edit>
+
+Line-targeted edit (replace a range of lines):
+<edit>
+<file_path>src/main.js</file_path>
+<start_line>42</start_line>
+<end_line>55</end_line>
+<new_string>  // simplified implementation
+  return processItems(order.items);</new_string>
+</edit>
+
+Line-targeted edit with hash verification:
+<edit>
+<file_path>src/main.js</file_path>
+<start_line>42:ab</start_line>
+<end_line>55:cd</end_line>
+<new_string>  return processItems(order.items);</new_string>
+</edit>
+
+Line-targeted insert (add code after a line):
+<edit>
+<file_path>src/main.js</file_path>
+<start_line>42</start_line>
+<position>after</position>
+<new_string>  const validated = validate(input);</new_string>
+</edit>
+
+Line-targeted delete (remove lines):
+<edit>
+<file_path>src/main.js</file_path>
+<start_line>42</start_line>
+<end_line>45</end_line>
+<new_string></new_string>
 </edit>`;
     createToolDefinition = `
 ## create
@@ -38287,7 +39002,7 @@ function getValidParamsForTool(toolName) {
   };
   const schema = schemaMap[toolName];
   if (!schema) {
-    return ["path", "directory", "pattern", "recursive", "includeHidden", "task", "files", "autoCommits", "result"];
+    return ["path", "directory", "pattern", "recursive", "includeHidden", "task", "files", "result"];
   }
   if (toolName === "attempt_completion") {
     return ["result"];
@@ -38408,7 +39123,6 @@ function detectUnrecognizedToolCall(xmlString, validTools) {
     "listSkills",
     "useSkill",
     "readImage",
-    "implement",
     "edit",
     "create",
     "delegate",
@@ -38783,6 +39497,8 @@ User: Read file inside the dependency
 </extract>
 
 </examples>
+
+**Edit Integration:** The line numbers shown in extract output (e.g. "42 | code") can be used directly with the edit tool's start_line/end_line parameters for precise line-targeted editing. To edit inside a large function: extract it by symbol name first (e.g. "file.js#myFunction"), then use the line numbers from the output to make surgical edits with start_line/end_line.
 `;
     delegateToolDefinition = `
 ## delegate
@@ -38938,7 +39654,7 @@ Capabilities:
 `;
     searchDescription = "Search code in the repository. Free-form questions are accepted, but Elasticsearch-style keyword queries work best. Use this tool first for any code-related questions.";
     queryDescription = "Search code using ast-grep structural pattern matching. Use this tool to find specific code structures like functions, classes, or methods.";
-    extractDescription = "Extract code blocks from files based on file paths and optional line numbers. Use this tool to see complete context after finding relevant files.";
+    extractDescription = "Extract code blocks from files based on file paths and optional line numbers. Use this tool to see complete context after finding relevant files. Line numbers from output can be used with edit start_line/end_line for precise editing.";
     delegateDescription = "Automatically delegate big distinct tasks to specialized probe subagents within the agentic loop. Used by AI agents to break down complex requests into focused, parallel tasks.";
     bashDescription = "Execute bash commands for system exploration and development tasks. Secure by default with built-in allow/deny lists.";
     analyzeAllDescription = 'Answer questions that require analyzing ALL matching data in the codebase. Use for aggregate questions like "What features exist?", "List all API endpoints", "Count TODO comments". The AI automatically plans the search strategy, processes all results via map-reduce, and synthesizes a comprehensive answer. WARNING: Slower than search - only use when you need complete coverage.';
@@ -38954,7 +39670,6 @@ Capabilities:
       "useSkill",
       "listFiles",
       "searchFiles",
-      "implement",
       "bash",
       "task",
       "attempt_completion"
@@ -39634,7 +40349,7 @@ function parseXmlToolCallWithThinking(xmlString, validTools) {
   const toolCall = parseXmlToolCall(cleanedXmlString, validTools);
   return toolCall ? { ...toolCall, thinkingContent } : null;
 }
-var import_crypto2, implementToolDefinition, listFilesToolDefinition, searchFilesToolDefinition, listSkillsToolDefinition, useSkillToolDefinition, readImageToolDefinition;
+var import_crypto2, listFilesToolDefinition, searchFilesToolDefinition, listSkillsToolDefinition, useSkillToolDefinition, readImageToolDefinition;
 var init_tools = __esm({
   "src/agent/tools.js"() {
     "use strict";
@@ -39642,31 +40357,6 @@ var init_tools = __esm({
     import_crypto2 = require("crypto");
     init_xmlParsingUtils();
     init_tasks();
-    implementToolDefinition = `
-## implement
-Description: Implement a given task. Can modify files. Can be used ONLY if task explicitly stated that something requires modification or implementation.
-
-Parameters:
-- task: (required) The task description. Should be as detailed as possible, ideally pointing to exact files which needs be modified or created.
-- autoCommits: (optional) Whether to enable auto-commits in aider. Default is false.
-
-Usage Example:
-
-<examples>
-
-User: Can you implement a function to calculate Fibonacci numbers in main.js?
-<implement>
-<task>Implement a recursive function to calculate the nth Fibonacci number in main.js</task>
-</implement>
-
-User: Can you implement a function to calculate Fibonacci numbers in main.js with auto-commits?
-<implement>
-<task>Implement a recursive function to calculate the nth Fibonacci number in main.js</task>
-<autoCommits>true</autoCommits>
-</implement>
-
-</examples>
-`;
     listFilesToolDefinition = `
 ## listFiles
 Description: List files and directories in a specified location.
@@ -39782,33 +40472,289 @@ User: Analyze the diagram in docs/architecture.svg
   }
 });
 
-// node_modules/balanced-match/index.js
-var require_balanced_match = __commonJS({
-  "node_modules/balanced-match/index.js"(exports2, module2) {
+// src/tools/fileTracker.js
+function computeContentHash(content) {
+  const normalized = (content || "").split("\n").map((l5) => l5.trimEnd()).join("\n");
+  return (0, import_crypto3.createHash)("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+function extractFilePath(target) {
+  const hashIdx = target.indexOf("#");
+  if (hashIdx !== -1) {
+    return target.slice(0, hashIdx);
+  }
+  const colonIdx = target.lastIndexOf(":");
+  if (colonIdx !== -1) {
+    const after = target.slice(colonIdx + 1);
+    if (/^\d+(-\d+)?$/.test(after)) {
+      return target.slice(0, colonIdx);
+    }
+  }
+  return target;
+}
+function extractSymbolName(target) {
+  const hashIdx = target.indexOf("#");
+  if (hashIdx !== -1) {
+    const symbol15 = target.slice(hashIdx + 1);
+    return symbol15 || null;
+  }
+  return null;
+}
+function parseFilePathsFromOutput(output) {
+  const paths = [];
+  const regex = /^(?:File:\s+|---\s+)([^\s].*?)(?:\s+---)?$/gm;
+  let match2;
+  while ((match2 = regex.exec(output)) !== null) {
+    const path9 = match2[1].trim();
+    if (path9 && !path9.startsWith("Results") && !path9.startsWith("Page") && (path9.includes("/") || path9.includes(".") || path9.includes("\\"))) {
+      paths.push(path9);
+    }
+  }
+  return paths;
+}
+var import_crypto3, import_path7, FileTracker;
+var init_fileTracker = __esm({
+  "src/tools/fileTracker.js"() {
     "use strict";
-    module2.exports = balanced;
-    function balanced(a5, b5, str) {
-      if (a5 instanceof RegExp) a5 = maybeMatch(a5, str);
-      if (b5 instanceof RegExp) b5 = maybeMatch(b5, str);
-      var r5 = range2(a5, b5, str);
+    import_crypto3 = require("crypto");
+    import_path7 = require("path");
+    init_symbolEdit();
+    FileTracker = class {
+      /**
+       * @param {Object} [options]
+       * @param {boolean} [options.debug=false] - Enable debug logging
+       */
+      constructor(options = {}) {
+        this.debug = options.debug || false;
+        this._seenFiles = /* @__PURE__ */ new Set();
+        this._contentRecords = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Mark a file as "seen" — the LLM has read its content.
+       * @param {string} resolvedPath - Absolute path to the file
+       */
+      markFileSeen(resolvedPath2) {
+        this._seenFiles.add(resolvedPath2);
+        if (this.debug) {
+          console.error(`[FileTracker] Marked as seen: ${resolvedPath2}`);
+        }
+      }
+      /**
+       * Check if a file has been seen in this session.
+       * @param {string} resolvedPath - Absolute path to the file
+       * @returns {boolean}
+       */
+      isFileSeen(resolvedPath2) {
+        return this._seenFiles.has(resolvedPath2);
+      }
+      /**
+       * Store a content hash for a symbol in a file.
+       * @param {string} resolvedPath - Absolute path to the file
+       * @param {string} symbolName - Symbol name (e.g. "calculateTotal")
+       * @param {string} code - The symbol's source code
+       * @param {number} startLine - 1-indexed start line
+       * @param {number} endLine - 1-indexed end line
+       * @param {string} [source='extract'] - How the content was obtained
+       */
+      trackSymbolContent(resolvedPath2, symbolName, code, startLine, endLine, source = "extract") {
+        const key = `${resolvedPath2}#${symbolName}`;
+        const contentHash = computeContentHash(code);
+        this._contentRecords.set(key, {
+          contentHash,
+          startLine,
+          endLine,
+          symbolName,
+          source,
+          timestamp: Date.now()
+        });
+        if (this.debug) {
+          console.error(`[FileTracker] Tracked symbol ${key} (hash: ${contentHash}, lines ${startLine}-${endLine})`);
+        }
+      }
+      /**
+       * Look up a stored content record for a symbol.
+       * @param {string} resolvedPath - Absolute path to the file
+       * @param {string} symbolName - Symbol name
+       * @returns {Object|null} The stored record or null
+       */
+      getSymbolRecord(resolvedPath2, symbolName) {
+        return this._contentRecords.get(`${resolvedPath2}#${symbolName}`) || null;
+      }
+      /**
+       * Check if a symbol's current content matches what was stored.
+       * @param {string} resolvedPath - Absolute path to the file
+       * @param {string} symbolName - Symbol name
+       * @param {string} currentCode - The symbol's current source code (from findSymbol)
+       * @returns {{ok: boolean, reason?: string, message?: string}}
+       */
+      checkSymbolContent(resolvedPath2, symbolName, currentCode) {
+        const key = `${resolvedPath2}#${symbolName}`;
+        const record = this._contentRecords.get(key);
+        if (!record) {
+          return { ok: true };
+        }
+        const currentHash = computeContentHash(currentCode);
+        if (currentHash === record.contentHash) {
+          return { ok: true };
+        }
+        return {
+          ok: false,
+          reason: "stale",
+          message: `Symbol "${symbolName}" has changed since you last read it (hash: ${record.contentHash} \u2192 ${currentHash}).`
+        };
+      }
+      /**
+       * Track files from extract target strings.
+       * Marks each file as seen. For #symbol targets, calls findSymbol to get and hash the code.
+       * @param {string[]} targets - Array of extract targets (e.g. ["file.js#fn", "file.js:10-20"])
+       * @param {string} cwd - Working directory for resolving relative paths
+       */
+      async trackFilesFromExtract(targets, cwd) {
+        const seenPaths = /* @__PURE__ */ new Set();
+        const symbolPromises = [];
+        for (const target of targets) {
+          const filePath = extractFilePath(target);
+          const resolved = (0, import_path7.isAbsolute)(filePath) ? filePath : (0, import_path7.resolve)(cwd, filePath);
+          if (!seenPaths.has(resolved)) {
+            seenPaths.add(resolved);
+            this.markFileSeen(resolved);
+          }
+          const symbolName = extractSymbolName(target);
+          if (symbolName) {
+            symbolPromises.push(
+              findSymbol(resolved, symbolName, cwd).then((symbolInfo) => {
+                if (symbolInfo) {
+                  this.trackSymbolContent(
+                    resolved,
+                    symbolName,
+                    symbolInfo.code,
+                    symbolInfo.startLine,
+                    symbolInfo.endLine,
+                    "extract"
+                  );
+                }
+              }).catch((err) => {
+                if (this.debug) {
+                  console.error(`[FileTracker] Failed to track symbol "${symbolName}" in ${resolved}: ${err.message}`);
+                }
+              })
+            );
+          }
+        }
+        if (symbolPromises.length > 0) {
+          await Promise.all(symbolPromises);
+        }
+      }
+      /**
+       * Track files discovered in probe search/extract output.
+       * Parses "File: path" headers and "--- path ---" separators, marks each as "seen".
+       * @param {string} output - Probe output text
+       * @param {string} cwd - Working directory for resolving relative paths
+       */
+      async trackFilesFromOutput(output, cwd) {
+        const paths = parseFilePathsFromOutput(output);
+        for (const filePath of paths) {
+          const resolved = (0, import_path7.isAbsolute)(filePath) ? filePath : (0, import_path7.resolve)(cwd, filePath);
+          this.markFileSeen(resolved);
+        }
+      }
+      /**
+       * Check if a file is safe to edit (seen-check only).
+       * Mode-specific content verification happens in edit handlers.
+       * @param {string} resolvedPath - Absolute path to the file
+       * @returns {{ok: boolean, reason?: string, message?: string}}
+       */
+      checkBeforeEdit(resolvedPath2) {
+        if (!this._seenFiles.has(resolvedPath2)) {
+          return {
+            ok: false,
+            reason: "untracked",
+            message: "This file has not been read yet in this session. Use extract or search to read the file first."
+          };
+        }
+        return { ok: true };
+      }
+      /**
+       * Mark a file as seen after a successful write (backward compat).
+       * Also invalidates content records for the file since its content changed.
+       * @param {string} resolvedPath - Absolute path to the file
+       */
+      async trackFileAfterWrite(resolvedPath2) {
+        this.markFileSeen(resolvedPath2);
+        this.invalidateFileRecords(resolvedPath2);
+      }
+      /**
+       * Update the stored hash for a symbol after a successful write.
+       * Enables chained edits to the same symbol.
+       * @param {string} resolvedPath - Absolute path to the file
+       * @param {string} symbolName - Symbol name
+       * @param {string} code - The symbol's new source code
+       * @param {number} startLine - 1-indexed start line (new position)
+       * @param {number} endLine - 1-indexed end line (new position)
+       */
+      trackSymbolAfterWrite(resolvedPath2, symbolName, code, startLine, endLine) {
+        this.trackSymbolContent(resolvedPath2, symbolName, code, startLine, endLine, "edit");
+      }
+      /**
+       * Remove all content records for a file.
+       * Called after non-symbol edits (text/line mode) since those change content
+       * without providing a symbol-level update.
+       * @param {string} resolvedPath - Absolute path to the file
+       */
+      invalidateFileRecords(resolvedPath2) {
+        const prefix = resolvedPath2 + "#";
+        for (const key of this._contentRecords.keys()) {
+          if (key.startsWith(prefix)) {
+            this._contentRecords.delete(key);
+          }
+        }
+        if (this.debug) {
+          console.error(`[FileTracker] Invalidated content records for ${resolvedPath2}`);
+        }
+      }
+      /**
+       * Quick sync check if a file is being tracked (alias for isFileSeen).
+       * @param {string} resolvedPath - Absolute path to the file
+       * @returns {boolean}
+       */
+      isTracked(resolvedPath2) {
+        return this.isFileSeen(resolvedPath2);
+      }
+      /**
+       * Clear all tracking state.
+       */
+      clear() {
+        this._seenFiles.clear();
+        this._contentRecords.clear();
+      }
+    };
+  }
+});
+
+// node_modules/balanced-match/dist/esm/index.js
+var balanced, maybeMatch, range2;
+var init_esm = __esm({
+  "node_modules/balanced-match/dist/esm/index.js"() {
+    balanced = (a5, b5, str) => {
+      const ma = a5 instanceof RegExp ? maybeMatch(a5, str) : a5;
+      const mb = b5 instanceof RegExp ? maybeMatch(b5, str) : b5;
+      const r5 = ma !== null && mb != null && range2(ma, mb, str);
       return r5 && {
         start: r5[0],
         end: r5[1],
         pre: str.slice(0, r5[0]),
-        body: str.slice(r5[0] + a5.length, r5[1]),
-        post: str.slice(r5[1] + b5.length)
+        body: str.slice(r5[0] + ma.length, r5[1]),
+        post: str.slice(r5[1] + mb.length)
       };
-    }
-    function maybeMatch(reg, str) {
-      var m5 = str.match(reg);
+    };
+    maybeMatch = (reg, str) => {
+      const m5 = str.match(reg);
       return m5 ? m5[0] : null;
-    }
-    balanced.range = range2;
-    function range2(a5, b5, str) {
-      var begs, beg, left, right, result;
-      var ai = str.indexOf(a5);
-      var bi = str.indexOf(b5, ai + 1);
-      var i5 = ai;
+    };
+    range2 = (a5, b5, str) => {
+      let begs, beg, left, right = void 0, result;
+      let ai = str.indexOf(a5);
+      let bi = str.indexOf(b5, ai + 1);
+      let i5 = ai;
       if (ai >= 0 && bi > 0) {
         if (a5 === b5) {
           return [ai, bi];
@@ -39816,14 +40762,16 @@ var require_balanced_match = __commonJS({
         begs = [];
         left = str.length;
         while (i5 >= 0 && !result) {
-          if (i5 == ai) {
+          if (i5 === ai) {
             begs.push(i5);
             ai = str.indexOf(a5, i5 + 1);
-          } else if (begs.length == 1) {
-            result = [begs.pop(), bi];
+          } else if (begs.length === 1) {
+            const r5 = begs.pop();
+            if (r5 !== void 0)
+              result = [r5, bi];
           } else {
             beg = begs.pop();
-            if (beg < left) {
+            if (beg !== void 0 && beg < left) {
               left = beg;
               right = bi;
             }
@@ -39831,163 +40779,179 @@ var require_balanced_match = __commonJS({
           }
           i5 = ai < bi && ai >= 0 ? ai : bi;
         }
-        if (begs.length) {
+        if (begs.length && right !== void 0) {
           result = [left, right];
         }
       }
       return result;
-    }
+    };
   }
 });
 
-// node_modules/brace-expansion/index.js
-var require_brace_expansion = __commonJS({
-  "node_modules/brace-expansion/index.js"(exports2, module2) {
-    var balanced = require_balanced_match();
-    module2.exports = expandTop;
-    var escSlash = "\0SLASH" + Math.random() + "\0";
-    var escOpen = "\0OPEN" + Math.random() + "\0";
-    var escClose = "\0CLOSE" + Math.random() + "\0";
-    var escComma = "\0COMMA" + Math.random() + "\0";
-    var escPeriod = "\0PERIOD" + Math.random() + "\0";
-    function numeric(str) {
-      return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
-    }
-    function escapeBraces(str) {
-      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
-    }
-    function unescapeBraces(str) {
-      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
-    }
-    function parseCommaParts(str) {
-      if (!str)
-        return [""];
-      var parts = [];
-      var m5 = balanced("{", "}", str);
-      if (!m5)
-        return str.split(",");
-      var pre = m5.pre;
-      var body = m5.body;
-      var post = m5.post;
-      var p5 = pre.split(",");
-      p5[p5.length - 1] += "{" + body + "}";
-      var postParts = parseCommaParts(post);
-      if (post.length) {
-        p5[p5.length - 1] += postParts.shift();
-        p5.push.apply(p5, postParts);
-      }
-      parts.push.apply(parts, p5);
-      return parts;
-    }
-    function expandTop(str) {
-      if (!str)
-        return [];
-      if (str.substr(0, 2) === "{}") {
-        str = "\\{\\}" + str.substr(2);
-      }
-      return expand2(escapeBraces(str), true).map(unescapeBraces);
-    }
-    function embrace(str) {
-      return "{" + str + "}";
-    }
-    function isPadded(el) {
-      return /^-?0\d/.test(el);
-    }
-    function lte(i5, y2) {
-      return i5 <= y2;
-    }
-    function gte(i5, y2) {
-      return i5 >= y2;
+// node_modules/brace-expansion/dist/esm/index.js
+function numeric(str) {
+  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+}
+function escapeBraces(str) {
+  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str) {
+  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+}
+function parseCommaParts(str) {
+  if (!str) {
+    return [""];
+  }
+  const parts = [];
+  const m5 = balanced("{", "}", str);
+  if (!m5) {
+    return str.split(",");
+  }
+  const { pre, body, post } = m5;
+  const p5 = pre.split(",");
+  p5[p5.length - 1] += "{" + body + "}";
+  const postParts = parseCommaParts(post);
+  if (post.length) {
+    ;
+    p5[p5.length - 1] += postParts.shift();
+    p5.push.apply(p5, postParts);
+  }
+  parts.push.apply(parts, p5);
+  return parts;
+}
+function expand(str, options = {}) {
+  if (!str) {
+    return [];
+  }
+  const { max = EXPANSION_MAX } = options;
+  if (str.slice(0, 2) === "{}") {
+    str = "\\{\\}" + str.slice(2);
+  }
+  return expand_(escapeBraces(str), max, true).map(unescapeBraces);
+}
+function embrace(str) {
+  return "{" + str + "}";
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+function lte(i5, y2) {
+  return i5 <= y2;
+}
+function gte(i5, y2) {
+  return i5 >= y2;
+}
+function expand_(str, max, isTop) {
+  const expansions = [];
+  const m5 = balanced("{", "}", str);
+  if (!m5)
+    return [str];
+  const pre = m5.pre;
+  const post = m5.post.length ? expand_(m5.post, max, false) : [""];
+  if (/\$$/.test(m5.pre)) {
+    for (let k5 = 0; k5 < post.length && k5 < max; k5++) {
+      const expansion = pre + "{" + m5.body + "}" + post[k5];
+      expansions.push(expansion);
     }
-    function expand2(str, isTop) {
-      var expansions = [];
-      var m5 = balanced("{", "}", str);
-      if (!m5) return [str];
-      var pre = m5.pre;
-      var post = m5.post.length ? expand2(m5.post, false) : [""];
-      if (/\$$/.test(m5.pre)) {
-        for (var k5 = 0; k5 < post.length; k5++) {
-          var expansion = pre + "{" + m5.body + "}" + post[k5];
-          expansions.push(expansion);
-        }
-      } else {
-        var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m5.body);
-        var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m5.body);
-        var isSequence = isNumericSequence || isAlphaSequence;
-        var isOptions = m5.body.indexOf(",") >= 0;
-        if (!isSequence && !isOptions) {
-          if (m5.post.match(/,(?!,).*\}/)) {
-            str = m5.pre + "{" + m5.body + escClose + m5.post;
-            return expand2(str);
-          }
-          return [str];
-        }
-        var n5;
-        if (isSequence) {
-          n5 = m5.body.split(/\.\./);
-        } else {
-          n5 = parseCommaParts(m5.body);
-          if (n5.length === 1) {
-            n5 = expand2(n5[0], false).map(embrace);
-            if (n5.length === 1) {
-              return post.map(function(p5) {
-                return m5.pre + n5[0] + p5;
-              });
-            }
+  } else {
+    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m5.body);
+    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m5.body);
+    const isSequence = isNumericSequence || isAlphaSequence;
+    const isOptions = m5.body.indexOf(",") >= 0;
+    if (!isSequence && !isOptions) {
+      if (m5.post.match(/,(?!,).*\}/)) {
+        str = m5.pre + "{" + m5.body + escClose + m5.post;
+        return expand_(str, max, true);
+      }
+      return [str];
+    }
+    let n5;
+    if (isSequence) {
+      n5 = m5.body.split(/\.\./);
+    } else {
+      n5 = parseCommaParts(m5.body);
+      if (n5.length === 1 && n5[0] !== void 0) {
+        n5 = expand_(n5[0], max, false).map(embrace);
+        if (n5.length === 1) {
+          return post.map((p5) => m5.pre + n5[0] + p5);
+        }
+      }
+    }
+    let N;
+    if (isSequence && n5[0] !== void 0 && n5[1] !== void 0) {
+      const x5 = numeric(n5[0]);
+      const y2 = numeric(n5[1]);
+      const width = Math.max(n5[0].length, n5[1].length);
+      let incr = n5.length === 3 && n5[2] !== void 0 ? Math.abs(numeric(n5[2])) : 1;
+      let test = lte;
+      const reverse = y2 < x5;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      const pad = n5.some(isPadded);
+      N = [];
+      for (let i5 = x5; test(i5, y2); i5 += incr) {
+        let c5;
+        if (isAlphaSequence) {
+          c5 = String.fromCharCode(i5);
+          if (c5 === "\\") {
+            c5 = "";
           }
-        }
-        var N;
-        if (isSequence) {
-          var x5 = numeric(n5[0]);
-          var y2 = numeric(n5[1]);
-          var width = Math.max(n5[0].length, n5[1].length);
-          var incr = n5.length == 3 ? Math.abs(numeric(n5[2])) : 1;
-          var test = lte;
-          var reverse = y2 < x5;
-          if (reverse) {
-            incr *= -1;
-            test = gte;
-          }
-          var pad = n5.some(isPadded);
-          N = [];
-          for (var i5 = x5; test(i5, y2); i5 += incr) {
-            var c5;
-            if (isAlphaSequence) {
-              c5 = String.fromCharCode(i5);
-              if (c5 === "\\")
-                c5 = "";
-            } else {
-              c5 = String(i5);
-              if (pad) {
-                var need = width - c5.length;
-                if (need > 0) {
-                  var z2 = new Array(need + 1).join("0");
-                  if (i5 < 0)
-                    c5 = "-" + z2 + c5.slice(1);
-                  else
-                    c5 = z2 + c5;
-                }
+        } else {
+          c5 = String(i5);
+          if (pad) {
+            const need = width - c5.length;
+            if (need > 0) {
+              const z2 = new Array(need + 1).join("0");
+              if (i5 < 0) {
+                c5 = "-" + z2 + c5.slice(1);
+              } else {
+                c5 = z2 + c5;
               }
             }
-            N.push(c5);
-          }
-        } else {
-          N = [];
-          for (var j5 = 0; j5 < n5.length; j5++) {
-            N.push.apply(N, expand2(n5[j5], false));
           }
         }
-        for (var j5 = 0; j5 < N.length; j5++) {
-          for (var k5 = 0; k5 < post.length; k5++) {
-            var expansion = pre + N[j5] + post[k5];
-            if (!isTop || isSequence || expansion)
-              expansions.push(expansion);
-          }
+        N.push(c5);
+      }
+    } else {
+      N = [];
+      for (let j5 = 0; j5 < n5.length; j5++) {
+        N.push.apply(N, expand_(n5[j5], max, false));
+      }
+    }
+    for (let j5 = 0; j5 < N.length; j5++) {
+      for (let k5 = 0; k5 < post.length && expansions.length < max; k5++) {
+        const expansion = pre + N[j5] + post[k5];
+        if (!isTop || isSequence || expansion) {
+          expansions.push(expansion);
         }
       }
-      return expansions;
     }
   }
+  return expansions;
+}
+var escSlash, escOpen, escClose, escComma, escPeriod, escSlashPattern, escOpenPattern, escClosePattern, escCommaPattern, escPeriodPattern, slashPattern, openPattern, closePattern, commaPattern, periodPattern, EXPANSION_MAX;
+var init_esm2 = __esm({
+  "node_modules/brace-expansion/dist/esm/index.js"() {
+    init_esm();
+    escSlash = "\0SLASH" + Math.random() + "\0";
+    escOpen = "\0OPEN" + Math.random() + "\0";
+    escClose = "\0CLOSE" + Math.random() + "\0";
+    escComma = "\0COMMA" + Math.random() + "\0";
+    escPeriod = "\0PERIOD" + Math.random() + "\0";
+    escSlashPattern = new RegExp(escSlash, "g");
+    escOpenPattern = new RegExp(escOpen, "g");
+    escClosePattern = new RegExp(escClose, "g");
+    escCommaPattern = new RegExp(escComma, "g");
+    escPeriodPattern = new RegExp(escPeriod, "g");
+    slashPattern = /\\\\/g;
+    openPattern = /\\{/g;
+    closePattern = /\\}/g;
+    commaPattern = /\\,/g;
+    periodPattern = /\\./g;
+    EXPANSION_MAX = 1e5;
+  }
 });
 
 // node_modules/minimatch/dist/esm/assert-valid-pattern.js
@@ -40570,11 +41534,13 @@ var init_ast = __esm({
         let escaping = false;
         let re = "";
         let uflag = false;
+        let inStar = false;
         for (let i5 = 0; i5 < glob2.length; i5++) {
           const c5 = glob2.charAt(i5);
           if (escaping) {
             escaping = false;
             re += (reSpecials.has(c5) ? "\\" : "") + c5;
+            inStar = false;
             continue;
           }
           if (c5 === "\\") {
@@ -40592,16 +41558,19 @@ var init_ast = __esm({
               uflag = uflag || needUflag;
               i5 += consumed - 1;
               hasMagic2 = hasMagic2 || magic;
+              inStar = false;
               continue;
             }
           }
           if (c5 === "*") {
-            if (noEmpty && glob2 === "*")
-              re += starNoEmpty;
-            else
-              re += star;
+            if (inStar)
+              continue;
+            inStar = true;
+            re += noEmpty && /^[*]+$/.test(glob2) ? starNoEmpty : star;
             hasMagic2 = true;
             continue;
+          } else {
+            inStar = false;
           }
           if (c5 === "?") {
             re += qmark;
@@ -40627,10 +41596,10 @@ var init_escape = __esm({
 });
 
 // node_modules/minimatch/dist/esm/index.js
-var import_brace_expansion, minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path5, sep2, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
-var init_esm = __esm({
+var minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path5, sep2, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
+var init_esm3 = __esm({
   "node_modules/minimatch/dist/esm/index.js"() {
-    import_brace_expansion = __toESM(require_brace_expansion(), 1);
+    init_esm2();
     init_assert_valid_pattern();
     init_ast();
     init_escape();
@@ -40753,7 +41722,7 @@ var init_esm = __esm({
       if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
         return [pattern];
       }
-      return (0, import_brace_expansion.default)(pattern);
+      return expand(pattern);
     };
     minimatch.braceExpand = braceExpand;
     makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
@@ -41359,7 +42328,7 @@ var init_esm = __esm({
 
 // node_modules/path-scurry/node_modules/lru-cache/dist/esm/index.js
 var perf, warned, PROCESS, emitWarning, AC, AS, shouldWarn, TYPE, isPosInt, getUintArray, ZeroArray, Stack, LRUCache;
-var init_esm2 = __esm({
+var init_esm4 = __esm({
   "node_modules/path-scurry/node_modules/lru-cache/dist/esm/index.js"() {
     perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
     warned = /* @__PURE__ */ new Set();
@@ -42733,7 +43702,7 @@ var init_esm2 = __esm({
 
 // node_modules/minipass/dist/esm/index.js
 var import_node_events, import_node_stream, import_node_string_decoder, proc, isStream, isReadable, isWritable, EOF, MAYBE_EMIT_END, EMITTED_END, EMITTING_END, EMITTED_ERROR, CLOSED, READ, FLUSH, FLUSHCHUNK, ENCODING, DECODER, FLOWING, PAUSED, RESUME, BUFFER, PIPES, BUFFERLENGTH, BUFFERPUSH, BUFFERSHIFT, OBJECTMODE, DESTROYED, ERROR, EMITDATA, EMITEND, EMITEND2, ASYNC, ABORT, ABORTED, SIGNAL, DATALISTENERS, DISCARDED, defer, nodefer, isEndish, isArrayBufferLike, isArrayBufferView, Pipe, PipeProxyErrors, isObjectModeOptions, isEncodingOptions, Minipass;
-var init_esm3 = __esm({
+var init_esm5 = __esm({
   "node_modules/minipass/dist/esm/index.js"() {
     import_node_events = require("node:events");
     import_node_stream = __toESM(require("node:stream"), 1);
@@ -43463,10 +44432,10 @@ var init_esm3 = __esm({
        * Return a void Promise that resolves once the stream ends.
        */
       async promise() {
-        return new Promise((resolve7, reject2) => {
+        return new Promise((resolve8, reject2) => {
           this.on(DESTROYED, () => reject2(new Error("stream destroyed")));
           this.on("error", (er) => reject2(er));
-          this.on("end", () => resolve7());
+          this.on("end", () => resolve8());
         });
       }
       /**
@@ -43490,7 +44459,7 @@ var init_esm3 = __esm({
             return Promise.resolve({ done: false, value: res });
           if (this[EOF])
             return stop();
-          let resolve7;
+          let resolve8;
           let reject2;
           const onerr = (er) => {
             this.off("data", ondata);
@@ -43504,19 +44473,19 @@ var init_esm3 = __esm({
             this.off("end", onend);
             this.off(DESTROYED, ondestroy);
             this.pause();
-            resolve7({ value, done: !!this[EOF] });
+            resolve8({ value, done: !!this[EOF] });
           };
           const onend = () => {
             this.off("error", onerr);
             this.off("data", ondata);
             this.off(DESTROYED, ondestroy);
             stop();
-            resolve7({ done: true, value: void 0 });
+            resolve8({ done: true, value: void 0 });
           };
           const ondestroy = () => onerr(new Error("stream destroyed"));
           return new Promise((res2, rej) => {
             reject2 = rej;
-            resolve7 = res2;
+            resolve8 = res2;
             this.once(DESTROYED, ondestroy);
             this.once("error", onerr);
             this.once("end", onend);
@@ -43620,15 +44589,15 @@ var init_esm3 = __esm({
 
 // node_modules/path-scurry/dist/esm/index.js
 var import_node_path, import_node_url, import_fs6, 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({
+var init_esm6 = __esm({
   "node_modules/path-scurry/dist/esm/index.js"() {
-    init_esm2();
+    init_esm4();
     import_node_path = require("node:path");
     import_node_url = require("node:url");
     import_fs6 = require("fs");
     actualFS = __toESM(require("node:fs"), 1);
     import_promises = require("node:fs/promises");
-    init_esm3();
+    init_esm5();
     realpathSync2 = import_fs6.realpathSync.native;
     defaultFS = {
       lstatSync: import_fs6.lstatSync,
@@ -44500,9 +45469,9 @@ var init_esm4 = __esm({
         if (this.#asyncReaddirInFlight) {
           await this.#asyncReaddirInFlight;
         } else {
-          let resolve7 = () => {
+          let resolve8 = () => {
           };
-          this.#asyncReaddirInFlight = new Promise((res) => resolve7 = res);
+          this.#asyncReaddirInFlight = new Promise((res) => resolve8 = res);
           try {
             for (const e5 of await this.#fs.promises.readdir(fullpath, {
               withFileTypes: true
@@ -44515,7 +45484,7 @@ var init_esm4 = __esm({
             children.provisional = 0;
           }
           this.#asyncReaddirInFlight = void 0;
-          resolve7();
+          resolve8();
         }
         return children.slice(0, children.provisional);
       }
@@ -45358,7 +46327,7 @@ var init_esm4 = __esm({
 var isPatternList, isGlobList, Pattern;
 var init_pattern = __esm({
   "node_modules/glob/dist/esm/pattern.js"() {
-    init_esm();
+    init_esm3();
     isPatternList = (pl) => pl.length >= 1;
     isGlobList = (gl) => gl.length >= 1;
     Pattern = class _Pattern {
@@ -45529,7 +46498,7 @@ var init_pattern = __esm({
 var defaultPlatform2, Ignore;
 var init_ignore = __esm({
   "node_modules/glob/dist/esm/ignore.js"() {
-    init_esm();
+    init_esm3();
     init_pattern();
     defaultPlatform2 = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
     Ignore = class {
@@ -45623,7 +46592,7 @@ var init_ignore = __esm({
 var HasWalkedCache, MatchRecord, SubWalks, Processor;
 var init_processor = __esm({
   "node_modules/glob/dist/esm/processor.js"() {
-    init_esm();
+    init_esm3();
     HasWalkedCache = class _HasWalkedCache {
       store;
       constructor(store = /* @__PURE__ */ new Map()) {
@@ -45850,7 +46819,7 @@ var init_processor = __esm({
 var makeIgnore, GlobUtil, GlobWalker, GlobStream;
 var init_walker = __esm({
   "node_modules/glob/dist/esm/walker.js"() {
-    init_esm3();
+    init_esm5();
     init_ignore();
     init_processor();
     makeIgnore = (ignore2, opts) => typeof ignore2 === "string" ? new Ignore([ignore2], opts) : Array.isArray(ignore2) ? new Ignore(ignore2, opts) : ignore2;
@@ -46185,9 +47154,9 @@ var init_walker = __esm({
 var import_node_url2, defaultPlatform3, Glob;
 var init_glob = __esm({
   "node_modules/glob/dist/esm/glob.js"() {
-    init_esm();
+    init_esm3();
     import_node_url2 = require("node:url");
-    init_esm4();
+    init_esm6();
     init_pattern();
     init_walker();
     defaultPlatform3 = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
@@ -46395,7 +47364,7 @@ var init_glob = __esm({
 var hasMagic;
 var init_has_magic = __esm({
   "node_modules/glob/dist/esm/has-magic.js"() {
-    init_esm();
+    init_esm3();
     hasMagic = (pattern, options = {}) => {
       if (!Array.isArray(pattern)) {
         pattern = [pattern];
@@ -46429,12 +47398,12 @@ function globIterate(pattern, options = {}) {
   return new Glob(pattern, options).iterate();
 }
 var streamSync, stream, iterateSync, iterate, sync, glob;
-var init_esm5 = __esm({
+var init_esm7 = __esm({
   "node_modules/glob/dist/esm/index.js"() {
-    init_esm();
+    init_esm3();
     init_glob();
     init_has_magic();
-    init_esm();
+    init_esm3();
     init_glob();
     init_has_magic();
     init_ignore();
@@ -46564,19 +47533,19 @@ function createWrappedTools(baseTools) {
   }
   return wrappedTools;
 }
-var import_child_process6, import_util11, import_crypto3, import_events, import_fs7, import_fs8, import_path7, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
+var import_child_process6, import_util11, import_crypto4, import_events, import_fs7, import_fs8, import_path8, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
 var init_probeTool = __esm({
   "src/agent/probeTool.js"() {
     "use strict";
     init_index();
     import_child_process6 = require("child_process");
     import_util11 = require("util");
-    import_crypto3 = require("crypto");
+    import_crypto4 = require("crypto");
     import_events = require("events");
     import_fs7 = __toESM(require("fs"), 1);
     import_fs8 = require("fs");
-    import_path7 = __toESM(require("path"), 1);
-    init_esm5();
+    import_path8 = __toESM(require("path"), 1);
+    init_esm7();
     init_symlink_utils();
     toolCallEmitter = new import_events.EventEmitter();
     activeToolExecutions = /* @__PURE__ */ new Map();
@@ -46586,7 +47555,7 @@ var init_probeTool = __esm({
         // Spread schema, description etc.
         execute: async (params) => {
           const debug = process.env.DEBUG === "1";
-          const toolSessionId = params.sessionId || (0, import_crypto3.randomUUID)();
+          const toolSessionId = params.sessionId || (0, import_crypto4.randomUUID)();
           if (debug) {
             console.log(`[DEBUG] probeTool: Executing ${toolName} for session ${toolSessionId}`);
           }
@@ -46664,17 +47633,17 @@ var init_probeTool = __esm({
       execute: async (params) => {
         const { directory = ".", workingDirectory } = params;
         const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = import_path7.default.resolve(baseCwd);
+        const secureBaseDir = import_path8.default.resolve(baseCwd);
         const isDependencyPath = directory.startsWith("/dep/") || directory.startsWith("go:") || directory.startsWith("js:") || directory.startsWith("rust:");
         let targetDir;
-        if (import_path7.default.isAbsolute(directory)) {
-          targetDir = import_path7.default.resolve(directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
+        if (import_path8.default.isAbsolute(directory)) {
+          targetDir = import_path8.default.resolve(directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path8.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Cannot access directory outside workspace: ${directory}`);
           }
         } else {
-          targetDir = import_path7.default.resolve(secureBaseDir, directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
+          targetDir = import_path8.default.resolve(secureBaseDir, directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path8.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Access denied: ${directory}`);
           }
         }
@@ -46691,7 +47660,7 @@ var init_probeTool = __esm({
             return `${(size / (1024 * 1024 * 1024)).toFixed(1)}G`;
           };
           const entries = await Promise.all(files.map(async (file) => {
-            const fullPath = import_path7.default.join(targetDir, file.name);
+            const fullPath = import_path8.default.join(targetDir, file.name);
             const entryType = await getEntryType(file, fullPath);
             return {
               name: file.name,
@@ -46728,17 +47697,17 @@ var init_probeTool = __esm({
           throw new Error("Pattern is required for file search");
         }
         const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = import_path7.default.resolve(baseCwd);
+        const secureBaseDir = import_path8.default.resolve(baseCwd);
         const isDependencyPath = directory.startsWith("/dep/") || directory.startsWith("go:") || directory.startsWith("js:") || directory.startsWith("rust:");
         let targetDir;
-        if (import_path7.default.isAbsolute(directory)) {
-          targetDir = import_path7.default.resolve(directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
+        if (import_path8.default.isAbsolute(directory)) {
+          targetDir = import_path8.default.resolve(directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path8.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Cannot access directory outside workspace: ${directory}`);
           }
         } else {
-          targetDir = import_path7.default.resolve(secureBaseDir, directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
+          targetDir = import_path8.default.resolve(secureBaseDir, directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path8.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Access denied: ${directory}`);
           }
         }
@@ -46784,7 +47753,7 @@ function createMockProvider() {
       provider: "mock",
       // Mock the doGenerate method used by Vercel AI SDK
       doGenerate: async ({ messages, tools: tools2 }) => {
-        await new Promise((resolve7) => setTimeout(resolve7, 10));
+        await new Promise((resolve8) => setTimeout(resolve8, 10));
         return {
           text: "This is a mock response for testing",
           toolCalls: [],
@@ -51987,23 +52956,23 @@ var init_regexp_parser = __esm({
         return ASSERT_NEVER_REACH_HERE();
       }
       quantifier(isBacktracking = false) {
-        let range2 = void 0;
+        let range3 = void 0;
         const begin = this.idx;
         switch (this.popChar()) {
           case "*":
-            range2 = {
+            range3 = {
               atLeast: 0,
               atMost: Infinity
             };
             break;
           case "+":
-            range2 = {
+            range3 = {
               atLeast: 1,
               atMost: Infinity
             };
             break;
           case "?":
-            range2 = {
+            range3 = {
               atLeast: 0,
               atMost: 1
             };
@@ -52012,7 +52981,7 @@ var init_regexp_parser = __esm({
             const atLeast = this.integerIncludingZero();
             switch (this.popChar()) {
               case "}":
-                range2 = {
+                range3 = {
                   atLeast,
                   atMost: atLeast
                 };
@@ -52021,12 +52990,12 @@ var init_regexp_parser = __esm({
                 let atMost;
                 if (this.isDigit()) {
                   atMost = this.integerIncludingZero();
-                  range2 = {
+                  range3 = {
                     atLeast,
                     atMost
                   };
                 } else {
-                  range2 = {
+                  range3 = {
                     atLeast,
                     atMost: Infinity
                   };
@@ -52034,25 +53003,25 @@ var init_regexp_parser = __esm({
                 this.consumeChar("}");
                 break;
             }
-            if (isBacktracking === true && range2 === void 0) {
+            if (isBacktracking === true && range3 === void 0) {
               return void 0;
             }
-            ASSERT_EXISTS(range2);
+            ASSERT_EXISTS(range3);
             break;
         }
-        if (isBacktracking === true && range2 === void 0) {
+        if (isBacktracking === true && range3 === void 0) {
           return void 0;
         }
-        if (ASSERT_EXISTS(range2)) {
+        if (ASSERT_EXISTS(range3)) {
           if (this.peekChar(0) === "?") {
             this.consumeChar("?");
-            range2.greedy = false;
+            range3.greedy = false;
           } else {
-            range2.greedy = true;
+            range3.greedy = true;
           }
-          range2.type = "Quantifier";
-          range2.loc = this.loc(begin);
-          return range2;
+          range3.type = "Quantifier";
+          range3.loc = this.loc(begin);
+          return range3;
         }
       }
       atom() {
@@ -52754,18 +53723,18 @@ function firstCharOptimizedIndices(ast, result, ignoreCase) {
               if (typeof code === "number") {
                 addOptimizedIdxToResult(code, result, ignoreCase);
               } else {
-                const range2 = code;
+                const range3 = code;
                 if (ignoreCase === true) {
-                  for (let rangeCode = range2.from; rangeCode <= range2.to; rangeCode++) {
+                  for (let rangeCode = range3.from; rangeCode <= range3.to; rangeCode++) {
                     addOptimizedIdxToResult(rangeCode, result, ignoreCase);
                   }
                 } else {
-                  for (let rangeCode = range2.from; rangeCode <= range2.to && rangeCode < minOptimizationVal; rangeCode++) {
+                  for (let rangeCode = range3.from; rangeCode <= range3.to && rangeCode < minOptimizationVal; rangeCode++) {
                     addOptimizedIdxToResult(rangeCode, result, ignoreCase);
                   }
-                  if (range2.to >= minOptimizationVal) {
-                    const minUnOptVal = range2.from >= minOptimizationVal ? range2.from : minOptimizationVal;
-                    const maxUnOptVal = range2.to;
+                  if (range3.to >= minOptimizationVal) {
+                    const minUnOptVal = range3.from >= minOptimizationVal ? range3.from : minOptimizationVal;
+                    const maxUnOptVal = range3.to;
                     const minOptIdx = charCodeToOptimizedIndex(minUnOptVal);
                     const maxOptIdx = charCodeToOptimizedIndex(maxUnOptVal);
                     for (let currOptIdx = minOptIdx; currOptIdx <= maxOptIdx; currOptIdx++) {
@@ -52826,8 +53795,8 @@ function findCode(setNode, targetCharCodes) {
     if (typeof codeOrRange === "number") {
       return includes_default(targetCharCodes, codeOrRange);
     } else {
-      const range2 = codeOrRange;
-      return find_default(targetCharCodes, (targetCode) => range2.from <= targetCode && targetCode <= range2.to) !== void 0;
+      const range3 = codeOrRange;
+      return find_default(targetCharCodes, (targetCode) => range3.from <= targetCode && targetCode <= range3.to) !== void 0;
     }
   });
 }
@@ -70732,8 +71701,8 @@ var require_createRange = __commonJS({
 var require_range = __commonJS({
   "node_modules/lodash/range.js"(exports2, module2) {
     var createRange = require_createRange();
-    var range2 = createRange();
-    module2.exports = range2;
+    var range3 = createRange();
+    module2.exports = range3;
   }
 });
 
@@ -79974,7 +80943,7 @@ var require_compile = __commonJS({
       const schOrFunc = root2.refs[ref2];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve7.call(this, root2, ref2);
+      let _sch = resolve8.call(this, root2, ref2);
       if (_sch === void 0) {
         const schema = (_a16 = root2.localRefs) === null || _a16 === void 0 ? void 0 : _a16[ref2];
         const { schemaId } = this.opts;
@@ -80001,7 +80970,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s22) {
       return s1.schema === s22.schema && s1.root === s22.root && s1.baseId === s22.baseId;
     }
-    function resolve7(root2, ref2) {
+    function resolve8(root2, ref2) {
       let sch;
       while (typeof (sch = this.refs[ref2]) == "string")
         ref2 = sch;
@@ -80576,7 +81545,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve7(baseURI, relativeURI, options) {
+    function resolve8(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse9(baseURI, schemelessOptions), parse9(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -80803,7 +81772,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize: normalize3,
-      resolve: resolve7,
+      resolve: resolve8,
       resolveComponent,
       equal,
       serialize,
@@ -83496,6 +84465,7 @@ __export(schemaUtils_exports, {
   processSchemaResponse: () => processSchemaResponse,
   replaceMermaidDiagramsInJson: () => replaceMermaidDiagramsInJson,
   replaceMermaidDiagramsInMarkdown: () => replaceMermaidDiagramsInMarkdown,
+  sanitizeMarkdownEscapesInJson: () => sanitizeMarkdownEscapesInJson,
   tryAutoWrapForSimpleSchema: () => tryAutoWrapForSimpleSchema,
   tryMaidAutoFix: () => tryMaidAutoFix,
   validateAndFixMermaidResponse: () => validateAndFixMermaidResponse,
@@ -83599,6 +84569,17 @@ function decodeHtmlEntities(text) {
   }
   return decoded;
 }
+function sanitizeMarkdownEscapesInJson(jsonString) {
+  if (!jsonString || typeof jsonString !== "string") {
+    return jsonString;
+  }
+  return jsonString.replace(/\\\\|\\([^"\\\/bfnrtu])/g, (match2, captured) => {
+    if (match2 === "\\\\") {
+      return "\\\\";
+    }
+    return captured;
+  });
+}
 function normalizeJsonQuotes(str) {
   if (!str || typeof str !== "string") {
     return str;
@@ -83651,6 +84632,15 @@ function cleanSchemaResponse(response) {
   if (resultWrapperMatch) {
     return cleanSchemaResponse(resultWrapperMatch[1]);
   }
+  const toolCodeMatch = trimmed.match(/<tool_code>\s*([\s\S]*?)\s*<\/tool_code>/);
+  if (toolCodeMatch) {
+    let innerContent = toolCodeMatch[1].trim();
+    const funcCallMatch = innerContent.match(/(?:print|attempt_completion)\s*\(\s*([{\[][\s\S]*[}\]])\s*\)/);
+    if (funcCallMatch) {
+      return cleanSchemaResponse(funcCallMatch[1]);
+    }
+    return cleanSchemaResponse(innerContent);
+  }
   const jsonBlockMatch = trimmed.match(/```json\s*\n([\s\S]*?)\n```/);
   if (jsonBlockMatch) {
     return normalizeJsonQuotes(jsonBlockMatch[1].trim());
@@ -83718,9 +84708,25 @@ function validateJsonResponse(response, options = {}) {
       console.log(`[DEBUG] JSON validation: Schema validation enabled`);
     }
   }
+  let responseToValidate = response;
+  try {
+    JSON.parse(response);
+  } catch (initialError) {
+    if (initialError.message && initialError.message.includes("escape")) {
+      const sanitized = sanitizeMarkdownEscapesInJson(response);
+      try {
+        JSON.parse(sanitized);
+        responseToValidate = sanitized;
+        if (debug) {
+          console.log(`[DEBUG] JSON validation: Fixed Markdown escapes in JSON (issue #441)`);
+        }
+      } catch {
+      }
+    }
+  }
   try {
     const parseStart = Date.now();
-    const parsed = JSON.parse(response);
+    const parsed = JSON.parse(responseToValidate);
     const parseTime = Date.now() - parseStart;
     if (debug) {
       console.log(`[DEBUG] JSON validation: Successfully parsed in ${parseTime}ms`);
@@ -84062,7 +85068,21 @@ function tryAutoWrapForSimpleSchema(response, schema, options = {}) {
       console.log(`[DEBUG] Auto-wrap: Response is already valid JSON, skipping`);
     }
     return null;
-  } catch {
+  } catch (initialError) {
+    if (initialError.message && initialError.message.includes("escape")) {
+      try {
+        const sanitized = sanitizeMarkdownEscapesInJson(response);
+        JSON.parse(sanitized);
+        if (debug) {
+          console.log(`[DEBUG] Auto-wrap: Fixed Markdown escapes in JSON (issue #441), returning sanitized JSON`);
+        }
+        return sanitized;
+      } catch {
+        if (debug) {
+          console.log(`[DEBUG] Auto-wrap: Markdown escape sanitization didn't fix JSON, proceeding with wrapping`);
+        }
+      }
+    }
   }
   const wrapped = JSON.stringify({ [wrapperInfo.fieldName]: response });
   if (debug) {
@@ -85275,13 +86295,13 @@ function loadMCPConfiguration() {
     // Environment variable path
     process.env.MCP_CONFIG_PATH,
     // Local project paths
-    (0, import_path8.join)(process.cwd(), ".mcp", "config.json"),
-    (0, import_path8.join)(process.cwd(), "mcp.config.json"),
+    (0, import_path9.join)(process.cwd(), ".mcp", "config.json"),
+    (0, import_path9.join)(process.cwd(), "mcp.config.json"),
     // Home directory paths
-    (0, import_path8.join)((0, import_os3.homedir)(), ".config", "probe", "mcp.json"),
-    (0, import_path8.join)((0, import_os3.homedir)(), ".mcp", "config.json"),
+    (0, import_path9.join)((0, import_os3.homedir)(), ".config", "probe", "mcp.json"),
+    (0, import_path9.join)((0, import_os3.homedir)(), ".mcp", "config.json"),
     // Claude-style config location
-    (0, import_path8.join)((0, import_os3.homedir)(), "Library", "Application Support", "Claude", "mcp_config.json")
+    (0, import_path9.join)((0, import_os3.homedir)(), "Library", "Application Support", "Claude", "mcp_config.json")
   ].filter(Boolean);
   let config = null;
   for (const configPath of configPaths) {
@@ -85408,16 +86428,16 @@ function parseEnabledServers(config) {
   }
   return servers;
 }
-var import_fs9, import_path8, import_os3, import_url4, __filename4, __dirname4, DEFAULT_TIMEOUT, MAX_TIMEOUT, DEFAULT_CONFIG;
+var import_fs9, import_path9, import_os3, import_url4, __filename4, __dirname4, DEFAULT_TIMEOUT, MAX_TIMEOUT, DEFAULT_CONFIG;
 var init_config = __esm({
   "src/agent/mcp/config.js"() {
     "use strict";
     import_fs9 = require("fs");
-    import_path8 = require("path");
+    import_path9 = require("path");
     import_os3 = require("os");
     import_url4 = require("url");
     __filename4 = (0, import_url4.fileURLToPath)("file:///");
-    __dirname4 = (0, import_path8.dirname)(__filename4);
+    __dirname4 = (0, import_path9.dirname)(__filename4);
     DEFAULT_TIMEOUT = 3e4;
     MAX_TIMEOUT = (() => {
       if (process.env.MCP_MAX_TIMEOUT) {
@@ -85431,7 +86451,7 @@ var init_config = __esm({
         // Example probe server configuration
         "probe-local": {
           command: "node",
-          args: [(0, import_path8.join)(__dirname4, "../../../examples/chat/mcpServer.js")],
+          args: [(0, import_path9.join)(__dirname4, "../../../examples/chat/mcpServer.js")],
           transport: "stdio",
           enabled: false
         },
@@ -91014,7 +92034,7 @@ var require_compose_scalar = __commonJS({
     var resolveBlockScalar = require_resolve_block_scalar();
     var resolveFlowScalar = require_resolve_flow_scalar();
     function composeScalar(ctx, token, tagToken, onError) {
-      const { value, type, comment, range: range2 } = token.type === "block-scalar" ? resolveBlockScalar.resolveBlockScalar(ctx, token, onError) : resolveFlowScalar.resolveFlowScalar(token, ctx.options.strict, onError);
+      const { value, type, comment, range: range3 } = token.type === "block-scalar" ? resolveBlockScalar.resolveBlockScalar(ctx, token, onError) : resolveFlowScalar.resolveFlowScalar(token, ctx.options.strict, onError);
       const tagName = tagToken ? ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg)) : null;
       let tag2;
       if (ctx.options.stringKeys && ctx.atKey) {
@@ -91034,7 +92054,7 @@ var require_compose_scalar = __commonJS({
         onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg);
         scalar = new Scalar.Scalar(value);
       }
-      scalar.range = range2;
+      scalar.range = range3;
       scalar.source = value;
       if (type)
         scalar.type = type;
@@ -93625,17 +94645,17 @@ async function parseSkillFile(skillFilePath, directoryName) {
       description,
       skillFilePath,
       directoryName,
-      sourceDir: (0, import_path9.dirname)(skillFilePath)
+      sourceDir: (0, import_path10.dirname)(skillFilePath)
     },
     error: null
   };
 }
-var import_promises2, import_path9, import_yaml, SKILL_NAME_REGEX, MAX_SKILL_NAME_LENGTH, MAX_DESCRIPTION_CHARS;
+var import_promises2, import_path10, import_yaml, SKILL_NAME_REGEX, MAX_SKILL_NAME_LENGTH, MAX_DESCRIPTION_CHARS;
 var init_parser7 = __esm({
   "src/agent/skills/parser.js"() {
     "use strict";
     import_promises2 = require("fs/promises");
-    import_path9 = require("path");
+    import_path10 = require("path");
     import_yaml = __toESM(require_dist(), 1);
     SKILL_NAME_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
     MAX_SKILL_NAME_LENGTH = 64;
@@ -93645,12 +94665,12 @@ var init_parser7 = __esm({
 
 // src/agent/skills/registry.js
 function isPathInside(basePath, targetPath) {
-  const base2 = (0, import_path10.resolve)(basePath);
-  const target = (0, import_path10.resolve)(targetPath);
-  const rel = (0, import_path10.relative)(base2, target);
+  const base2 = (0, import_path11.resolve)(basePath);
+  const target = (0, import_path11.resolve)(targetPath);
+  const rel = (0, import_path11.relative)(base2, target);
   if (rel === "") return true;
-  if (rel === ".." || rel.startsWith(`..${import_path10.sep}`)) return false;
-  if ((0, import_path10.isAbsolute)(rel)) return false;
+  if (rel === ".." || rel.startsWith(`..${import_path11.sep}`)) return false;
+  if ((0, import_path11.isAbsolute)(rel)) return false;
   return true;
 }
 function isSafeEntryName(name14) {
@@ -93658,19 +94678,19 @@ function isSafeEntryName(name14) {
   if (name14.includes("\0")) return false;
   return !name14.includes("/") && !name14.includes("\\");
 }
-var import_fs10, import_promises3, import_path10, DEFAULT_SKILL_DIRS, SKILL_FILE_NAME, SkillRegistry;
+var import_fs10, import_promises3, import_path11, DEFAULT_SKILL_DIRS, SKILL_FILE_NAME, SkillRegistry;
 var init_registry = __esm({
   "src/agent/skills/registry.js"() {
     "use strict";
     import_fs10 = require("fs");
     import_promises3 = require("fs/promises");
-    import_path10 = require("path");
+    import_path11 = require("path");
     init_parser7();
     DEFAULT_SKILL_DIRS = [".claude/skills", ".codex/skills", "skills", ".skills"];
     SKILL_FILE_NAME = "SKILL.md";
     SkillRegistry = class {
       constructor({ repoRoot, skillDirs = DEFAULT_SKILL_DIRS, debug = false } = {}) {
-        this.repoRoot = repoRoot ? (0, import_path10.resolve)(repoRoot) : process.cwd();
+        this.repoRoot = repoRoot ? (0, import_path11.resolve)(repoRoot) : process.cwd();
         this.repoRootReal = null;
         this.skillDirs = Array.isArray(skillDirs) && skillDirs.length > 0 ? skillDirs : DEFAULT_SKILL_DIRS;
         this.debug = debug;
@@ -93724,8 +94744,8 @@ var init_registry = __esm({
         }
       }
       async _resolveSkillDir(skillDir) {
-        const resolved = (0, import_path10.isAbsolute)(skillDir) ? (0, import_path10.resolve)(skillDir) : (0, import_path10.resolve)(this.repoRoot, skillDir);
-        const repoRoot = this.repoRootReal || (0, import_path10.resolve)(this.repoRoot);
+        const resolved = (0, import_path11.isAbsolute)(skillDir) ? (0, import_path11.resolve)(skillDir) : (0, import_path11.resolve)(this.repoRoot, skillDir);
+        const repoRoot = this.repoRootReal || (0, import_path11.resolve)(this.repoRoot);
         const resolvedReal = await this._resolveRealPath(resolved);
         if (!resolvedReal) return null;
         if (!isPathInside(repoRoot, resolvedReal)) {
@@ -93756,8 +94776,8 @@ var init_registry = __esm({
             }
             continue;
           }
-          const skillFolder = (0, import_path10.join)(dirPath, entry.name);
-          const skillFilePath = (0, import_path10.join)(skillFolder, SKILL_FILE_NAME);
+          const skillFolder = (0, import_path11.join)(dirPath, entry.name);
+          const skillFilePath = (0, import_path11.join)(skillFolder, SKILL_FILE_NAME);
           let skillStat;
           try {
             skillStat = await (0, import_promises3.lstat)(skillFilePath);
@@ -93915,7 +94935,7 @@ function extractErrorInfo(error2) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
 var DEFAULT_RETRYABLE_ERRORS, RetryManager;
 var init_RetryManager = __esm({
@@ -94695,9 +95715,9 @@ async function truncateIfNeeded(content, tokenCounter, sessionId, maxTokens) {
   let tempFilePath = null;
   let fileError = null;
   try {
-    const tempDir = (0, import_path11.join)((0, import_os4.tmpdir)(), "probe-output");
+    const tempDir = (0, import_path12.join)((0, import_os4.tmpdir)(), "probe-output");
     await (0, import_promises4.mkdir)(tempDir, { recursive: true });
-    tempFilePath = (0, import_path11.join)(tempDir, `tool-output-${sessionId || "unknown"}-${(0, import_crypto4.randomUUID)()}.txt`);
+    tempFilePath = (0, import_path12.join)(tempDir, `tool-output-${sessionId || "unknown"}-${(0, import_crypto5.randomUUID)()}.txt`);
     await (0, import_promises4.writeFile)(tempFilePath, content, "utf8");
   } catch (err) {
     fileError = err.message || "Unknown file system error";
@@ -94745,14 +95765,14 @@ ${truncatedBody}
     error: fileError || void 0
   };
 }
-var import_promises4, import_os4, import_path11, import_crypto4, DEFAULT_MAX_OUTPUT_TOKENS, CHARS_PER_TOKEN, TAIL_TOKENS, MIN_LIMIT_FOR_TAIL;
+var import_promises4, import_os4, import_path12, import_crypto5, DEFAULT_MAX_OUTPUT_TOKENS, CHARS_PER_TOKEN, TAIL_TOKENS, MIN_LIMIT_FOR_TAIL;
 var init_outputTruncator = __esm({
   "src/agent/outputTruncator.js"() {
     "use strict";
     import_promises4 = require("fs/promises");
     import_os4 = require("os");
-    import_path11 = require("path");
-    import_crypto4 = require("crypto");
+    import_path12 = require("path");
+    import_crypto5 = require("crypto");
     DEFAULT_MAX_OUTPUT_TOKENS = 2e4;
     CHARS_PER_TOKEN = 4;
     TAIL_TOKENS = 1e3;
@@ -95874,14 +96894,14 @@ var require_executor = __commonJS({
     function asyncDone(callback) {
       let isInstant = false;
       let instant;
-      const p5 = new Promise((resolve7, reject2) => {
+      const p5 = new Promise((resolve8, reject2) => {
         callback((err, result) => {
           if (err)
             reject2(err);
           else {
             isInstant = true;
             instant = result;
-            resolve7({ result });
+            resolve8({ result });
           }
         });
       });
@@ -95904,10 +96924,10 @@ var require_executor = __commonJS({
     }
     async function execAsync4(ticks, tree, scope, context, doneOriginal, inLoopOrSwitch) {
       let done = doneOriginal;
-      const p5 = new Promise((resolve7) => {
+      const p5 = new Promise((resolve8) => {
         done = (e5, r5) => {
           doneOriginal(e5, r5);
-          resolve7();
+          resolve8();
         };
       });
       if (!_execNoneRecurse(ticks, tree, scope, context, done, true, inLoopOrSwitch) && utils.isLisp(tree)) {
@@ -104258,6 +105278,13 @@ function generateSandboxGlobals(options) {
           if (i5 < keys2.length) params[keys2[i5]] = arg;
         });
       }
+      if (params.path && typeof params.path === "object") {
+        const coercedPath = params.path.file_path || params.path.path || params.path.directory || params.path.filename;
+        if (coercedPath && typeof coercedPath === "string") {
+          logFn?.(`[${name14}] Warning: Coerced object path to string "${coercedPath}" (issue #444)`);
+          params.path = coercedPath;
+        }
+      }
       const validated = schema.safeParse(params);
       if (!validated.success) {
         throw new Error(`Invalid parameters for ${name14}: ${validated.error.message}`);
@@ -104294,6 +105321,11 @@ function generateSandboxGlobals(options) {
   }
   if (llmCall) {
     const rawLLM = async (instruction, data3, opts = {}) => {
+      const dataStr = typeof data3 === "string" ? data3 : JSON.stringify(data3);
+      if (dataStr && dataStr.startsWith("ERROR:")) {
+        logFn?.("[LLM] Blocked: data contains error from previous tool call");
+        return "ERROR: Previous tool call failed - " + dataStr.substring(0, 200);
+      }
       const result = await llmCall(instruction, data3, opts);
       if (opts.schema && typeof result === "string") {
         try {
@@ -105859,7 +106891,7 @@ async function executeBashCommand(command, options = {}) {
   } = options;
   let cwd = workingDirectory;
   try {
-    cwd = (0, import_path12.resolve)(cwd);
+    cwd = (0, import_path13.resolve)(cwd);
     if (!(0, import_fs11.existsSync)(cwd)) {
       throw new Error(`Working directory does not exist: ${cwd}`);
     }
@@ -105881,7 +106913,7 @@ async function executeBashCommand(command, options = {}) {
     console.log(`[BashExecutor] Working directory: "${cwd}"`);
     console.log(`[BashExecutor] Timeout: ${timeout}ms`);
   }
-  return new Promise((resolve7, reject2) => {
+  return new Promise((resolve8, reject2) => {
     const processEnv = {
       ...process.env,
       ...env
@@ -105898,7 +106930,7 @@ async function executeBashCommand(command, options = {}) {
     } else {
       const args = parseCommandForExecution(command);
       if (!args || args.length === 0) {
-        resolve7({
+        resolve8({
           success: false,
           error: "Failed to parse command",
           stdout: "",
@@ -105983,7 +107015,7 @@ async function executeBashCommand(command, options = {}) {
         success = false;
         error2 = `Command exited with code ${code}`;
       }
-      resolve7({
+      resolve8({
         success,
         error: error2,
         stdout: stdout.trim(),
@@ -106003,7 +107035,7 @@ async function executeBashCommand(command, options = {}) {
       if (debug) {
         console.log(`[BashExecutor] Spawn error:`, error2);
       }
-      resolve7({
+      resolve8({
         success: false,
         error: `Failed to execute command: ${error2.message}`,
         stdout: "",
@@ -106097,24 +107129,24 @@ function validateExecutionOptions(options = {}) {
     warnings
   };
 }
-var import_child_process7, import_path12, import_fs11;
+var import_child_process7, import_path13, import_fs11;
 var init_bashExecutor = __esm({
   "src/agent/bashExecutor.js"() {
     "use strict";
     import_child_process7 = require("child_process");
-    import_path12 = require("path");
+    import_path13 = require("path");
     import_fs11 = require("fs");
     init_bashCommandUtils();
   }
 });
 
 // src/tools/bash.js
-var import_ai2, import_path13, bashTool;
+var import_ai2, import_path14, bashTool;
 var init_bash = __esm({
   "src/tools/bash.js"() {
     "use strict";
     import_ai2 = require("ai");
-    import_path13 = require("path");
+    import_path14 = require("path");
     init_bashPermissions();
     init_bashExecutor();
     init_path_validation();
@@ -106231,12 +107263,12 @@ For code exploration, try these safe alternatives:
 - npm list, pip list for package information`;
             }
             const defaultDir = getDefaultWorkingDirectory();
-            const workingDir = workingDirectory ? (0, import_path13.isAbsolute)(workingDirectory) ? (0, import_path13.resolve)(workingDirectory) : (0, import_path13.resolve)(defaultDir, workingDirectory) : defaultDir;
+            const workingDir = workingDirectory ? (0, import_path14.isAbsolute)(workingDirectory) ? (0, import_path14.resolve)(workingDirectory) : (0, import_path14.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_path13.sep);
+                return resolvedWorkingDir === resolvedFolder || resolvedWorkingDir.startsWith(resolvedFolder + import_path14.sep);
               });
               if (!isAllowed) {
                 const relativeDir = toRelativePath(workingDir, workspaceRoot);
@@ -106591,6 +107623,7 @@ ${lastError}
 
 RULES REMINDER:
 - search(query) is KEYWORD SEARCH \u2014 pass a search query, NOT a filename. Use extract(filepath) to read file contents.
+- search(query, path) \u2014 the path argument must be a STRING, not an object. Use field.file_path, not field.
 - search() returns up to 20K tokens by default. Use search(query, path, {maxTokens: null}) for unlimited, or searchAll(query) to auto-paginate ALL results.
 - search(), searchAll(), query(), extract(), listFiles(), bash() all return STRINGS, not arrays.
 - Use chunk(stringData) to split a string into an array of chunks.
@@ -106599,7 +107632,8 @@ RULES REMINDER:
 - Do NOT define helper functions that call tools \u2014 write logic inline.
 - Do NOT use async/await, template literals, or shorthand properties.
 - Do NOT use regex literals (/pattern/) \u2014 use String methods like indexOf, includes, startsWith instead.
-- String concatenation with +, not template literals.`;
+- String concatenation with +, not template literals.
+- IMPORTANT: If a tool returns "ERROR: ...", do NOT pass that error string to LLM() \u2014 handle or skip it.`;
               const fixedCode = await llmCallFn(fixPrompt, "", { maxTokens: 4e3, temperature: 0.2 });
               currentCode = stripCodeWrapping(fixedCode);
               planSpan?.addEvent?.("dsl.self_heal_complete", {
@@ -107213,7 +108247,7 @@ var init_executePlan = __esm({
     init_query();
     init_extract();
     init_delegate();
-    init_esm5();
+    init_esm7();
     init_bash();
     RAW_OUTPUT_START = "<<<RAW_OUTPUT>>>";
     RAW_OUTPUT_END = "<<<END_RAW_OUTPUT>>>";
@@ -107221,13 +108255,13 @@ var init_executePlan = __esm({
 });
 
 // src/agent/mcp/built-in-server.js
-var import_http, import_events2, import_crypto5, import_server, import_sse2, import_streamableHttp, import_types3, InMemoryEventStore, BuiltInMCPServer;
+var import_http, import_events2, import_crypto6, import_server, import_sse2, import_streamableHttp, import_types3, InMemoryEventStore, BuiltInMCPServer;
 var init_built_in_server = __esm({
   "src/agent/mcp/built-in-server.js"() {
     "use strict";
     import_http = require("http");
     import_events2 = require("events");
-    import_crypto5 = require("crypto");
+    import_crypto6 = require("crypto");
     import_server = require("@modelcontextprotocol/sdk/server/index.js");
     import_sse2 = require("@modelcontextprotocol/sdk/server/sse.js");
     import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
@@ -107303,7 +108337,7 @@ var init_built_in_server = __esm({
           }
         });
         this.registerHandlers();
-        return new Promise((resolve7, reject2) => {
+        return new Promise((resolve8, reject2) => {
           this.httpServer.listen(this.port, this.host, async () => {
             const address = this.httpServer.address();
             this.port = address.port;
@@ -107313,7 +108347,7 @@ var init_built_in_server = __esm({
               console.log(`[MCP] Messages endpoint: http://${this.host}:${this.port}/messages`);
             }
             this.emit("ready", { host: this.host, port: this.port });
-            resolve7({ host: this.host, port: this.port });
+            resolve8({ host: this.host, port: this.port });
           });
           this.httpServer.on("error", reject2);
         });
@@ -107471,7 +108505,7 @@ var init_built_in_server = __esm({
             }
             const eventStore = new InMemoryEventStore();
             transport = new import_streamableHttp.StreamableHTTPServerTransport({
-              sessionIdGenerator: () => (0, import_crypto5.randomUUID)(),
+              sessionIdGenerator: () => (0, import_crypto6.randomUUID)(),
               eventStore,
               // Enable resumability
               onsessioninitialized: (newSessionId) => {
@@ -107532,7 +108566,7 @@ var init_built_in_server = __esm({
        * Parse request body as JSON
        */
       async parseRequestBody(req) {
-        return new Promise((resolve7, reject2) => {
+        return new Promise((resolve8, reject2) => {
           let body = "";
           req.on("data", (chunk) => {
             body += chunk.toString();
@@ -107540,7 +108574,7 @@ var init_built_in_server = __esm({
           req.on("end", () => {
             try {
               const parsed = body ? JSON.parse(body) : null;
-              resolve7(parsed);
+              resolve8(parsed);
             } catch (error2) {
               reject2(error2);
             }
@@ -107847,12 +108881,12 @@ data: ${JSON.stringify(data3)}
         }
         this.connections.clear();
         if (this.httpServer) {
-          return new Promise((resolve7) => {
+          return new Promise((resolve8) => {
             this.httpServer.close(() => {
               if (this.debug) {
                 console.log("[MCP] Built-in server stopped");
               }
-              resolve7();
+              resolve8();
             });
           });
         }
@@ -107934,7 +108968,7 @@ __export(enhanced_claude_code_exports, {
 async function createEnhancedClaudeCLIEngine(options = {}) {
   const { agent, systemPrompt, customPrompt, debug, sessionId, allowedTools, timeout = 12e4 } = options;
   const session = new Session(
-    sessionId || (0, import_crypto6.randomBytes)(8).toString("hex"),
+    sessionId || (0, import_crypto7.randomBytes)(8).toString("hex"),
     debug
   );
   let mcpServer = null;
@@ -107951,12 +108985,12 @@ async function createEnhancedClaudeCLIEngine(options = {}) {
       console.log("[DEBUG] Built-in MCP server started");
       console.log("[DEBUG] MCP URL:", `http://${host}:${port}/mcp`);
     }
-    mcpConfigPath = import_path14.default.join(import_os5.default.tmpdir(), `probe-mcp-${session.id}.json`);
+    mcpConfigPath = import_path15.default.join(import_os5.default.tmpdir(), `probe-mcp-${session.id}.json`);
     const mcpConfig = {
       mcpServers: {
         probe: {
           command: "node",
-          args: [import_path14.default.join(process.cwd(), "mcp-probe-server.js")],
+          args: [import_path15.default.join(process.cwd(), "mcp-probe-server.js")],
           env: {
             PROBE_WORKSPACE: process.cwd(),
             DEBUG: debug ? "true" : "false"
@@ -108181,8 +109215,8 @@ ${opts.schema}`;
             break;
           }
         } else if (!processEnded) {
-          await new Promise((resolve7) => {
-            resolver = resolve7;
+          await new Promise((resolve8) => {
+            resolver = resolve8;
           });
         }
       }
@@ -108381,14 +109415,14 @@ function combinePrompts(systemPrompt, customPrompt, agent) {
   }
   return systemPrompt || "";
 }
-var import_child_process8, import_crypto6, import_promises5, import_path14, import_os5, import_events3;
+var import_child_process8, import_crypto7, import_promises5, import_path15, import_os5, import_events3;
 var init_enhanced_claude_code = __esm({
   "src/agent/engines/enhanced-claude-code.js"() {
     "use strict";
     import_child_process8 = require("child_process");
-    import_crypto6 = require("crypto");
+    import_crypto7 = require("crypto");
     import_promises5 = __toESM(require("fs/promises"), 1);
-    import_path14 = __toESM(require("path"), 1);
+    import_path15 = __toESM(require("path"), 1);
     import_os5 = __toESM(require("os"), 1);
     import_events3 = require("events");
     init_built_in_server();
@@ -108404,7 +109438,7 @@ __export(codex_exports, {
 async function createCodexEngine(options = {}) {
   const { agent, systemPrompt, customPrompt, debug, sessionId, allowedTools, model } = options;
   const session = new Session(
-    sessionId || (0, import_crypto7.randomBytes)(8).toString("hex"),
+    sessionId || (0, import_crypto8.randomBytes)(8).toString("hex"),
     debug
   );
   let mcpServer = null;
@@ -108446,12 +109480,12 @@ async function createCodexEngine(options = {}) {
         }
       }
       if (message.id !== void 0 && pendingRequests.has(message.id)) {
-        const { resolve: resolve7, reject: reject2 } = pendingRequests.get(message.id);
+        const { resolve: resolve8, reject: reject2 } = pendingRequests.get(message.id);
         pendingRequests.delete(message.id);
         if (message.error) {
           reject2(new Error(message.error.message || JSON.stringify(message.error)));
         } else {
-          resolve7(message.result);
+          resolve8(message.result);
         }
       }
       if (message.method === "codex/event" && message.params) {
@@ -108472,7 +109506,7 @@ async function createCodexEngine(options = {}) {
     });
   }
   function sendRequest(method, params = {}) {
-    return new Promise((resolve7, reject2) => {
+    return new Promise((resolve8, reject2) => {
       const id = ++requestId;
       const request = {
         jsonrpc: "2.0",
@@ -108480,7 +109514,7 @@ async function createCodexEngine(options = {}) {
         method,
         params
       };
-      pendingRequests.set(id, { resolve: resolve7, reject: reject2 });
+      pendingRequests.set(id, { resolve: resolve8, reject: reject2 });
       setTimeout(() => {
         if (pendingRequests.has(id)) {
           pendingRequests.delete(id);
@@ -108543,7 +109577,7 @@ ${prompt}`;
         const reqId = requestId + 1;
         let fullResponse = "";
         let gotSessionId = false;
-        const eventPromise = new Promise((resolve7) => {
+        const eventPromise = new Promise((resolve8) => {
           eventHandlers.set(reqId, (eventParams) => {
             const msg = eventParams.msg;
             if (msg.type === "session_configured" && msg.session_id && !gotSessionId) {
@@ -108563,7 +109597,7 @@ ${prompt}`;
           });
           setTimeout(() => {
             eventHandlers.delete(reqId);
-            resolve7();
+            resolve8();
           }, 6e5);
         });
         const resultPromise = sendRequest("tools/call", {
@@ -108659,12 +109693,12 @@ function combinePrompts2(systemPrompt, customPrompt, agent) {
   }
   return systemPrompt || "";
 }
-var import_child_process9, import_crypto7, import_readline;
+var import_child_process9, import_crypto8, import_readline;
 var init_codex = __esm({
   "src/agent/engines/codex.js"() {
     "use strict";
     import_child_process9 = require("child_process");
-    import_crypto7 = require("crypto");
+    import_crypto8 = require("crypto");
     import_readline = require("readline");
     init_built_in_server();
     init_Session();
@@ -108769,7 +109803,7 @@ Your content here
 
 Do NOT wrap in other tags like <api_call>, <tool_name>, <function>, etc.`;
 }
-var import_dotenv, import_anthropic2, import_openai2, import_google2, import_ai5, import_crypto8, import_events4, import_fs12, import_promises6, import_path15, ENGINE_ACTIVITY_TIMEOUT_DEFAULT, ENGINE_ACTIVITY_TIMEOUT_MIN, ENGINE_ACTIVITY_TIMEOUT_MAX, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
+var import_dotenv, import_anthropic2, import_openai2, import_google2, import_ai5, import_crypto9, import_events4, import_fs12, import_promises6, import_path16, ENGINE_ACTIVITY_TIMEOUT_DEFAULT, ENGINE_ACTIVITY_TIMEOUT_MIN, ENGINE_ACTIVITY_TIMEOUT_MAX, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
     "use strict";
@@ -108779,17 +109813,18 @@ var init_ProbeAgent = __esm({
     import_google2 = require("@ai-sdk/google");
     init_dist3();
     import_ai5 = require("ai");
-    import_crypto8 = require("crypto");
+    import_crypto9 = require("crypto");
     import_events4 = require("events");
     import_fs12 = require("fs");
     import_promises6 = require("fs/promises");
-    import_path15 = require("path");
+    import_path16 = require("path");
     init_tokenCounter();
     init_InMemoryStorageAdapter();
     init_HookManager();
     init_imageConfig();
     init_tools();
     init_common2();
+    init_fileTracker();
     init_probeTool();
     init_mockProvider();
     init_index();
@@ -108831,7 +109866,7 @@ var init_ProbeAgent = __esm({
        * @param {string} [options.customPrompt] - Custom prompt to replace the default system message
        * @param {string} [options.systemPrompt] - Alias for customPrompt; takes precedence when both are provided
        * @param {string} [options.promptType] - Predefined prompt type (code-explorer, code-searcher, architect, code-review, support)
-       * @param {boolean} [options.allowEdit=false] - Allow the use of the 'implement' tool
+       * @param {boolean} [options.allowEdit=false] - Allow the use of the 'edit' and 'create' tools
        * @param {boolean} [options.enableDelegate=false] - Enable the delegate tool for task distribution to subagents
        * @param {boolean} [options.enableExecutePlan=false] - Enable the execute_plan DSL orchestration tool
        * @param {string} [options.architectureFileName] - Architecture context filename to embed from repo root (defaults to AGENTS.md with CLAUDE.md fallback; ARCHITECTURE.md is always included when present)
@@ -108876,10 +109911,11 @@ var init_ProbeAgent = __esm({
        * @param {number} [options.maxOperationTimeout] - Maximum timeout in ms for the entire operation including all retries and fallbacks (default: 300000 or MAX_OPERATION_TIMEOUT env var). This is the absolute maximum time for streamTextWithRetryAndFallback.
        */
       constructor(options = {}) {
-        this.sessionId = options.sessionId || (0, import_crypto8.randomUUID)();
+        this.sessionId = options.sessionId || (0, import_crypto9.randomUUID)();
         this.customPrompt = options.systemPrompt || options.customPrompt || null;
         this.promptType = options.promptType || "code-explorer";
         this.allowEdit = !!options.allowEdit;
+        this.hashLines = options.hashLines !== void 0 ? !!options.hashLines : this.allowEdit;
         this.enableDelegate = !!options.enableDelegate;
         this.enableExecutePlan = !!options.enableExecutePlan;
         this.debug = options.debug || process.env.DEBUG === "1";
@@ -108941,7 +109977,8 @@ var init_ProbeAgent = __esm({
         if (this.debug) {
           console.log(`[DEBUG] Generated session ID for agent: ${this.sessionId}`);
           console.log(`[DEBUG] Maximum tool iterations configured: ${MAX_TOOL_ITERATIONS}`);
-          console.log(`[DEBUG] Allow Edit (implement tool): ${this.allowEdit}`);
+          console.log(`[DEBUG] Allow Edit: ${this.allowEdit}`);
+          console.log(`[DEBUG] Hash Lines: ${this.hashLines}`);
           console.log(`[DEBUG] Search delegation enabled: ${this.searchDelegate}`);
           console.log(`[DEBUG] Workspace root: ${this.workspaceRoot}`);
           console.log(`[DEBUG] Working directory (cwd): ${this.cwd}`);
@@ -109326,9 +110363,12 @@ var init_ProbeAgent = __esm({
           cwd: this.cwd,
           workspaceRoot: this.workspaceRoot,
           allowedFolders: this.allowedFolders,
+          // File state tracking for safe multi-edit workflows (only when editing is enabled)
+          fileTracker: this.allowEdit ? new FileTracker({ debug: this.debug }) : null,
           outline: this.outline,
           searchDelegate: this.searchDelegate,
           allowEdit: this.allowEdit,
+          hashLines: this.hashLines,
           enableDelegate: this.enableDelegate,
           enableExecutePlan: this.enableExecutePlan,
           enableBash: this.enableBash,
@@ -109399,7 +110439,7 @@ var init_ProbeAgent = __esm({
               if (!imagePath) {
                 throw new Error("Image path is required");
               }
-              const filename = (0, import_path15.basename)(imagePath);
+              const filename = (0, import_path16.basename)(imagePath);
               const extension = filename.toLowerCase().split(".").pop();
               if (!extension || !SUPPORTED_IMAGE_EXTENSIONS.includes(extension)) {
                 throw new Error(`Invalid or unsupported image extension: ${extension}. Supported formats: ${SUPPORTED_IMAGE_EXTENSIONS.join(", ")}`);
@@ -110113,7 +111153,7 @@ var init_ProbeAgent = __esm({
           let resolvedPath2 = imagePath;
           if (!imagePath.includes("/") && !imagePath.includes("\\")) {
             for (const dir of listFilesDirectories) {
-              const potentialPath = (0, import_path15.resolve)(dir, imagePath);
+              const potentialPath = (0, import_path16.resolve)(dir, imagePath);
               const loaded = await this.loadImageIfValid(potentialPath);
               if (loaded) {
                 if (this.debug) {
@@ -110138,7 +111178,7 @@ var init_ProbeAgent = __esm({
         let match2;
         while ((match2 = fileHeaderPattern.exec(content)) !== null) {
           const filePath = match2[1].trim();
-          const dir = (0, import_path15.dirname)(filePath);
+          const dir = (0, import_path16.dirname)(filePath);
           if (dir && dir !== ".") {
             directories.push(dir);
             if (this.debug) {
@@ -110183,17 +111223,17 @@ var init_ProbeAgent = __esm({
           const allowedDirs = this.allowedFolders && this.allowedFolders.length > 0 ? this.allowedFolders : [process.cwd()];
           let absolutePath;
           let isPathAllowed2 = false;
-          if ((0, import_path15.isAbsolute)(imagePath)) {
-            absolutePath = safeRealpath((0, import_path15.resolve)(imagePath));
+          if ((0, import_path16.isAbsolute)(imagePath)) {
+            absolutePath = safeRealpath((0, import_path16.resolve)(imagePath));
             isPathAllowed2 = allowedDirs.some((dir) => {
               const resolvedDir = safeRealpath(dir);
-              return absolutePath === resolvedDir || absolutePath.startsWith(resolvedDir + import_path15.sep);
+              return absolutePath === resolvedDir || absolutePath.startsWith(resolvedDir + import_path16.sep);
             });
           } else {
             for (const dir of allowedDirs) {
               const resolvedDir = safeRealpath(dir);
-              const resolvedPath2 = safeRealpath((0, import_path15.resolve)(dir, imagePath));
-              if (resolvedPath2 === resolvedDir || resolvedPath2.startsWith(resolvedDir + import_path15.sep)) {
+              const resolvedPath2 = safeRealpath((0, import_path16.resolve)(dir, imagePath));
+              if (resolvedPath2 === resolvedDir || resolvedPath2.startsWith(resolvedDir + import_path16.sep)) {
                 absolutePath = resolvedPath2;
                 isPathAllowed2 = true;
                 break;
@@ -110381,8 +111421,8 @@ var init_ProbeAgent = __esm({
         const hasConfiguredName = !!configuredName;
         let guidanceCandidates = [];
         if (hasConfiguredName) {
-          const targetName = (0, import_path15.basename)(configuredName);
-          if (configuredName !== targetName || configuredName.includes("/") || configuredName.includes("\\") || configuredName.includes("..") || (0, import_path15.isAbsolute)(configuredName)) {
+          const targetName = (0, import_path16.basename)(configuredName);
+          if (configuredName !== targetName || configuredName.includes("/") || configuredName.includes("\\") || configuredName.includes("..") || (0, import_path16.isAbsolute)(configuredName)) {
             console.warn(`[WARN] Invalid architectureFileName (must be a simple filename): ${configuredName}`);
           } else if (targetName) {
             const targetLower = targetName.toLowerCase();
@@ -110449,7 +111489,7 @@ var init_ProbeAgent = __esm({
         pushEntry(architectureMatch);
         const contexts = [];
         for (const entry of uniqueEntries) {
-          const filePath = (0, import_path15.resolve)(rootDirectory, entry.name);
+          const filePath = (0, import_path16.resolve)(rootDirectory, entry.name);
           try {
             const content = await (0, import_promises6.readFile)(filePath, "utf8");
             let kind = "other";
@@ -110514,10 +111554,10 @@ ${this.architectureContext.content}
       }
       _getSkillsRepoRoot() {
         if (this.workspaceRoot) {
-          return (0, import_path15.resolve)(this.workspaceRoot);
+          return (0, import_path16.resolve)(this.workspaceRoot);
         }
         if (this.allowedFolders && this.allowedFolders.length > 0) {
-          return (0, import_path15.resolve)(this.allowedFolders[0]);
+          return (0, import_path16.resolve)(this.allowedFolders[0]);
         }
         return process.cwd();
       }
@@ -110706,10 +111746,6 @@ Workspace: ${this.allowedFolders.join(", ")}`;
         }
         if (isToolAllowed("readImage")) {
           toolDefinitions += `${readImageToolDefinition}
-`;
-        }
-        if (this.allowEdit && isToolAllowed("implement")) {
-          toolDefinitions += `${implementToolDefinition}
 `;
         }
         if (this.allowEdit && isToolAllowed("edit")) {
@@ -110791,7 +111827,7 @@ The configuration is loaded from src/config.js lines 15-25 which contains the da
           availableToolsList += "- query: Search code using structural AST patterns.\n";
         }
         if (isToolAllowed("extract")) {
-          availableToolsList += "- extract: Extract specific code blocks or lines from files.\n";
+          availableToolsList += '- extract: Extract specific code blocks or lines from files. Use with symbol targets (e.g. "file.js#funcName") to get line numbers for line-targeted editing.\n';
         }
         if (isToolAllowed("listFiles")) {
           availableToolsList += "- listFiles: List files and directories in a specified location.\n";
@@ -110808,11 +111844,8 @@ The configuration is loaded from src/config.js lines 15-25 which contains the da
         if (isToolAllowed("readImage")) {
           availableToolsList += "- readImage: Read and load an image file for AI analysis.\n";
         }
-        if (this.allowEdit && isToolAllowed("implement")) {
-          availableToolsList += "- implement: Implement a feature or fix a bug using aider.\n";
-        }
         if (this.allowEdit && isToolAllowed("edit")) {
-          availableToolsList += "- edit: Edit files using exact string replacement.\n";
+          availableToolsList += "- edit: Edit files using text replacement, AST-aware symbol operations, or line-targeted editing.\n";
         }
         if (this.allowEdit && isToolAllowed("create")) {
           availableToolsList += "- create: Create new files with specified content.\n";
@@ -110900,8 +111933,14 @@ Follow these instructions carefully:
 8. Once the task is fully completed, use the '<attempt_completion>' tool to provide the final result. This is the ONLY way to signal completion.
 9. Prefer concise and focused search queries. Use specific keywords and phrases to narrow down results.${this.allowEdit ? `
 10. When modifying files, choose the appropriate tool:
-    - Use 'edit' for precise changes to existing files (requires exact string match)
-    - Use 'create' for new files or complete file rewrites` : ""}
+    - Use 'edit' for all code modifications:
+      * For small changes (a line or a few lines), use old_string + new_string \u2014 copy old_string verbatim from the file.
+      * For rewriting entire functions/classes/methods, use the symbol parameter instead (no exact text matching needed).
+      * For editing specific lines from search/extract output, use start_line (and optionally end_line) with the line numbers shown in the output.${this.hashLines ? ' Line references include content hashes (e.g. "42:ab") for integrity verification.' : ""}
+      * For editing inside large functions: first use extract with the symbol target (e.g. "file.js#myFunction") to see the function with line numbers${this.hashLines ? " and hashes" : ""}, then use start_line/end_line to surgically edit specific lines within it.
+    - Use 'create' for new files or complete file rewrites.
+    - If an edit fails, read the error message \u2014 it tells you exactly how to fix the call and retry.
+    - The system tracks which files you've seen via search/extract. If you try to edit a file you haven't read, or one that changed since you last read it, the edit will fail with instructions to re-read first. Always use extract before editing to ensure you have current file content.` : ""}
 </instructions>
 `;
         let systemMessage = "";
@@ -111401,8 +112440,11 @@ You are working with a workspace. Available paths: ${workspaceDesc}
               if (this.enableSkills && this.allowedTools.isEnabled("useSkill")) validTools.push("useSkill");
               if (this.allowedTools.isEnabled("readImage")) validTools.push("readImage");
               validTools.push("attempt_completion");
-              if (this.allowEdit && this.allowedTools.isEnabled("implement")) {
-                validTools.push("implement", "edit", "create");
+              if (this.allowEdit && this.allowedTools.isEnabled("edit")) {
+                validTools.push("edit");
+              }
+              if (this.allowEdit && this.allowedTools.isEnabled("create")) {
+                validTools.push("create");
               }
               if (this.enableBash && this.allowedTools.isEnabled("bash")) {
                 validTools.push("bash");
@@ -111624,10 +112666,10 @@ ${errorXml}
                   try {
                     let resolvedWorkingDirectory = this.workspaceRoot || this.cwd || this.allowedFolders && this.allowedFolders[0] || process.cwd();
                     if (params.workingDirectory) {
-                      const requestedDir = safeRealpath((0, import_path15.isAbsolute)(params.workingDirectory) ? (0, import_path15.resolve)(params.workingDirectory) : (0, import_path15.resolve)(resolvedWorkingDirectory, params.workingDirectory));
+                      const requestedDir = safeRealpath((0, import_path16.isAbsolute)(params.workingDirectory) ? (0, import_path16.resolve)(params.workingDirectory) : (0, import_path16.resolve)(resolvedWorkingDirectory, params.workingDirectory));
                       const isWithinAllowed = !this.allowedFolders || this.allowedFolders.length === 0 || this.allowedFolders.some((folder) => {
                         const resolvedFolder = safeRealpath(folder);
-                        return requestedDir === resolvedFolder || requestedDir.startsWith(resolvedFolder + import_path15.sep);
+                        return requestedDir === resolvedFolder || requestedDir.startsWith(resolvedFolder + import_path16.sep);
                       });
                       if (isWithinAllowed) {
                         resolvedWorkingDirectory = requestedDir;
@@ -111695,6 +112737,8 @@ ${errorXml}
                           // Inherit bash enablement
                           bashConfig: this.bashConfig,
                           // Inherit bash configuration
+                          allowEdit: this.allowEdit,
+                          // Inherit edit/create permission
                           allowedTools: allowedToolsForDelegate,
                           // Inherit allowed tools from parent
                           debug: this.debug,
@@ -111767,7 +112811,7 @@ ${errorXml}
                     currentMessages.push({ role: "assistant", content: assistantResponseContent });
                     let toolResultContent = typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult, null, 2);
                     if (this.workspaceRoot && toolResultContent) {
-                      const wsPrefix = this.workspaceRoot.endsWith(import_path15.sep) ? this.workspaceRoot : this.workspaceRoot + import_path15.sep;
+                      const wsPrefix = this.workspaceRoot.endsWith(import_path16.sep) ? this.workspaceRoot : this.workspaceRoot + import_path16.sep;
                       toolResultContent = toolResultContent.split(wsPrefix).join("");
                     }
                     const { cleanedContent, extractedBlocks } = extractRawOutputBlocks(toolResultContent);
@@ -111855,6 +112899,25 @@ ${errorXml}
                 }
                 break;
               }
+              if (options.schema) {
+                let contentToCheck = assistantResponseContent;
+                contentToCheck = contentToCheck.replace(/<thinking>[\s\S]*?<\/thinking>/gi, "").trim();
+                contentToCheck = contentToCheck.replace(/<thinking>[\s\S]*$/gi, "").trim();
+                const cleanedJson = cleanSchemaResponse(contentToCheck);
+                try {
+                  JSON.parse(cleanedJson);
+                  const validation = validateJsonResponse(cleanedJson, { debug: this.debug, schema: options.schema });
+                  if (validation.isValid) {
+                    if (this.debug) {
+                      console.log(`[DEBUG] Issue #443: Accepting valid JSON response without attempt_completion (${cleanedJson.length} chars)`);
+                    }
+                    finalResult = cleanedJson;
+                    completionAttempted = true;
+                    break;
+                  }
+                } catch {
+                }
+              }
               consecutiveNoToolCount++;
               const isIdentical = lastNoToolResponse !== null && assistantResponseContent === lastNoToolResponse;
               const isSemanticallyStuck = lastNoToolResponse !== null && areBothStuckResponses(lastNoToolResponse, assistantResponseContent);
@@ -112598,7 +113661,7 @@ Convert your previous response content into actual JSON data that follows this s
        */
       clone(options = {}) {
         const {
-          sessionId = (0, import_crypto8.randomUUID)(),
+          sessionId = (0, import_crypto9.randomUUID)(),
           stripInternalMessages = true,
           keepSystemMessage = true,
           deepCopy = true,
@@ -112831,6 +113894,7 @@ async function delegate({
   model = null,
   enableBash = false,
   bashConfig = null,
+  allowEdit = false,
   architectureFileName = null,
   promptType = "code-researcher",
   allowedTools = null,
@@ -112863,7 +113927,7 @@ async function delegate({
     }
   }
   const manager = delegationManager || defaultDelegationManager;
-  const sessionId = (0, import_crypto9.randomUUID)();
+  const sessionId = (0, import_crypto10.randomUUID)();
   const startTime = Date.now();
   const remainingIterations = Math.max(1, maxIterations - currentIteration);
   const delegationSpan = typeof tracer?.createDelegationSpan === "function" ? tracer.createDelegationSpan(sessionId, task) : null;
@@ -112910,6 +113974,8 @@ async function delegate({
       // Inherit from parent
       bashConfig,
       // Inherit from parent
+      allowEdit,
+      // Inherit from parent
       architectureFileName,
       allowedTools,
       disableTools,
@@ -113014,11 +114080,11 @@ async function delegate({
     throw new Error(`Delegation failed: ${error2.message}`);
   }
 }
-var import_crypto9, DelegationManager, defaultDelegationManager, DEFAULT_DELEGATE_TIMEOUT;
+var import_crypto10, DelegationManager, defaultDelegationManager, DEFAULT_DELEGATE_TIMEOUT;
 var init_delegate = __esm({
   "src/delegate.js"() {
     "use strict";
-    import_crypto9 = require("crypto");
+    import_crypto10 = require("crypto");
     init_ProbeAgent();
     DelegationManager = class {
       constructor(options = {}) {
@@ -113095,7 +114161,7 @@ var init_delegate = __esm({
         if (debug) {
           console.error(`[DelegationManager] Slot unavailable (${this.globalActive}/${this.maxConcurrent}), queuing... (queue size: ${this.waitQueue.length}, timeout: ${effectiveTimeout}ms)`);
         }
-        return new Promise((resolve7, reject2) => {
+        return new Promise((resolve8, reject2) => {
           const entry = {
             resolve: null,
             // Will be wrapped below
@@ -113111,7 +114177,7 @@ var init_delegate = __esm({
             if (settled) return;
             settled = true;
             if (entry.timeoutId) clearTimeout(entry.timeoutId);
-            resolve7(value);
+            resolve8(value);
           };
           entry.reject = (error2) => {
             if (settled) return;
@@ -113161,7 +114227,7 @@ var init_delegate = __esm({
         while (this.waitQueue.length > 0 && this.globalActive < this.maxConcurrent) {
           const next = this.waitQueue.shift();
           if (!next) break;
-          const { resolve: resolve7, reject: reject2, parentSessionId, queuedAt } = next;
+          const { resolve: resolve8, reject: reject2, parentSessionId, queuedAt } = next;
           if (parentSessionId) {
             const sessionData = this.sessionDelegations.get(parentSessionId);
             const sessionCount = sessionData?.count || 0;
@@ -113178,12 +114244,12 @@ var init_delegate = __esm({
             const waitTime = Date.now() - queuedAt;
             console.error(`[DelegationManager] Granted slot from queue (waited ${waitTime}ms). Active: ${this.globalActive}/${this.maxConcurrent}`);
           }
-          toResolve.push(resolve7);
+          toResolve.push(resolve8);
         }
         if (toResolve.length > 0 || toReject.length > 0) {
           setImmediate(() => {
-            for (const resolve7 of toResolve) {
-              resolve7(true);
+            for (const resolve8 of toResolve) {
+              resolve8(true);
             }
             for (const { reject: reject2, error: error2 } of toReject) {
               reject2(error2);
@@ -113829,6 +114895,7 @@ var init_vercel = __esm({
     init_analyzeAll();
     init_common2();
     init_error_types();
+    init_hashline();
     CODE_SEARCH_SCHEMA = {
       type: "object",
       properties: {
@@ -113847,8 +114914,15 @@ var init_vercel = __esm({
         maxTokens = 2e4,
         debug = false,
         outline = false,
-        searchDelegate = false
+        searchDelegate = false,
+        hashLines = false
       } = options;
+      const maybeAnnotate = (result) => {
+        if (hashLines && typeof result === "string") {
+          return annotateOutputWithHashes(result);
+        }
+        return result;
+      };
       return (0, import_ai6.tool)({
         name: "search",
         description: searchDelegate ? `${searchDescription} (delegates code search to a subagent and returns extracted code blocks)` : searchDescription,
@@ -113890,7 +114964,12 @@ var init_vercel = __esm({
           };
           if (!searchDelegate) {
             try {
-              return await runRawSearch();
+              const result = maybeAnnotate(await runRawSearch());
+              if (options.fileTracker && typeof result === "string") {
+                options.fileTracker.trackFilesFromOutput(result, options.cwd || ".").catch(() => {
+                });
+              }
+              return result;
             } catch (error2) {
               console.error("Error executing search command:", error2);
               return formatErrorForAI(error2);
@@ -113933,7 +115012,12 @@ var init_vercel = __esm({
               if (debug) {
                 console.error("Delegated search returned no targets; falling back to raw search");
               }
-              return await runRawSearch();
+              const fallbackResult = maybeAnnotate(await runRawSearch());
+              if (options.fileTracker && typeof fallbackResult === "string") {
+                options.fileTracker.trackFilesFromOutput(fallbackResult, options.cwd || ".").catch(() => {
+                });
+              }
+              return fallbackResult;
             }
             const resolutionBase = searchPaths[0] || options.cwd || ".";
             const resolvedTargets = targets.map((target) => resolveTargetPath(target, resolutionBase));
@@ -113948,13 +115032,18 @@ var init_vercel = __esm({
             const extractResult = await extract(extractOptions);
             if (resolutionBase && typeof extractResult === "string") {
               const wsPrefix = resolutionBase.endsWith("/") ? resolutionBase : resolutionBase + "/";
-              return extractResult.split(wsPrefix).join("");
+              return maybeAnnotate(extractResult.split(wsPrefix).join(""));
             }
-            return extractResult;
+            return maybeAnnotate(extractResult);
           } catch (error2) {
             console.error("Delegated search failed, falling back to raw search:", error2);
             try {
-              return await runRawSearch();
+              const fallbackResult2 = maybeAnnotate(await runRawSearch());
+              if (options.fileTracker && typeof fallbackResult2 === "string") {
+                options.fileTracker.trackFilesFromOutput(fallbackResult2, options.cwd || ".").catch(() => {
+                });
+              }
+              return fallbackResult2;
             } catch (fallbackError) {
               console.error("Error executing search command:", fallbackError);
               return formatErrorForAI(fallbackError);
@@ -114000,7 +115089,7 @@ var init_vercel = __esm({
       });
     };
     extractTool = (options = {}) => {
-      const { debug = false, outline = false } = options;
+      const { debug = false, outline = false, hashLines = false } = options;
       return (0, import_ai6.tool)({
         name: "extract",
         description: extractDescription,
@@ -114017,6 +115106,7 @@ var init_vercel = __esm({
             }
             let tempFilePath = null;
             let extractOptions = { cwd: effectiveCwd };
+            let extractFiles = null;
             if (input_content) {
               const { writeFileSync: writeFileSync2, unlinkSync } = await import("fs");
               const { join: join5 } = await import("path");
@@ -114040,13 +115130,13 @@ var init_vercel = __esm({
               };
             } else if (targets) {
               const parsedTargets = parseTargets(targets);
-              const files = parsedTargets.map((target) => resolveTargetPath(target, effectiveCwd));
+              extractFiles = parsedTargets.map((target) => resolveTargetPath(target, effectiveCwd));
               let effectiveFormat = format2;
               if (outline && format2 === "outline-xml") {
                 effectiveFormat = "xml";
               }
               extractOptions = {
-                files,
+                files: extractFiles,
                 cwd: effectiveCwd,
                 allowTests: allow_tests ?? true,
                 contextLines: context_lines,
@@ -114056,6 +115146,10 @@ var init_vercel = __esm({
               throw new Error("Either targets or input_content must be provided");
             }
             const results = await extract(extractOptions);
+            if (options.fileTracker && extractFiles && extractFiles.length > 0) {
+              options.fileTracker.trackFilesFromExtract(extractFiles, effectiveCwd).catch(() => {
+              });
+            }
             if (tempFilePath) {
               const { unlinkSync } = await import("fs");
               try {
@@ -114067,6 +115161,9 @@ var init_vercel = __esm({
                 console.error(`Warning: Failed to remove temporary file: ${cleanupError.message}`);
               }
             }
+            if (hashLines && typeof results === "string") {
+              return annotateOutputWithHashes(results);
+            }
             return results;
           } catch (error2) {
             console.error("Error executing extract command:", error2);
@@ -114493,7 +115590,7 @@ async function listFilesByLevel(options) {
   if (!import_fs13.default.existsSync(directory)) {
     throw new Error(`Directory does not exist: ${directory}`);
   }
-  const gitDirExists = import_fs13.default.existsSync(import_path16.default.join(directory, ".git"));
+  const gitDirExists = import_fs13.default.existsSync(import_path17.default.join(directory, ".git"));
   if (gitDirExists && respectGitignore) {
     try {
       return await listFilesUsingGit(directory, maxFiles);
@@ -114508,8 +115605,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((a5, b5) => {
-    const depthA = a5.split(import_path16.default.sep).length;
-    const depthB = b5.split(import_path16.default.sep).length;
+    const depthA = a5.split(import_path17.default.sep).length;
+    const depthB = b5.split(import_path17.default.sep).length;
     return depthA - depthB;
   });
   return sortedFiles.slice(0, maxFiles);
@@ -114526,23 +115623,23 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
     try {
       const entries = import_fs13.default.readdirSync(dir, { withFileTypes: true });
       const files = entries.filter((entry) => {
-        const fullPath = import_path16.default.join(dir, entry.name);
+        const fullPath = import_path17.default.join(dir, entry.name);
         return getEntryTypeSync(entry, fullPath).isFile;
       });
       for (const file of files) {
         if (result.length >= maxFiles) break;
-        const filePath = import_path16.default.join(dir, file.name);
-        const relativePath = import_path16.default.relative(directory, filePath);
+        const filePath = import_path17.default.join(dir, file.name);
+        const relativePath = import_path17.default.relative(directory, filePath);
         if (shouldIgnore(relativePath, ignorePatterns)) continue;
         result.push(relativePath);
       }
       const dirs = entries.filter((entry) => {
-        const fullPath = import_path16.default.join(dir, entry.name);
+        const fullPath = import_path17.default.join(dir, entry.name);
         return getEntryTypeSync(entry, fullPath).isDirectory;
       });
       for (const subdir of dirs) {
-        const subdirPath = import_path16.default.join(dir, subdir.name);
-        const relativeSubdirPath = import_path16.default.relative(directory, subdirPath);
+        const subdirPath = import_path17.default.join(dir, subdir.name);
+        const relativeSubdirPath = import_path17.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 });
@@ -114554,7 +115651,7 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   return result;
 }
 function loadGitignorePatterns(directory) {
-  const gitignorePath = import_path16.default.join(directory, ".gitignore");
+  const gitignorePath = import_path17.default.join(directory, ".gitignore");
   if (!import_fs13.default.existsSync(gitignorePath)) {
     return [];
   }
@@ -114577,12 +115674,12 @@ function shouldIgnore(filePath, ignorePatterns) {
   }
   return false;
 }
-var import_fs13, import_path16, import_util12, import_child_process10, execAsync3;
+var import_fs13, import_path17, import_util12, import_child_process10, execAsync3;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
     import_fs13 = __toESM(require("fs"), 1);
-    import_path16 = __toESM(require("path"), 1);
+    import_path17 = __toESM(require("path"), 1);
     import_util12 = require("util");
     import_child_process10 = require("child_process");
     init_symlink_utils();
@@ -114600,12 +115697,12 @@ function initializeSimpleTelemetryFromOptions(options) {
   });
   return telemetry;
 }
-var import_fs14, import_path17, SimpleTelemetry, SimpleAppTracer;
+var import_fs14, import_path18, SimpleTelemetry, SimpleAppTracer;
 var init_simpleTelemetry = __esm({
   "src/agent/simpleTelemetry.js"() {
     "use strict";
     import_fs14 = require("fs");
-    import_path17 = require("path");
+    import_path18 = require("path");
     SimpleTelemetry = class {
       constructor(options = {}) {
         this.serviceName = options.serviceName || "probe-agent";
@@ -114619,7 +115716,7 @@ var init_simpleTelemetry = __esm({
       }
       initializeFileExporter() {
         try {
-          const dir = (0, import_path17.dirname)(this.filePath);
+          const dir = (0, import_path18.dirname)(this.filePath);
           if (!(0, import_fs14.existsSync)(dir)) {
             (0, import_fs14.mkdirSync)(dir, { recursive: true });
           }
@@ -114684,20 +115781,20 @@ var init_simpleTelemetry = __esm({
       }
       async flush() {
         if (this.stream) {
-          return new Promise((resolve7) => {
-            this.stream.once("drain", resolve7);
+          return new Promise((resolve8) => {
+            this.stream.once("drain", resolve8);
             if (!this.stream.writableNeedDrain) {
-              resolve7();
+              resolve8();
             }
           });
         }
       }
       async shutdown() {
         if (this.stream) {
-          return new Promise((resolve7) => {
+          return new Promise((resolve8) => {
             this.stream.end(() => {
               console.log(`[SimpleTelemetry] File stream closed: ${this.filePath}`);
-              resolve7();
+              resolve8();
             });
           });
         }
@@ -115056,6 +116153,7 @@ var init_hooks = __esm({
 var index_exports = {};
 __export(index_exports, {
   DEFAULT_SYSTEM_MESSAGE: () => DEFAULT_SYSTEM_MESSAGE,
+  FileTracker: () => FileTracker,
   HOOK_TYPES: () => HOOK_TYPES,
   HookManager: () => HookManager,
   InMemoryStorageAdapter: () => InMemoryStorageAdapter,
@@ -115136,6 +116234,7 @@ var init_index = __esm({
     init_executePlan();
     init_bash();
     init_edit();
+    init_fileTracker();
     init_ProbeAgent();
     init_simpleTelemetry();
     init_probeTool();
@@ -115149,6 +116248,7 @@ init_index();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_SYSTEM_MESSAGE,
+  FileTracker,
   HOOK_TYPES,
   HookManager,
   InMemoryStorageAdapter,