@probelabs/probe 0.6.0-rc253 → 0.6.0-rc255

package/build/agent/index.js

@@ -2377,7 +2377,7 @@ async function waitForFileLock(lockPath, binaryPath) {
       }
     } catch {
     }
-    await new Promise((resolve8) => setTimeout(resolve8, LOCK_POLL_INTERVAL_MS));
+    await new Promise((resolve9) => setTimeout(resolve9, LOCK_POLL_INTERVAL_MS));
   }
   if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
     console.log(`Timeout waiting for file lock`);
@@ -3718,7 +3718,7 @@ Cwd: ${cwd}`;
   }
 }
 function extractWithStdin(binaryPath, cliArgs, content, options, cwd) {
-  return new Promise((resolve8, reject2) => {
+  return new Promise((resolve9, reject2) => {
     const childProcess = spawn(binaryPath, ["extract", ...cliArgs], {
       stdio: ["pipe", "pipe", "pipe"],
       cwd
@@ -3741,7 +3741,7 @@ function extractWithStdin(binaryPath, cliArgs, content, options, cwd) {
       }
       try {
         const result = processExtractOutput(stdout, options);
-        resolve8(result);
+        resolve9(result);
       } catch (error) {
         reject2(error);
       }
@@ -3849,6 +3849,7 @@ async function delegate({
   model = null,
   enableBash = false,
   bashConfig = null,
+  allowEdit = false,
   architectureFileName = null,
   promptType = "code-researcher",
   allowedTools = null,
@@ -3928,6 +3929,8 @@ async function delegate({
       // Inherit from parent
       bashConfig,
       // Inherit from parent
+      allowEdit,
+      // Inherit from parent
       architectureFileName,
       allowedTools,
       disableTools,
@@ -4112,7 +4115,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((resolve8, reject2) => {
+        return new Promise((resolve9, reject2) => {
           const entry = {
             resolve: null,
             // Will be wrapped below
@@ -4128,7 +4131,7 @@ var init_delegate = __esm({
             if (settled) return;
             settled = true;
             if (entry.timeoutId) clearTimeout(entry.timeoutId);
-            resolve8(value);
+            resolve9(value);
           };
           entry.reject = (error) => {
             if (settled) return;
@@ -4178,7 +4181,7 @@ var init_delegate = __esm({
         while (this.waitQueue.length > 0 && this.globalActive < this.maxConcurrent) {
           const next = this.waitQueue.shift();
           if (!next) break;
-          const { resolve: resolve8, reject: reject2, parentSessionId, queuedAt } = next;
+          const { resolve: resolve9, reject: reject2, parentSessionId, queuedAt } = next;
           if (parentSessionId) {
             const sessionData = this.sessionDelegations.get(parentSessionId);
             const sessionCount = sessionData?.count || 0;
@@ -4195,12 +4198,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(resolve8);
+          toResolve.push(resolve9);
         }
         if (toResolve.length > 0 || toReject.length > 0) {
           setImmediate(() => {
-            for (const resolve8 of toResolve) {
-              resolve8(true);
+            for (const resolve9 of toResolve) {
+              resolve9(true);
             }
             for (const { reject: reject2, error } of toReject) {
               reject2(error);
@@ -8835,6 +8838,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 i = 0; i <= contentLines.length - windowSize; i++) {
+    let allMatch = true;
+    for (let j = 0; j < windowSize; j++) {
+      if (contentLines[i + j].trim() !== trimmedSearchLines[j]) {
+        allMatch = false;
+        break;
+      }
+    }
+    if (allMatch) {
+      const matchedText = contentLines.slice(i, i + 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 i = 0;
+  while (i < str.length) {
+    const ch = str[i];
+    if (ch === " " || ch === "	") {
+      normalized.push(" ");
+      indexMap.push(i);
+      while (i < str.length && (str[i] === " " || str[i] === "	")) {
+        i++;
+      }
+    } else {
+      normalized.push(ch);
+      indexMap.push(i);
+      i++;
+    }
+  }
+  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 i = 0; i <= contentLines.length - windowSize; i++) {
+    const windowLines = contentLines.slice(i, i + windowSize);
+    const windowMinIndent = getMinIndent(windowLines);
+    const strippedWindow = windowLines.map((line) => stripIndent(line, windowMinIndent));
+    let allMatch = true;
+    for (let j = 0; j < windowSize; j++) {
+      if (strippedWindow[j] !== strippedSearch[j]) {
+        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 (error) {
+    if (process.env.DEBUG === "1") {
+      console.error(`[SymbolEdit] findSymbol error for "${symbolName}" in ${filePath}: ${error.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 (error) {
+    if (process.env.DEBUG === "1") {
+      console.error(`[SymbolEdit] findAllSymbols error for "${symbolName}" in ${filePath}: ${error.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 h = 5381;
+  for (let i = 0; i < stripped.length; i++) {
+    h = (h << 5) + h + stripped.charCodeAt(i) & 4294967295;
+  }
+  return ((h >>> 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((l) => l.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((l) => prefixPattern.test(l)).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
 import { tool } from "ai";
 import { promises as fs6 } from "fs";
@@ -8862,29 +9259,204 @@ function parseFileToolOptions(options = {}) {
     workspaceRoot: options.workspaceRoot || options.cwd || allowedFolders.length > 0 && allowedFolders[0] || process.cwd()
   };
 }
+async function handleSymbolEdit({ resolvedPath, file_path, symbol, new_string, position, debug, cwd, fileTracker }) {
+  if (typeof symbol !== "string" || symbol.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(resolvedPath, symbol, cwd || process.cwd());
+  if (allMatches.length === 0) {
+    return `Error editing file: Symbol "${symbol}" 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(
+      (m) => `  - ${m.qualifiedName} (${m.nodeType}, line ${m.startLine})`
+    ).join("\n");
+    return `Error editing ${file_path}: Found ${allMatches.length} symbols named "${symbol}". 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(resolvedPath, symbol, symbolInfo.code);
+    if (!check.ok && check.reason === "stale") {
+      return `Error editing ${file_path}: Symbol "${symbol}" has changed since you last read it. Use extract to re-read the current content, then retry.
+
+Example: <extract><targets>${file_path}#${symbol}</targets></extract>`;
+    }
+  }
+  const content = await fs6.readFile(resolvedPath, "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 fs6.writeFile(resolvedPath, lines.join("\n"), "utf-8");
+    if (fileTracker) {
+      const updated = await findSymbol(resolvedPath, symbol, cwd || process.cwd());
+      if (updated) {
+        fileTracker.trackSymbolAfterWrite(resolvedPath, symbol, updated.code, updated.startLine, updated.endLine);
+      }
+      fileTracker.markFileSeen(resolvedPath);
+    }
+    const insertLine = position === "after" ? symbolInfo.endLine + 1 : symbolInfo.startLine;
+    if (debug) {
+      console.error(`[Edit] Successfully inserted ${newLines.length} lines ${position} "${symbol}" at line ${insertLine} in ${resolvedPath}`);
+    }
+    return `Successfully inserted ${newLines.length} lines ${position} symbol "${symbol}" 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 fs6.writeFile(resolvedPath, lines.join("\n"), "utf-8");
+    if (fileTracker) {
+      const updated = await findSymbol(resolvedPath, symbol, cwd || process.cwd());
+      if (updated) {
+        fileTracker.trackSymbolAfterWrite(resolvedPath, symbol, updated.code, updated.startLine, updated.endLine);
+      }
+      fileTracker.markFileSeen(resolvedPath);
+    }
+    if (debug) {
+      console.error(`[Edit] Successfully replaced symbol "${symbol}" in ${resolvedPath} (lines ${symbolInfo.startLine}-${symbolInfo.endLine})`);
+    }
+    return `Successfully replaced symbol "${symbol}" 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 i = contextStart; i < contextEnd; i++) {
+    const lineNum = i + 1;
+    const hash = computeLineHash(updatedLines[i]);
+    const isNew = i >= insertOffset && i < insertOffset + newLineCount;
+    const marker = isNew ? ">" : " ";
+    context += `${marker} ${lineNum}:${hash} | ${updatedLines[i]}
+`;
+  }
+  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, 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 fs6.readFile(resolvedPath, "utf-8");
+  const fileLines = content.split("\n");
+  if (startLine > fileLines.length) {
+    return `Error editing file: Line ${startLine} is beyond file length (${fileLines.length} lines). Use 'extract' to read the current file content.`;
+  }
+  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 fs6.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
+    if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath);
+    const action = `${newLines.length} line${newLines.length !== 1 ? "s" : ""} inserted after line ${startLine}`;
+    return buildLineEditResponse(file_path, startLine, startLine, newLines.length, fileLines, startLine, action, modifications);
+  } else if (position === "before") {
+    fileLines.splice(startLine - 1, 0, ...newLines);
+    await fs6.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
+    if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath);
+    const action = `${newLines.length} line${newLines.length !== 1 ? "s" : ""} inserted before line ${startLine}`;
+    return buildLineEditResponse(file_path, startLine, startLine, newLines.length, fileLines, startLine - 1, action, modifications);
+  } else {
+    const replacedCount = endLine - startLine + 1;
+    fileLines.splice(startLine - 1, replacedCount, ...newLines);
+    await fs6.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
+    if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath);
+    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 editTool, createTool, editSchema, createSchema, editDescription, createDescription, editToolDefinition, createToolDefinition;
 var init_edit = __esm({
   "src/tools/edit.js"() {
     "use strict";
     init_path_validation();
+    init_fuzzyMatch();
+    init_symbolEdit();
+    init_hashline();
+    init_lineEditHeuristics();
     editTool = (options = {}) => {
       const { debug, allowedFolders, cwd, workspaceRoot } = parseFileToolOptions(options);
       return 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: {
@@ -8894,30 +9466,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, 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 resolvedPath = isAbsolute(file_path) ? file_path : resolve(cwd || process.cwd(), file_path);
             if (debug) {
@@ -8925,34 +9511,64 @@ Important:
             }
             if (!isPathAllowed(resolvedPath, allowedFolders)) {
               const relativePath = toRelativePath(resolvedPath, 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 (!existsSync(resolvedPath)) {
-              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(resolvedPath)) {
+              const displayPath = toRelativePath(resolvedPath, 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 (symbol !== void 0 && symbol !== null) {
+              return await handleSymbolEdit({ resolvedPath, file_path, symbol, new_string, position, debug, cwd, fileTracker: options.fileTracker });
+            }
+            if (start_line !== void 0 && start_line !== null) {
+              return await handleLineEdit({ resolvedPath, 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 fs6.readFile(resolvedPath, "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 fs6.writeFile(resolvedPath, newContent, "utf-8");
+            if (options.fileTracker) await options.fileTracker.trackFileAfterWrite(resolvedPath);
             const replacedCount = replace_all ? occurrences : 1;
             if (debug) {
               console.error(`[Edit] Successfully edited ${resolvedPath}, 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 (error) {
             console.error("[Edit] Error:", error);
             return `Error editing file: ${error.message}`;
@@ -8999,10 +9615,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 resolvedPath = isAbsolute(file_path) ? file_path : resolve(cwd || process.cwd(), file_path);
             if (debug) {
@@ -9010,15 +9626,17 @@ Important:
             }
             if (!isPathAllowed(resolvedPath, allowedFolders)) {
               const relativePath = toRelativePath(resolvedPath, 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 (existsSync(resolvedPath) && !overwrite) {
               return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
             }
+            const existed = existsSync(resolvedPath);
             const dir = dirname(resolvedPath);
             await fs6.mkdir(dir, { recursive: true });
             await fs6.writeFile(resolvedPath, content, "utf-8");
-            const action = existsSync(resolvedPath) && overwrite ? "overwrote" : "created";
+            if (options.fileTracker) await options.fileTracker.trackFileAfterWrite(resolvedPath);
+            const action = existed && overwrite ? "overwrote" : "created";
             const bytes = Buffer.byteLength(content, "utf-8");
             if (debug) {
               console.error(`[Create] Successfully ${action} ${resolvedPath}`);
@@ -9040,18 +9658,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",
@@ -9071,50 +9706,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
@@ -9652,7 +10360,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"];
@@ -9773,7 +10481,6 @@ function detectUnrecognizedToolCall(xmlString, validTools) {
     "listSkills",
     "useSkill",
     "readImage",
-    "implement",
     "edit",
     "create",
     "delegate",
@@ -10147,6 +10854,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
@@ -10302,7 +11011,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.";
     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.';
     DEFAULT_VALID_TOOLS = [
@@ -10317,7 +11026,6 @@ Capabilities:
       "useSkill",
       "listFiles",
       "searchFiles",
-      "implement",
       "bash",
       "task",
       "attempt_completion"
@@ -10442,6 +11150,7 @@ var init_vercel = __esm({
     init_analyzeAll();
     init_common();
     init_error_types();
+    init_hashline();
     CODE_SEARCH_SCHEMA = {
       type: "object",
       properties: {
@@ -10460,8 +11169,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 tool2({
         name: "search",
         description: searchDelegate ? `${searchDescription} (delegates code search to a subagent and returns extracted code blocks)` : searchDescription,
@@ -10503,7 +11219,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 (error) {
               console.error("Error executing search command:", error);
               return formatErrorForAI(error);
@@ -10546,7 +11267,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));
@@ -10561,13 +11287,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 (error) {
             console.error("Delegated search failed, falling back to raw search:", error);
             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);
@@ -10613,7 +11344,7 @@ var init_vercel = __esm({
       });
     };
     extractTool = (options = {}) => {
-      const { debug = false, outline = false } = options;
+      const { debug = false, outline = false, hashLines = false } = options;
       return tool2({
         name: "extract",
         description: extractDescription,
@@ -10630,6 +11361,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");
@@ -10653,13 +11385,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 = format;
               if (outline && format === "outline-xml") {
                 effectiveFormat = "xml";
               }
               extractOptions = {
-                files,
+                files: extractFiles,
                 cwd: effectiveCwd,
                 allowTests: allow_tests ?? true,
                 contextLines: context_lines,
@@ -10669,6 +11401,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 {
@@ -10680,6 +11416,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 (error) {
             console.error("Error executing extract command:", error);
@@ -12030,7 +12769,7 @@ async function executeBashCommand(command, options = {}) {
     console.log(`[BashExecutor] Working directory: "${cwd}"`);
     console.log(`[BashExecutor] Timeout: ${timeout}ms`);
   }
-  return new Promise((resolve8, reject2) => {
+  return new Promise((resolve9, reject2) => {
     const processEnv = {
       ...process.env,
       ...env
@@ -12047,7 +12786,7 @@ async function executeBashCommand(command, options = {}) {
     } else {
       const args = parseCommandForExecution(command);
       if (!args || args.length === 0) {
-        resolve8({
+        resolve9({
           success: false,
           error: "Failed to parse command",
           stdout: "",
@@ -12132,7 +12871,7 @@ async function executeBashCommand(command, options = {}) {
         success = false;
         error = `Command exited with code ${code}`;
       }
-      resolve8({
+      resolve9({
         success,
         error,
         stdout: stdout.trim(),
@@ -12152,7 +12891,7 @@ async function executeBashCommand(command, options = {}) {
       if (debug) {
         console.log(`[BashExecutor] Spawn error:`, error);
       }
-      resolve8({
+      resolve9({
         success: false,
         error: `Failed to execute command: ${error.message}`,
         stdout: "",
@@ -13560,14 +14299,14 @@ var require_executor = __commonJS({
     function asyncDone(callback) {
       let isInstant = false;
       let instant;
-      const p = new Promise((resolve8, reject2) => {
+      const p = new Promise((resolve9, reject2) => {
         callback((err, result) => {
           if (err)
             reject2(err);
           else {
             isInstant = true;
             instant = result;
-            resolve8({ result });
+            resolve9({ result });
           }
         });
       });
@@ -13590,10 +14329,10 @@ var require_executor = __commonJS({
     }
     async function execAsync4(ticks, tree, scope, context, doneOriginal, inLoopOrSwitch) {
       let done = doneOriginal;
-      const p = new Promise((resolve8) => {
+      const p = new Promise((resolve9) => {
         done = (e, r) => {
           doneOriginal(e, r);
-          resolve8();
+          resolve9();
         };
       });
       if (!_execNoneRecurse(ticks, tree, scope, context, done, true, inLoopOrSwitch) && utils.isLisp(tree)) {
@@ -21944,6 +22683,13 @@ function generateSandboxGlobals(options) {
           if (i < keys2.length) params[keys2[i]] = 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?.(`[${name}] 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 ${name}: ${validated.error.message}`);
@@ -21980,6 +22726,11 @@ function generateSandboxGlobals(options) {
   }
   if (llmCall) {
     const rawLLM = async (instruction, data2, opts = {}) => {
+      const dataStr = typeof data2 === "string" ? data2 : JSON.stringify(data2);
+      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, data2, opts);
       if (opts.schema && typeof result === "string") {
         try {
@@ -22345,33 +23096,31 @@ var init_runtime = __esm({
   }
 });
 
-// node_modules/balanced-match/index.js
-var require_balanced_match = __commonJS({
-  "node_modules/balanced-match/index.js"(exports2, module2) {
-    "use strict";
-    module2.exports = balanced;
-    function balanced(a, b, str) {
-      if (a instanceof RegExp) a = maybeMatch(a, str);
-      if (b instanceof RegExp) b = maybeMatch(b, str);
-      var r = range(a, b, str);
+// node_modules/balanced-match/dist/esm/index.js
+var balanced, maybeMatch, range;
+var init_esm = __esm({
+  "node_modules/balanced-match/dist/esm/index.js"() {
+    balanced = (a, b, str) => {
+      const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+      const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+      const r = ma !== null && mb != null && range(ma, mb, str);
       return r && {
         start: r[0],
         end: r[1],
         pre: str.slice(0, r[0]),
-        body: str.slice(r[0] + a.length, r[1]),
-        post: str.slice(r[1] + b.length)
+        body: str.slice(r[0] + ma.length, r[1]),
+        post: str.slice(r[1] + mb.length)
       };
-    }
-    function maybeMatch(reg, str) {
-      var m = str.match(reg);
+    };
+    maybeMatch = (reg, str) => {
+      const m = str.match(reg);
       return m ? m[0] : null;
-    }
-    balanced.range = range;
-    function range(a, b, str) {
-      var begs, beg, left, right, result;
-      var ai = str.indexOf(a);
-      var bi = str.indexOf(b, ai + 1);
-      var i = ai;
+    };
+    range = (a, b, str) => {
+      let begs, beg, left, right = void 0, result;
+      let ai = str.indexOf(a);
+      let bi = str.indexOf(b, ai + 1);
+      let i = ai;
       if (ai >= 0 && bi > 0) {
         if (a === b) {
           return [ai, bi];
@@ -22379,14 +23128,16 @@ var require_balanced_match = __commonJS({
         begs = [];
         left = str.length;
         while (i >= 0 && !result) {
-          if (i == ai) {
+          if (i === ai) {
             begs.push(i);
             ai = str.indexOf(a, i + 1);
-          } else if (begs.length == 1) {
-            result = [begs.pop(), bi];
+          } else if (begs.length === 1) {
+            const r = begs.pop();
+            if (r !== void 0)
+              result = [r, bi];
           } else {
             beg = begs.pop();
-            if (beg < left) {
+            if (beg !== void 0 && beg < left) {
               left = beg;
               right = bi;
             }
@@ -22394,163 +23145,179 @@ var require_balanced_match = __commonJS({
           }
           i = 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 m = balanced("{", "}", str);
-      if (!m)
-        return str.split(",");
-      var pre = m.pre;
-      var body = m.body;
-      var post = m.post;
-      var p = pre.split(",");
-      p[p.length - 1] += "{" + body + "}";
-      var postParts = parseCommaParts(post);
-      if (post.length) {
-        p[p.length - 1] += postParts.shift();
-        p.push.apply(p, postParts);
-      }
-      parts.push.apply(parts, p);
-      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(i, y) {
-      return i <= y;
-    }
-    function gte(i, y) {
-      return i >= y;
+// 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 m = balanced("{", "}", str);
+  if (!m) {
+    return str.split(",");
+  }
+  const { pre, body, post } = m;
+  const p = pre.split(",");
+  p[p.length - 1] += "{" + body + "}";
+  const postParts = parseCommaParts(post);
+  if (post.length) {
+    ;
+    p[p.length - 1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+  parts.push.apply(parts, p);
+  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(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
+function expand_(str, max, isTop) {
+  const expansions = [];
+  const m = balanced("{", "}", str);
+  if (!m)
+    return [str];
+  const pre = m.pre;
+  const post = m.post.length ? expand_(m.post, max, false) : [""];
+  if (/\$$/.test(m.pre)) {
+    for (let k = 0; k < post.length && k < max; k++) {
+      const expansion = pre + "{" + m.body + "}" + post[k];
+      expansions.push(expansion);
     }
-    function expand2(str, isTop) {
-      var expansions = [];
-      var m = balanced("{", "}", str);
-      if (!m) return [str];
-      var pre = m.pre;
-      var post = m.post.length ? expand2(m.post, false) : [""];
-      if (/\$$/.test(m.pre)) {
-        for (var k = 0; k < post.length; k++) {
-          var expansion = pre + "{" + m.body + "}" + post[k];
-          expansions.push(expansion);
-        }
-      } else {
-        var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-        var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-        var isSequence = isNumericSequence || isAlphaSequence;
-        var isOptions = m.body.indexOf(",") >= 0;
-        if (!isSequence && !isOptions) {
-          if (m.post.match(/,(?!,).*\}/)) {
-            str = m.pre + "{" + m.body + escClose + m.post;
-            return expand2(str);
-          }
-          return [str];
-        }
-        var n;
-        if (isSequence) {
-          n = m.body.split(/\.\./);
-        } else {
-          n = parseCommaParts(m.body);
-          if (n.length === 1) {
-            n = expand2(n[0], false).map(embrace);
-            if (n.length === 1) {
-              return post.map(function(p) {
-                return m.pre + n[0] + p;
-              });
-            }
+  } else {
+    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+    const isSequence = isNumericSequence || isAlphaSequence;
+    const isOptions = m.body.indexOf(",") >= 0;
+    if (!isSequence && !isOptions) {
+      if (m.post.match(/,(?!,).*\}/)) {
+        str = m.pre + "{" + m.body + escClose + m.post;
+        return expand_(str, max, true);
+      }
+      return [str];
+    }
+    let n;
+    if (isSequence) {
+      n = m.body.split(/\.\./);
+    } else {
+      n = parseCommaParts(m.body);
+      if (n.length === 1 && n[0] !== void 0) {
+        n = expand_(n[0], max, false).map(embrace);
+        if (n.length === 1) {
+          return post.map((p) => m.pre + n[0] + p);
+        }
+      }
+    }
+    let N;
+    if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
+      const x = numeric(n[0]);
+      const y = numeric(n[1]);
+      const width = Math.max(n[0].length, n[1].length);
+      let incr = n.length === 3 && n[2] !== void 0 ? Math.abs(numeric(n[2])) : 1;
+      let test = lte;
+      const reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      const pad = n.some(isPadded);
+      N = [];
+      for (let i = x; test(i, y); i += incr) {
+        let c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === "\\") {
+            c = "";
           }
-        }
-        var N;
-        if (isSequence) {
-          var x = numeric(n[0]);
-          var y = numeric(n[1]);
-          var width = Math.max(n[0].length, n[1].length);
-          var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
-          var test = lte;
-          var reverse = y < x;
-          if (reverse) {
-            incr *= -1;
-            test = gte;
-          }
-          var pad = n.some(isPadded);
-          N = [];
-          for (var i = x; test(i, y); i += incr) {
-            var c;
-            if (isAlphaSequence) {
-              c = String.fromCharCode(i);
-              if (c === "\\")
-                c = "";
-            } else {
-              c = String(i);
-              if (pad) {
-                var need = width - c.length;
-                if (need > 0) {
-                  var z = new Array(need + 1).join("0");
-                  if (i < 0)
-                    c = "-" + z + c.slice(1);
-                  else
-                    c = z + c;
-                }
+        } else {
+          c = String(i);
+          if (pad) {
+            const need = width - c.length;
+            if (need > 0) {
+              const z = new Array(need + 1).join("0");
+              if (i < 0) {
+                c = "-" + z + c.slice(1);
+              } else {
+                c = z + c;
               }
             }
-            N.push(c);
-          }
-        } else {
-          N = [];
-          for (var j = 0; j < n.length; j++) {
-            N.push.apply(N, expand2(n[j], false));
           }
         }
-        for (var j = 0; j < N.length; j++) {
-          for (var k = 0; k < post.length; k++) {
-            var expansion = pre + N[j] + post[k];
-            if (!isTop || isSequence || expansion)
-              expansions.push(expansion);
-          }
+        N.push(c);
+      }
+    } else {
+      N = [];
+      for (let j = 0; j < n.length; j++) {
+        N.push.apply(N, expand_(n[j], max, false));
+      }
+    }
+    for (let j = 0; j < N.length; j++) {
+      for (let k = 0; k < post.length && expansions.length < max; k++) {
+        const expansion = pre + N[j] + post[k];
+        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
@@ -23133,11 +23900,13 @@ var init_ast = __esm({
         let escaping = false;
         let re = "";
         let uflag = false;
+        let inStar = false;
         for (let i = 0; i < glob2.length; i++) {
           const c = glob2.charAt(i);
           if (escaping) {
             escaping = false;
             re += (reSpecials.has(c) ? "\\" : "") + c;
+            inStar = false;
             continue;
           }
           if (c === "\\") {
@@ -23155,16 +23924,19 @@ var init_ast = __esm({
               uflag = uflag || needUflag;
               i += consumed - 1;
               hasMagic2 = hasMagic2 || magic;
+              inStar = false;
               continue;
             }
           }
           if (c === "*") {
-            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 (c === "?") {
             re += qmark;
@@ -23190,10 +23962,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, sep3, 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, sep3, 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();
@@ -23316,7 +24088,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();
@@ -23922,7 +24694,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();
@@ -25299,7 +26071,7 @@ import { EventEmitter } from "node:events";
 import Stream from "node:stream";
 import { StringDecoder } from "node:string_decoder";
 var 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"() {
     proc = typeof process === "object" && process ? process : {
       stdout: null,
@@ -26026,10 +26798,10 @@ var init_esm3 = __esm({
        * Return a void Promise that resolves once the stream ends.
        */
       async promise() {
-        return new Promise((resolve8, reject2) => {
+        return new Promise((resolve9, reject2) => {
           this.on(DESTROYED, () => reject2(new Error("stream destroyed")));
           this.on("error", (er) => reject2(er));
-          this.on("end", () => resolve8());
+          this.on("end", () => resolve9());
         });
       }
       /**
@@ -26053,7 +26825,7 @@ var init_esm3 = __esm({
             return Promise.resolve({ done: false, value: res });
           if (this[EOF])
             return stop();
-          let resolve8;
+          let resolve9;
           let reject2;
           const onerr = (er) => {
             this.off("data", ondata);
@@ -26067,19 +26839,19 @@ var init_esm3 = __esm({
             this.off("end", onend);
             this.off(DESTROYED, ondestroy);
             this.pause();
-            resolve8({ value, done: !!this[EOF] });
+            resolve9({ value, done: !!this[EOF] });
           };
           const onend = () => {
             this.off("error", onerr);
             this.off("data", ondata);
             this.off(DESTROYED, ondestroy);
             stop();
-            resolve8({ done: true, value: void 0 });
+            resolve9({ done: true, value: void 0 });
           };
           const ondestroy = () => onerr(new Error("stream destroyed"));
           return new Promise((res2, rej) => {
             reject2 = rej;
-            resolve8 = res2;
+            resolve9 = res2;
             this.once(DESTROYED, ondestroy);
             this.once("error", onerr);
             this.once("end", onend);
@@ -26188,10 +26960,10 @@ import { lstatSync, readdir as readdirCB, readdirSync, readlinkSync, realpathSyn
 import * as actualFS from "node:fs";
 import { lstat, readdir, readlink, realpath } from "node:fs/promises";
 var 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_esm3();
+    init_esm4();
+    init_esm5();
     realpathSync2 = rps.native;
     defaultFS = {
       lstatSync,
@@ -27063,9 +27835,9 @@ var init_esm4 = __esm({
         if (this.#asyncReaddirInFlight) {
           await this.#asyncReaddirInFlight;
         } else {
-          let resolve8 = () => {
+          let resolve9 = () => {
           };
-          this.#asyncReaddirInFlight = new Promise((res) => resolve8 = res);
+          this.#asyncReaddirInFlight = new Promise((res) => resolve9 = res);
           try {
             for (const e of await this.#fs.promises.readdir(fullpath, {
               withFileTypes: true
@@ -27078,7 +27850,7 @@ var init_esm4 = __esm({
             children.provisional = 0;
           }
           this.#asyncReaddirInFlight = void 0;
-          resolve8();
+          resolve9();
         }
         return children.slice(0, children.provisional);
       }
@@ -27921,7 +28693,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 {
@@ -28092,7 +28864,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 {
@@ -28186,7 +28958,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()) {
@@ -28413,7 +29185,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;
@@ -28749,8 +29521,8 @@ import { fileURLToPath as fileURLToPath5 } from "node:url";
 var defaultPlatform3, Glob;
 var init_glob = __esm({
   "node_modules/glob/dist/esm/glob.js"() {
-    init_esm();
-    init_esm4();
+    init_esm3();
+    init_esm6();
     init_pattern();
     init_walker();
     defaultPlatform3 = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
@@ -28958,7 +29730,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];
@@ -28992,12 +29764,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();
@@ -29334,6 +30106,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.
@@ -29342,7 +30115,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", {
@@ -29955,7 +30729,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>>>";
@@ -30227,6 +31001,264 @@ var init_file_lister = __esm({
   }
 });
 
+// src/tools/fileTracker.js
+import { createHash as createHash2 } from "crypto";
+import { resolve as resolve5, isAbsolute as isAbsolute4 } from "path";
+function computeContentHash(content) {
+  const normalized = (content || "").split("\n").map((l) => l.trimEnd()).join("\n");
+  return createHash2("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 symbol = target.slice(hashIdx + 1);
+    return symbol || 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 FileTracker;
+var init_fileTracker = __esm({
+  "src/tools/fileTracker.js"() {
+    "use strict";
+    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(resolvedPath) {
+        this._seenFiles.add(resolvedPath);
+        if (this.debug) {
+          console.error(`[FileTracker] Marked as seen: ${resolvedPath}`);
+        }
+      }
+      /**
+       * Check if a file has been seen in this session.
+       * @param {string} resolvedPath - Absolute path to the file
+       * @returns {boolean}
+       */
+      isFileSeen(resolvedPath) {
+        return this._seenFiles.has(resolvedPath);
+      }
+      /**
+       * 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(resolvedPath, symbolName, code, startLine, endLine, source = "extract") {
+        const key = `${resolvedPath}#${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(resolvedPath, symbolName) {
+        return this._contentRecords.get(`${resolvedPath}#${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(resolvedPath, symbolName, currentCode) {
+        const key = `${resolvedPath}#${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 = isAbsolute4(filePath) ? filePath : resolve5(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 = isAbsolute4(filePath) ? filePath : resolve5(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(resolvedPath) {
+        if (!this._seenFiles.has(resolvedPath)) {
+          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(resolvedPath) {
+        this.markFileSeen(resolvedPath);
+        this.invalidateFileRecords(resolvedPath);
+      }
+      /**
+       * 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(resolvedPath, symbolName, code, startLine, endLine) {
+        this.trackSymbolContent(resolvedPath, 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(resolvedPath) {
+        const prefix = resolvedPath + "#";
+        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 ${resolvedPath}`);
+        }
+      }
+      /**
+       * Quick sync check if a file is being tracked (alias for isFileSeen).
+       * @param {string} resolvedPath - Absolute path to the file
+       * @returns {boolean}
+       */
+      isTracked(resolvedPath) {
+        return this.isFileSeen(resolvedPath);
+      }
+      /**
+       * Clear all tracking state.
+       */
+      clear() {
+        this._seenFiles.clear();
+        this._contentRecords.clear();
+      }
+    };
+  }
+});
+
 // src/agent/simpleTelemetry.js
 import { existsSync as existsSync3, mkdirSync, createWriteStream } from "fs";
 import { dirname as dirname2 } from "path";
@@ -30321,20 +31353,20 @@ var init_simpleTelemetry = __esm({
       }
       async flush() {
         if (this.stream) {
-          return new Promise((resolve8) => {
-            this.stream.once("drain", resolve8);
+          return new Promise((resolve9) => {
+            this.stream.once("drain", resolve9);
             if (!this.stream.writableNeedDrain) {
-              resolve8();
+              resolve9();
             }
           });
         }
       }
       async shutdown() {
         if (this.stream) {
-          return new Promise((resolve8) => {
+          return new Promise((resolve9) => {
             this.stream.end(() => {
               console.log(`[SimpleTelemetry] File stream closed: ${this.filePath}`);
-              resolve8();
+              resolve9();
             });
           });
         }
@@ -30779,7 +31811,7 @@ var init_probeTool = __esm({
   "src/agent/probeTool.js"() {
     "use strict";
     init_index();
-    init_esm5();
+    init_esm7();
     init_symlink_utils();
     toolCallEmitter = new EventEmitter2();
     activeToolExecutions = /* @__PURE__ */ new Map();
@@ -31517,6 +32549,7 @@ var init_index = __esm({
     init_executePlan();
     init_bash();
     init_edit();
+    init_fileTracker();
     init_ProbeAgent();
     init_simpleTelemetry();
     init_probeTool();
@@ -31699,38 +32732,13 @@ function parseXmlToolCallWithThinking(xmlString, validTools) {
   const toolCall = parseXmlToolCall(cleanedXmlString, validTools);
   return toolCall ? { ...toolCall, thinkingContent } : null;
 }
-var implementToolDefinition, listFilesToolDefinition, searchFilesToolDefinition, listSkillsToolDefinition, useSkillToolDefinition, readImageToolDefinition;
+var listFilesToolDefinition, searchFilesToolDefinition, listSkillsToolDefinition, useSkillToolDefinition, readImageToolDefinition;
 var init_tools2 = __esm({
   "src/agent/tools.js"() {
     "use strict";
     init_index();
     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.
@@ -31854,7 +32862,7 @@ function createMockProvider() {
       provider: "mock",
       // Mock the doGenerate method used by Vercel AI SDK
       doGenerate: async ({ messages, tools: tools2 }) => {
-        await new Promise((resolve8) => setTimeout(resolve8, 10));
+        await new Promise((resolve9) => setTimeout(resolve9, 10));
         return {
           text: "This is a mock response for testing",
           toolCalls: [],
@@ -37057,23 +38065,23 @@ var init_regexp_parser = __esm({
         return ASSERT_NEVER_REACH_HERE();
       }
       quantifier(isBacktracking = false) {
-        let range = void 0;
+        let range2 = void 0;
         const begin = this.idx;
         switch (this.popChar()) {
           case "*":
-            range = {
+            range2 = {
               atLeast: 0,
               atMost: Infinity
             };
             break;
           case "+":
-            range = {
+            range2 = {
               atLeast: 1,
               atMost: Infinity
             };
             break;
           case "?":
-            range = {
+            range2 = {
               atLeast: 0,
               atMost: 1
             };
@@ -37082,7 +38090,7 @@ var init_regexp_parser = __esm({
             const atLeast = this.integerIncludingZero();
             switch (this.popChar()) {
               case "}":
-                range = {
+                range2 = {
                   atLeast,
                   atMost: atLeast
                 };
@@ -37091,12 +38099,12 @@ var init_regexp_parser = __esm({
                 let atMost;
                 if (this.isDigit()) {
                   atMost = this.integerIncludingZero();
-                  range = {
+                  range2 = {
                     atLeast,
                     atMost
                   };
                 } else {
-                  range = {
+                  range2 = {
                     atLeast,
                     atMost: Infinity
                   };
@@ -37104,25 +38112,25 @@ var init_regexp_parser = __esm({
                 this.consumeChar("}");
                 break;
             }
-            if (isBacktracking === true && range === void 0) {
+            if (isBacktracking === true && range2 === void 0) {
               return void 0;
             }
-            ASSERT_EXISTS(range);
+            ASSERT_EXISTS(range2);
             break;
         }
-        if (isBacktracking === true && range === void 0) {
+        if (isBacktracking === true && range2 === void 0) {
           return void 0;
         }
-        if (ASSERT_EXISTS(range)) {
+        if (ASSERT_EXISTS(range2)) {
           if (this.peekChar(0) === "?") {
             this.consumeChar("?");
-            range.greedy = false;
+            range2.greedy = false;
           } else {
-            range.greedy = true;
+            range2.greedy = true;
           }
-          range.type = "Quantifier";
-          range.loc = this.loc(begin);
-          return range;
+          range2.type = "Quantifier";
+          range2.loc = this.loc(begin);
+          return range2;
         }
       }
       atom() {
@@ -37824,18 +38832,18 @@ function firstCharOptimizedIndices(ast, result, ignoreCase) {
               if (typeof code === "number") {
                 addOptimizedIdxToResult(code, result, ignoreCase);
               } else {
-                const range = code;
+                const range2 = code;
                 if (ignoreCase === true) {
-                  for (let rangeCode = range.from; rangeCode <= range.to; rangeCode++) {
+                  for (let rangeCode = range2.from; rangeCode <= range2.to; rangeCode++) {
                     addOptimizedIdxToResult(rangeCode, result, ignoreCase);
                   }
                 } else {
-                  for (let rangeCode = range.from; rangeCode <= range.to && rangeCode < minOptimizationVal; rangeCode++) {
+                  for (let rangeCode = range2.from; rangeCode <= range2.to && rangeCode < minOptimizationVal; rangeCode++) {
                     addOptimizedIdxToResult(rangeCode, result, ignoreCase);
                   }
-                  if (range.to >= minOptimizationVal) {
-                    const minUnOptVal = range.from >= minOptimizationVal ? range.from : minOptimizationVal;
-                    const maxUnOptVal = range.to;
+                  if (range2.to >= minOptimizationVal) {
+                    const minUnOptVal = range2.from >= minOptimizationVal ? range2.from : minOptimizationVal;
+                    const maxUnOptVal = range2.to;
                     const minOptIdx = charCodeToOptimizedIndex(minUnOptVal);
                     const maxOptIdx = charCodeToOptimizedIndex(maxUnOptVal);
                     for (let currOptIdx = minOptIdx; currOptIdx <= maxOptIdx; currOptIdx++) {
@@ -37896,8 +38904,8 @@ function findCode(setNode, targetCharCodes) {
     if (typeof codeOrRange === "number") {
       return includes_default(targetCharCodes, codeOrRange);
     } else {
-      const range = codeOrRange;
-      return find_default(targetCharCodes, (targetCode) => range.from <= targetCode && targetCode <= range.to) !== void 0;
+      const range2 = codeOrRange;
+      return find_default(targetCharCodes, (targetCode) => range2.from <= targetCode && targetCode <= range2.to) !== void 0;
     }
   });
 }
@@ -55802,8 +56810,8 @@ var require_createRange = __commonJS({
 var require_range = __commonJS({
   "node_modules/lodash/range.js"(exports2, module2) {
     var createRange = require_createRange();
-    var range = createRange();
-    module2.exports = range;
+    var range2 = createRange();
+    module2.exports = range2;
   }
 });
 
@@ -65044,7 +66052,7 @@ var require_compile = __commonJS({
       const schOrFunc = root2.refs[ref2];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve8.call(this, root2, ref2);
+      let _sch = resolve9.call(this, root2, ref2);
       if (_sch === void 0) {
         const schema = (_a = root2.localRefs) === null || _a === void 0 ? void 0 : _a[ref2];
         const { schemaId } = this.opts;
@@ -65071,7 +66079,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve8(root2, ref2) {
+    function resolve9(root2, ref2) {
       let sch;
       while (typeof (sch = this.refs[ref2]) == "string")
         ref2 = sch;
@@ -65646,7 +66654,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve8(baseURI, relativeURI, options) {
+    function resolve9(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;
@@ -65873,7 +66881,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize: normalize3,
-      resolve: resolve8,
+      resolve: resolve9,
       resolveComponent,
       equal,
       serialize,
@@ -68566,6 +69574,7 @@ __export(schemaUtils_exports, {
   processSchemaResponse: () => processSchemaResponse,
   replaceMermaidDiagramsInJson: () => replaceMermaidDiagramsInJson,
   replaceMermaidDiagramsInMarkdown: () => replaceMermaidDiagramsInMarkdown,
+  sanitizeMarkdownEscapesInJson: () => sanitizeMarkdownEscapesInJson,
   tryAutoWrapForSimpleSchema: () => tryAutoWrapForSimpleSchema,
   tryMaidAutoFix: () => tryMaidAutoFix,
   validateAndFixMermaidResponse: () => validateAndFixMermaidResponse,
@@ -68669,6 +69678,17 @@ function decodeHtmlEntities2(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;
@@ -68721,6 +69741,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());
@@ -68788,9 +69817,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`);
@@ -69132,7 +70177,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) {
@@ -76084,7 +77143,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 } = token.type === "block-scalar" ? resolveBlockScalar.resolveBlockScalar(ctx, token, onError) : resolveFlowScalar.resolveFlowScalar(token, ctx.options.strict, onError);
+      const { value, type, comment, range: range2 } = 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 tag;
       if (ctx.options.stringKeys && ctx.atKey) {
@@ -76104,7 +77163,7 @@ var require_compose_scalar = __commonJS({
         onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg);
         scalar = new Scalar.Scalar(value);
       }
-      scalar.range = range;
+      scalar.range = range2;
       scalar.source = value;
       if (type)
         scalar.type = type;
@@ -78716,14 +79775,14 @@ var init_parser7 = __esm({
 // src/agent/skills/registry.js
 import { existsSync as existsSync5 } from "fs";
 import { readdir as readdir2, readFile as readFile2, realpath as realpath2, lstat as lstat2 } from "fs/promises";
-import { resolve as resolve5, join as join3, isAbsolute as isAbsolute4, sep as sep4, relative } from "path";
+import { resolve as resolve6, join as join3, isAbsolute as isAbsolute5, sep as sep4, relative } from "path";
 function isPathInside(basePath, targetPath) {
-  const base2 = resolve5(basePath);
-  const target = resolve5(targetPath);
+  const base2 = resolve6(basePath);
+  const target = resolve6(targetPath);
   const rel = relative(base2, target);
   if (rel === "") return true;
   if (rel === ".." || rel.startsWith(`..${sep4}`)) return false;
-  if (isAbsolute4(rel)) return false;
+  if (isAbsolute5(rel)) return false;
   return true;
 }
 function isSafeEntryName(name) {
@@ -78740,7 +79799,7 @@ var init_registry = __esm({
     SKILL_FILE_NAME = "SKILL.md";
     SkillRegistry = class {
       constructor({ repoRoot, skillDirs = DEFAULT_SKILL_DIRS, debug = false } = {}) {
-        this.repoRoot = repoRoot ? resolve5(repoRoot) : process.cwd();
+        this.repoRoot = repoRoot ? resolve6(repoRoot) : process.cwd();
         this.repoRootReal = null;
         this.skillDirs = Array.isArray(skillDirs) && skillDirs.length > 0 ? skillDirs : DEFAULT_SKILL_DIRS;
         this.debug = debug;
@@ -78794,8 +79853,8 @@ var init_registry = __esm({
         }
       }
       async _resolveSkillDir(skillDir) {
-        const resolved = isAbsolute4(skillDir) ? resolve5(skillDir) : resolve5(this.repoRoot, skillDir);
-        const repoRoot = this.repoRootReal || resolve5(this.repoRoot);
+        const resolved = isAbsolute5(skillDir) ? resolve6(skillDir) : resolve6(this.repoRoot, skillDir);
+        const repoRoot = this.repoRootReal || resolve6(this.repoRoot);
         const resolvedReal = await this._resolveRealPath(resolved);
         if (!resolvedReal) return null;
         if (!isPathInside(repoRoot, resolvedReal)) {
@@ -78985,7 +80044,7 @@ function extractErrorInfo(error) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 var DEFAULT_RETRYABLE_ERRORS, RetryManager;
 var init_RetryManager = __esm({
@@ -79917,7 +80976,7 @@ var init_built_in_server = __esm({
           }
         });
         this.registerHandlers();
-        return new Promise((resolve8, reject2) => {
+        return new Promise((resolve9, reject2) => {
           this.httpServer.listen(this.port, this.host, async () => {
             const address = this.httpServer.address();
             this.port = address.port;
@@ -79927,7 +80986,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 });
-            resolve8({ host: this.host, port: this.port });
+            resolve9({ host: this.host, port: this.port });
           });
           this.httpServer.on("error", reject2);
         });
@@ -80146,7 +81205,7 @@ var init_built_in_server = __esm({
        * Parse request body as JSON
        */
       async parseRequestBody(req) {
-        return new Promise((resolve8, reject2) => {
+        return new Promise((resolve9, reject2) => {
           let body = "";
           req.on("data", (chunk) => {
             body += chunk.toString();
@@ -80154,7 +81213,7 @@ var init_built_in_server = __esm({
           req.on("end", () => {
             try {
               const parsed = body ? JSON.parse(body) : null;
-              resolve8(parsed);
+              resolve9(parsed);
             } catch (error) {
               reject2(error);
             }
@@ -80461,12 +81520,12 @@ data: ${JSON.stringify(data2)}
         }
         this.connections.clear();
         if (this.httpServer) {
-          return new Promise((resolve8) => {
+          return new Promise((resolve9) => {
             this.httpServer.close(() => {
               if (this.debug) {
                 console.log("[MCP] Built-in server stopped");
               }
-              resolve8();
+              resolve9();
             });
           });
         }
@@ -80801,8 +81860,8 @@ ${opts.schema}`;
             break;
           }
         } else if (!processEnded) {
-          await new Promise((resolve8) => {
-            resolver = resolve8;
+          await new Promise((resolve9) => {
+            resolver = resolve9;
           });
         }
       }
@@ -81062,12 +82121,12 @@ async function createCodexEngine(options = {}) {
         }
       }
       if (message.id !== void 0 && pendingRequests.has(message.id)) {
-        const { resolve: resolve8, reject: reject2 } = pendingRequests.get(message.id);
+        const { resolve: resolve9, reject: reject2 } = pendingRequests.get(message.id);
         pendingRequests.delete(message.id);
         if (message.error) {
           reject2(new Error(message.error.message || JSON.stringify(message.error)));
         } else {
-          resolve8(message.result);
+          resolve9(message.result);
         }
       }
       if (message.method === "codex/event" && message.params) {
@@ -81088,7 +82147,7 @@ async function createCodexEngine(options = {}) {
     });
   }
   function sendRequest(method, params = {}) {
-    return new Promise((resolve8, reject2) => {
+    return new Promise((resolve9, reject2) => {
       const id = ++requestId;
       const request = {
         jsonrpc: "2.0",
@@ -81096,7 +82155,7 @@ async function createCodexEngine(options = {}) {
         method,
         params
       };
-      pendingRequests.set(id, { resolve: resolve8, reject: reject2 });
+      pendingRequests.set(id, { resolve: resolve9, reject: reject2 });
       setTimeout(() => {
         if (pendingRequests.has(id)) {
           pendingRequests.delete(id);
@@ -81159,7 +82218,7 @@ ${prompt}`;
         const reqId = requestId + 1;
         let fullResponse = "";
         let gotSessionId = false;
-        const eventPromise = new Promise((resolve8) => {
+        const eventPromise = new Promise((resolve9) => {
           eventHandlers.set(reqId, (eventParams) => {
             const msg = eventParams.msg;
             if (msg.type === "session_configured" && msg.session_id && !gotSessionId) {
@@ -81179,7 +82238,7 @@ ${prompt}`;
           });
           setTimeout(() => {
             eventHandlers.delete(reqId);
-            resolve8();
+            resolve9();
           }, 6e5);
         });
         const resultPromise = sendRequest("tools/call", {
@@ -81369,7 +82428,7 @@ import { randomUUID as randomUUID6 } from "crypto";
 import { EventEmitter as EventEmitter5 } from "events";
 import { existsSync as existsSync6 } from "fs";
 import { readFile as readFile3, stat, readdir as readdir3 } from "fs/promises";
-import { resolve as resolve6, isAbsolute as isAbsolute5, dirname as dirname5, basename, normalize as normalize2, sep as sep5 } from "path";
+import { resolve as resolve7, isAbsolute as isAbsolute6, dirname as dirname5, basename, normalize as normalize2, sep as sep5 } from "path";
 function extractWrappedToolName(wrappedToolError) {
   if (!wrappedToolError || typeof wrappedToolError !== "string") {
     return "unknown";
@@ -81401,6 +82460,7 @@ var init_ProbeAgent = __esm({
     init_imageConfig();
     init_tools2();
     init_common();
+    init_fileTracker();
     init_probeTool();
     init_mockProvider();
     init_index();
@@ -81442,7 +82502,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)
@@ -81491,6 +82551,7 @@ var init_ProbeAgent = __esm({
         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";
@@ -81552,7 +82613,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}`);
@@ -81937,9 +82999,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,
@@ -82724,7 +83789,7 @@ var init_ProbeAgent = __esm({
           let resolvedPath = imagePath;
           if (!imagePath.includes("/") && !imagePath.includes("\\")) {
             for (const dir of listFilesDirectories) {
-              const potentialPath = resolve6(dir, imagePath);
+              const potentialPath = resolve7(dir, imagePath);
               const loaded = await this.loadImageIfValid(potentialPath);
               if (loaded) {
                 if (this.debug) {
@@ -82794,8 +83859,8 @@ var init_ProbeAgent = __esm({
           const allowedDirs = this.allowedFolders && this.allowedFolders.length > 0 ? this.allowedFolders : [process.cwd()];
           let absolutePath;
           let isPathAllowed2 = false;
-          if (isAbsolute5(imagePath)) {
-            absolutePath = safeRealpath(resolve6(imagePath));
+          if (isAbsolute6(imagePath)) {
+            absolutePath = safeRealpath(resolve7(imagePath));
             isPathAllowed2 = allowedDirs.some((dir) => {
               const resolvedDir = safeRealpath(dir);
               return absolutePath === resolvedDir || absolutePath.startsWith(resolvedDir + sep5);
@@ -82803,7 +83868,7 @@ var init_ProbeAgent = __esm({
           } else {
             for (const dir of allowedDirs) {
               const resolvedDir = safeRealpath(dir);
-              const resolvedPath = safeRealpath(resolve6(dir, imagePath));
+              const resolvedPath = safeRealpath(resolve7(dir, imagePath));
               if (resolvedPath === resolvedDir || resolvedPath.startsWith(resolvedDir + sep5)) {
                 absolutePath = resolvedPath;
                 isPathAllowed2 = true;
@@ -82993,7 +84058,7 @@ var init_ProbeAgent = __esm({
         let guidanceCandidates = [];
         if (hasConfiguredName) {
           const targetName = basename(configuredName);
-          if (configuredName !== targetName || configuredName.includes("/") || configuredName.includes("\\") || configuredName.includes("..") || isAbsolute5(configuredName)) {
+          if (configuredName !== targetName || configuredName.includes("/") || configuredName.includes("\\") || configuredName.includes("..") || isAbsolute6(configuredName)) {
             console.warn(`[WARN] Invalid architectureFileName (must be a simple filename): ${configuredName}`);
           } else if (targetName) {
             const targetLower = targetName.toLowerCase();
@@ -83060,7 +84125,7 @@ var init_ProbeAgent = __esm({
         pushEntry(architectureMatch);
         const contexts = [];
         for (const entry of uniqueEntries) {
-          const filePath = resolve6(rootDirectory, entry.name);
+          const filePath = resolve7(rootDirectory, entry.name);
           try {
             const content = await readFile3(filePath, "utf8");
             let kind = "other";
@@ -83125,10 +84190,10 @@ ${this.architectureContext.content}
       }
       _getSkillsRepoRoot() {
         if (this.workspaceRoot) {
-          return resolve6(this.workspaceRoot);
+          return resolve7(this.workspaceRoot);
         }
         if (this.allowedFolders && this.allowedFolders.length > 0) {
-          return resolve6(this.allowedFolders[0]);
+          return resolve7(this.allowedFolders[0]);
         }
         return process.cwd();
       }
@@ -83317,10 +84382,6 @@ Workspace: ${this.allowedFolders.join(", ")}`;
         }
         if (isToolAllowed("readImage")) {
           toolDefinitions += `${readImageToolDefinition}
-`;
-        }
-        if (this.allowEdit && isToolAllowed("implement")) {
-          toolDefinitions += `${implementToolDefinition}
 `;
         }
         if (this.allowEdit && isToolAllowed("edit")) {
@@ -83402,7 +84463,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";
@@ -83419,11 +84480,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";
@@ -83511,8 +84569,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 = "";
@@ -84012,8 +85076,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");
@@ -84235,7 +85302,7 @@ ${errorXml}
                   try {
                     let resolvedWorkingDirectory = this.workspaceRoot || this.cwd || this.allowedFolders && this.allowedFolders[0] || process.cwd();
                     if (params.workingDirectory) {
-                      const requestedDir = safeRealpath(isAbsolute5(params.workingDirectory) ? resolve6(params.workingDirectory) : resolve6(resolvedWorkingDirectory, params.workingDirectory));
+                      const requestedDir = safeRealpath(isAbsolute6(params.workingDirectory) ? resolve7(params.workingDirectory) : resolve7(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 + sep5);
@@ -84306,6 +85373,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,
@@ -84466,6 +85535,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);
@@ -85443,7 +86531,7 @@ import {
   McpError
 } from "@modelcontextprotocol/sdk/types.js";
 import { readFileSync as readFileSync2, existsSync as existsSync7 } from "fs";
-import { resolve as resolve7 } from "path";
+import { resolve as resolve8 } from "path";
 
 // src/agent/acp/server.js
 import { randomUUID as randomUUID7 } from "crypto";
@@ -85702,8 +86790,8 @@ var ACPConnection = class extends EventEmitter6 {
     if (params !== null) {
       message.params = params;
     }
-    return new Promise((resolve8, reject2) => {
-      this.pendingRequests.set(id, { resolve: resolve8, reject: reject2 });
+    return new Promise((resolve9, reject2) => {
+      this.pendingRequests.set(id, { resolve: resolve9, reject: reject2 });
       this.sendMessage(message);
       setTimeout(() => {
         if (this.pendingRequests.has(id)) {
@@ -86117,7 +87205,7 @@ dotenv3.config();
 function readInputContent(input) {
   if (!input) return null;
   try {
-    const resolvedPath = resolve7(input);
+    const resolvedPath = resolve8(input);
     if (existsSync7(resolvedPath)) {
       return readFileSync2(resolvedPath, "utf-8").trim();
     }
@@ -86126,7 +87214,7 @@ function readInputContent(input) {
   return input;
 }
 function readFromStdin() {
-  return new Promise((resolve8, reject2) => {
+  return new Promise((resolve9, reject2) => {
     let data2 = "";
     let hasReceivedData = false;
     let dataChunks = [];
@@ -86151,7 +87239,7 @@ function readFromStdin() {
       if (!trimmed && dataChunks.length === 0) {
         reject2(new Error("No input received from stdin"));
       } else {
-        resolve8(trimmed);
+        resolve9(trimmed);
       }
     });
     process.stdin.on("error", (error) => {
@@ -86183,7 +87271,8 @@ function parseArgs() {
     schema: null,
     provider: null,
     model: null,
-    allowEdit: false,
+    allowEdit: process.env.ALLOW_EDIT === "1" || false,
+    hashLines: process.env.HASH_LINES !== void 0 ? process.env.HASH_LINES === "1" : void 0,
     enableDelegate: false,
     verbose: false,
     help: false,
@@ -86232,6 +87321,10 @@ function parseArgs() {
       config.verbose = true;
     } else if (arg === "--allow-edit") {
       config.allowEdit = true;
+    } else if (arg === "--hash-lines") {
+      config.hashLines = true;
+    } else if (arg === "--no-hash-lines") {
+      config.hashLines = false;
     } else if (arg === "--enable-delegate") {
       config.enableDelegate = true;
     } else if (arg === "--no-delegate") {
@@ -86328,12 +87421,14 @@ Options:
   --schema <schema|file>           Output schema (JSON, XML, any format - text or file path)
   --provider <name>                Force AI provider: anthropic, openai, google
   --model <name>                   Override model name
-  --allow-edit                     Enable code modification capabilities
+  --allow-edit                     Enable code modification capabilities (edit + create tools)
+  --hash-lines                     Annotate search/extract output with line hashes (default: on when --allow-edit)
+  --no-hash-lines                  Disable line hash annotations even with --allow-edit
   --enable-delegate                Enable delegate tool for task distribution to subagents
   --allowed-tools <tools>          Filter available tools (comma-separated list)
                                    Use '*' or 'all' for all tools (default)
                                    Use 'none' or '' for no tools (raw AI mode)
-                                   Specific tools: search,query,extract,listFiles,searchFiles,listSkills,useSkill
+                                   Specific tools: search,query,extract,edit,create,listFiles,searchFiles,listSkills,useSkill
                                    Supports exclusion: '*,!bash' (all except bash)
   --disable-tools                  Disable all tools (raw AI mode, no code analysis)
                                    Convenience flag equivalent to --allowed-tools none
@@ -86371,6 +87466,8 @@ Environment Variables:
   FORCE_PROVIDER                  Force specific provider (anthropic, openai, google)
   MODEL_NAME                      Override model name
   MAX_RESPONSE_TOKENS             Maximum tokens for AI response
+  ALLOW_EDIT                      Enable code modification (set to '1')
+  HASH_LINES                      Annotate output with line hashes (set to '1'; default: on with ALLOW_EDIT)
   DEBUG                           Enable verbose mode (set to '1')
 
 Examples:
@@ -86387,6 +87484,8 @@ Examples:
   probe agent "Explain this code" --allowed-tools search,extract  # Only search and extract
   probe agent "What is this project about?" --allowed-tools none  # Raw AI mode (no tools)
   probe agent "Tell me about this project" --disable-tools        # Raw AI mode (convenience flag)
+  probe agent "Fix the off-by-one error" --allow-edit --path ./src  # Enable code editing
+  ALLOW_EDIT=1 probe agent "Refactor the login flow"                # Edit via env var
   probe agent --mcp               # Start MCP server mode
   probe agent --acp               # Start ACP server mode