nolo-cli 0.10.0 → 0.12.0-alpha.1

package/{chunk-6KUOUWMP.js → chunk-DRMGJFGQ.js}

@@ -3,25 +3,25 @@ import {
   finalizeAccumulatedToolCalls,
   flushChatCompletionStream,
   readSseFrames,
-  throwIfChatCompletionStreamFailed,
-  toOpenAiCompatibleMessages
-} from "./chunk-5KLGBAAR.js";
+  throwIfChatCompletionStreamFailed
+} from "./chunk-ZR4VHQ5D.js";
 import {
   parseToolArgumentsJson
-} from "./chunk-6SLCD4RB.js";
+} from "./chunk-4BTHUYMY.js";
 import {
   createThinkParserState,
   extractThinkContent
 } from "./chunk-OPZYGHUC.js";
 import {
   buildProviderAuthHeaders,
-  buildProviderExecutionPlan
-} from "./chunk-JRKKFRAV.js";
+  buildProviderExecutionPlan,
+  toOpenAiCompatibleMessages
+} from "./chunk-TSKWE74T.js";
 import {
   canonicalizeToolName,
   createGlob,
   resolveExecutableOnPath
-} from "./chunk-AUQ747NZ.js";
+} from "./chunk-43UD5ZP7.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
@@ -40,6 +40,9 @@ import {
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
@@ -52,9 +55,6 @@ import {
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
-import {
-  isRecord
-} from "./chunk-KUG52IAP.js";
 
 // packages/agent-runtime/kimiUserAgent.ts
 var KIMI_CODE_CLI_VERSION = "0.29.2";
@@ -389,10 +389,16 @@ function dialogMessageRecordToAgentRuntimeMessage(record) {
   return {
     role: record.role,
     content: record.content ?? "",
+    ...record.contextReference !== void 0 ? { context_reference: record.contextReference } : {},
     ...typeof record.reasoning_content === "string" ? { reasoning_content: record.reasoning_content } : {},
     ...typeof record.toolCallId === "string" ? { tool_call_id: record.toolCallId } : {},
     ...Array.isArray(record.tool_calls) ? { tool_calls: record.tool_calls } : {},
-    ...typeof record.toolName === "string" ? { toolName: record.toolName } : {}
+    ...typeof record.toolName === "string" ? { toolName: record.toolName } : {},
+    ...(() => {
+      const raw = record.createdAt;
+      const ms = typeof raw === "number" ? raw : typeof raw === "string" ? Date.parse(raw) : NaN;
+      return Number.isFinite(ms) ? { createdAt: ms } : {};
+    })()
   };
 }
 
@@ -469,6 +475,7 @@ function buildDialogMessageWriteOps(args) {
         dialogId: args.dialogId,
         role: message.role,
         content: message.content ?? "",
+        ...message.context_reference !== void 0 ? { contextReference: message.context_reference } : {},
         // 持久化思维链(reasoning):空轮/异常排查的关键证据,
         // 回读由 dialogMessageRecordToAgentRuntimeMessage 还原。
         ...typeof message.reasoning_content === "string" ? { reasoning_content: message.reasoning_content } : {},
@@ -878,7 +885,14 @@ var DEFAULT_LOCAL_TOOLS = /* @__PURE__ */ new Set([
   "searchFiles",
   "execShell",
   "launchProcess",
-  "listProcesses"
+  "listProcesses",
+  // Scheduling tools: forking/observing sub-agents is a declared capability
+  // of capable agents, and the blast radius is strictly narrower than
+  // execShell (already default-enabled). Requiring an env allowlist for these
+  // while execShell is open by default inverted the risk model and forced every
+  // new local user to hand-edit .env files before sub-agent tasks worked.
+  "startAgentRun",
+  "controlAgentRun"
 ]);
 function parseToolAllowlist(value) {
   return (value ?? "").split(",").flatMap((item) => {
@@ -951,7 +965,7 @@ function resolveLocalToolPolicy(args) {
   return {
     allowed: false,
     toolName,
-    reason: `${toolName} is not enabled for local runtime runs. Set NOLO_LOCAL_ALLOWED_TOOLS and make sure the agent declares the tool before using it locally.`
+    reason: `${toolName} is not enabled for local runtime runs. The agent must declare the tool in its manifest; in restricted mode (NOLO_LOCAL_TOOL_MODE=restricted) non-default tools also require adding to NOLO_LOCAL_ALLOWED_TOOLS (e.g. NOLO_LOCAL_ALLOWED_TOOLS=someCustomTool) and restarting the session so the env var loads.`
   };
 }
 async function executeLocalToolWithPolicy(args) {
@@ -1331,7 +1345,7 @@ function buildSearchWorkspaceParameters(variant) {
   const path = buildWorkspacePathProperty();
   const includeIgnored = {
     type: "boolean",
-    description: "When true, search files ignored by .gitignore such as .tmp. Defaults to false; .git and node_modules remain excluded."
+    description: "When true, search files ignored by .gitignore such as .tmp. Defaults to false. Build artifacts (dist/, *.tsbuildinfo, *.min.js, etc.) are always excluded regardless of this flag. .git and node_modules remain excluded."
   };
   const exclude = {
     type: "array",
@@ -1694,6 +1708,24 @@ var EXEC_SHELL_TIMEOUT_ENV = "NOLO_EXEC_SHELL_TIMEOUT_MS";
 var EXEC_SHELL_DETACH_ENV = "NOLO_EXEC_SHELL_DETACH_MS";
 var DEFAULT_EXEC_SHELL_DETACH_MS = 12e4;
 var DEFAULT_LOCAL_API_ORIGIN = "http://127.0.0.1:38123";
+var ALWAYS_EXCLUDED_GLOBS = [
+  "*.tsbuildinfo",
+  "dist/**",
+  "build/**",
+  "out/**",
+  "coverage/**",
+  ".next/**",
+  ".turbo/**",
+  "public/assets/**",
+  "*.min.js",
+  "*.min.css",
+  "*.map",
+  "*.lock",
+  "bun.lockb",
+  "*.ldb"
+];
+var DEFAULT_SEARCH_MAX_RESULTS = 200;
+var SEARCH_OUTPUT_CHAR_LIMIT = 2e4;
 function readTrimmedString(value) {
   return asOptionalTrimmedString(value);
 }
@@ -2039,8 +2071,29 @@ function sliceReadFileContent(args) {
     truncated: startLine > 1 || effectiveEndLine < totalLines
   };
 }
-function countExactTextOccurrences(args) {
-  return args.content.split(args.oldText).length - 1;
+function buildEolTolerantPattern(oldTextLf) {
+  const escaped = oldTextLf.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = escaped.replace(/\n/g, "\\r?\\n");
+  return new RegExp(pattern, "g");
+}
+function countAndReplaceEolTolerant(args) {
+  const oldTextLf = normalizeEolToLf(args.oldText);
+  const newTextLf = normalizeEolToLf(args.newText);
+  const pattern = buildEolTolerantPattern(oldTextLf);
+  let count = 0;
+  const result = args.content.replace(pattern, (match) => {
+    count++;
+    const eol = match.includes("\r\n") ? "\r\n" : "\n";
+    return convertEol(newTextLf, eol);
+  });
+  return { count, result };
+}
+function normalizeEolToLf(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+function convertEol(text, eol) {
+  const lf = normalizeEolToLf(text);
+  return eol === "\r\n" ? lf.replace(/\n/g, "\r\n") : lf;
 }
 function pluralizeReplacement(count) {
   return count === 1 ? "replacement" : "replacements";
@@ -2061,8 +2114,8 @@ function requireWorkspaceGlobPattern(args) {
   if (!pattern) throw new Error("globFiles requires a non-empty pattern.");
   return pattern;
 }
-function readWorkspaceMaxResults(args) {
-  if (args.maxResults === void 0) return void 0;
+function readWorkspaceMaxResults(args, defaultValue) {
+  if (args.maxResults === void 0) return defaultValue;
   const value = Number(args.maxResults);
   if (!Number.isInteger(value) || value < 1) {
     throw new Error("maxResults must be a positive integer.");
@@ -2238,6 +2291,29 @@ function waitForNodeProcessExit(proc) {
     });
   });
 }
+function isSpawnFailureError(error) {
+  if (!error || typeof error !== "object") return false;
+  const err = error;
+  if (err.code === "ENOENT") return true;
+  const message = toErrorMessage(error).toLowerCase();
+  return message.includes("enoent") || message.includes("executable not found") || message.includes("spawn") && message.includes("not found");
+}
+function spawnFailedCommandResult(error, outputLimit) {
+  const stderr = `spawn failed: ${toErrorMessage(error)}
+`;
+  return {
+    stdout: "",
+    stderr,
+    exitCode: 127,
+    timedOut: false,
+    spawnFailed: true,
+    content: truncateToolOutput(
+      [`stderr:
+${stderr.trim()}`, "exitCode: 127"].filter(Boolean).join("\n\n"),
+      outputLimit
+    )
+  };
+}
 function resolveRipgrepBinary(env = process.env) {
   const fromEnv = asOptionalTrimmedString(env.NOLO_BUNDLED_RG);
   if (fromEnv) {
@@ -2248,6 +2324,9 @@ function resolveRipgrepBinary(env = process.env) {
   }
   return resolveExecutableOnPath("rg");
 }
+function resolveGrepBinary() {
+  return resolveExecutableOnPath("grep");
+}
 async function runWorkspaceCommand(args) {
   const timeoutMs = asOptionalPositiveFiniteNumber(args.timeoutMs);
   const detached = process.platform !== "win32";
@@ -2332,7 +2411,21 @@ async function runWorkspaceCommand(args) {
   }
   if (abortPromise) racers.push(abortPromise);
   if (detachPromise) racers.push(detachPromise);
-  const raceWinner = await Promise.race(racers);
+  let raceWinner;
+  try {
+    raceWinner = await Promise.race(racers);
+  } catch (error) {
+    if (timeout) clearTimeout(timeout);
+    if (detachTimer) clearTimeout(detachTimer);
+    if (abortListener && args.abortSignal) {
+      args.abortSignal.removeEventListener("abort", abortListener);
+    }
+    detachSignalCleanup();
+    if (isSpawnFailureError(error)) {
+      return spawnFailedCommandResult(error, args.outputLimit);
+    }
+    throw error;
+  }
   if (timeout) clearTimeout(timeout);
   if (detachTimer) clearTimeout(detachTimer);
   if (abortListener && args.abortSignal) {
@@ -2449,12 +2542,40 @@ async function runWorkspaceCommandLimitedLines(args) {
     ]);
   } catch (error) {
     const settled2 = await exitSettled;
-    if (!settled2.ok) throw settled2.error;
+    if (!settled2.ok) {
+      return {
+        stdout: "",
+        stderr: `spawn failed: ${toErrorMessage(settled2.error)}
+`,
+        exitCode: 127,
+        limitedByMaxResults: false,
+        spawnFailed: true
+      };
+    }
+    if (isSpawnFailureError(error)) {
+      return {
+        stdout: "",
+        stderr: `spawn failed: ${toErrorMessage(error)}
+`,
+        exitCode: 127,
+        limitedByMaxResults: false,
+        spawnFailed: true
+      };
+    }
     throw error;
   }
   if (!limitedByMaxResults && pending.trim()) lines.push(pending);
   const settled = await exitSettled;
-  if (!settled.ok) throw settled.error;
+  if (!settled.ok) {
+    return {
+      stdout: "",
+      stderr: `spawn failed: ${toErrorMessage(settled.error)}
+`,
+      exitCode: 127,
+      limitedByMaxResults: false,
+      spawnFailed: true
+    };
+  }
   const exitCode = limitedByMaxResults ? 0 : settled.code;
   const stderr = await stderrPromise;
   return {
@@ -2583,13 +2704,16 @@ async function editFileTool(args) {
     ...args.confirmExternalFileAccess ? { confirmExternalFileAccess: args.confirmExternalFileAccess } : {}
   });
   const content = await readFile(absolutePath, "utf8");
-  const replacementCount = countExactTextOccurrences({ content, oldText });
+  const { count: replacementCount, result: nextContent } = countAndReplaceEolTolerant({
+    content,
+    oldText,
+    newText
+  });
   if (replacementCount !== expectedReplacements) {
     throw new Error(
-      `editFile expected ${expectedReplacements} ${pluralizeReplacement(expectedReplacements)} but found ${replacementCount} in ${requestedPath}.`
+      `editFile expected ${expectedReplacements} ${pluralizeReplacement(expectedReplacements)} but found ${replacementCount} in ${requestedPath} (matched after EOL normalization; verify the exact text).`
     );
   }
-  const nextContent = content.split(oldText).join(newText);
   await writeFile(absolutePath, nextContent, "utf8");
   const relativePath = normalizeWorkspaceRelativePath({
     workspaceRoot: resolve(args.workspaceRoot),
@@ -2686,7 +2810,7 @@ async function searchFilesTool(args) {
   const parsed = parseWorkspaceToolArguments(args.call.arguments);
   const query = requireWorkspaceSearchQuery(parsed);
   const exclude = readWorkspaceExcludeGlobs(parsed);
-  const maxResults = readWorkspaceMaxResults(parsed);
+  const maxResults = readWorkspaceMaxResults(parsed, DEFAULT_SEARCH_MAX_RESULTS);
   const contextLines = readWorkspaceContextLines(parsed);
   const literal = parsed.literal === true;
   const caseSensitive = parsed.caseSensitive === false ? false : true;
@@ -2701,8 +2825,8 @@ async function searchFilesTool(args) {
     workspaceRoot: resolve(args.workspaceRoot),
     targetPath: searchPath
   });
-  const rgBinary = resolveRipgrepBinary();
-  const grepBinary = resolveExecutableOnPath("grep") || "grep";
+  const rgBinary = (args.resolveRipgrepBinary ?? resolveRipgrepBinary)();
+  const grepBinary = (args.resolveGrepBinary ?? resolveGrepBinary)();
   const rgCommand = rgBinary ? [
     rgBinary,
     "--line-number",
@@ -2716,29 +2840,26 @@ async function searchFilesTool(args) {
     "!node_modules",
     "--glob",
     "!.git",
+    ...ALWAYS_EXCLUDED_GLOBS.flatMap((g) => ["--glob", `!${g}`]),
     ...exclude.flatMap((excludePattern) => ["--glob", `!${excludePattern}`]),
     "--",
     query,
     relativeSearchPath
   ] : null;
-  const grepCommand = [
-    grepBinary,
-    "-R",
-    "-n",
-    "-I",
-    ...literal ? ["-F"] : [],
-    ...caseSensitive ? [] : ["-i"],
-    ...contextLines !== void 0 ? ["-C", String(contextLines)] : [],
-    "--exclude-dir=node_modules",
-    "--exclude-dir=.git",
-    ...exclude.flatMap((excludePattern) => ["--exclude", excludePattern]),
-    query,
-    relativeSearchPath
+  const grepExcludeArgs = [
+    ...ALWAYS_EXCLUDED_GLOBS.flatMap((g) => {
+      if (!g.endsWith("/**")) return ["--exclude", g];
+      const dir = g.replace(/\/\*\*$/, "");
+      return dir.includes("/") ? [] : [`--exclude-dir=${dir}`];
+    }),
+    ...exclude.flatMap((excludePattern) => ["--exclude", excludePattern])
   ];
+  let searchEngine = "js";
+  let binariesUnavailable = !rgBinary && !grepBinary;
   const result = await (async () => {
     if (rgCommand) {
       try {
-        return maxResults && !contextLines ? await runWorkspaceCommandLimitedLines({
+        const rgResult = maxResults && !contextLines ? await runWorkspaceCommandLimitedLines({
           workspaceRoot: args.workspaceRoot,
           command: rgCommand,
           maxLines: maxResults
@@ -2746,35 +2867,66 @@ async function searchFilesTool(args) {
           workspaceRoot: args.workspaceRoot,
           command: rgCommand
         });
+        if (!rgResult.spawnFailed) {
+          searchEngine = "ripgrep";
+          return rgResult;
+        }
       } catch {
       }
     }
-    try {
-      return maxResults && !contextLines ? await runWorkspaceCommandLimitedLines({
-        workspaceRoot: args.workspaceRoot,
-        command: grepCommand,
-        maxLines: maxResults
-      }) : await runWorkspaceCommand({
-        workspaceRoot: args.workspaceRoot,
-        command: grepCommand
-      });
-    } catch {
-      return {
-        stdout: "",
-        stderr: "",
-        exitCode: 0,
-        limitedByMaxResults: false
-      };
+    if (grepBinary) {
+      const grepCommand = [
+        grepBinary,
+        "-R",
+        "-n",
+        "-I",
+        ...literal ? ["-F"] : [],
+        ...caseSensitive ? [] : ["-i"],
+        ...contextLines !== void 0 ? ["-C", String(contextLines)] : [],
+        "--exclude-dir=node_modules",
+        "--exclude-dir=.git",
+        ...grepExcludeArgs,
+        query,
+        relativeSearchPath
+      ];
+      try {
+        const grepResult = maxResults && !contextLines ? await runWorkspaceCommandLimitedLines({
+          workspaceRoot: args.workspaceRoot,
+          command: grepCommand,
+          maxLines: maxResults
+        }) : await runWorkspaceCommand({
+          workspaceRoot: args.workspaceRoot,
+          command: grepCommand
+        });
+        if (!grepResult.spawnFailed) {
+          searchEngine = "grep";
+          return grepResult;
+        }
+        binariesUnavailable = true;
+      } catch {
+        binariesUnavailable = true;
+      }
+    } else {
+      binariesUnavailable = true;
     }
+    return {
+      stdout: "",
+      stderr: "",
+      exitCode: 0,
+      limitedByMaxResults: false,
+      spawnFailed: true
+    };
   })();
   let outputLines = result.stdout.split(/\r?\n/).map((line) => line.trimEnd().replace(/^\.\//, "")).filter(Boolean);
+  outputLines = dropAlwaysExcludedLines(outputLines);
   let limitedByMaxResults = "limitedByMaxResults" in result && result.limitedByMaxResults === true;
-  if (outputLines.length === 0 && result.exitCode === 0 && (includeIgnored || !await hasRootGitignore(args.workspaceRoot))) {
+  const forceJsFallback = binariesUnavailable || result.spawnFailed === true;
+  if (outputLines.length === 0 && (forceJsFallback || result.exitCode === 0 && (includeIgnored || !await hasRootGitignore(args.workspaceRoot)))) {
     const fallback = await scanWorkspaceTextMatches({
       workspaceRoot: args.workspaceRoot,
       relativeSearchPath,
       query,
-      exclude,
+      exclude: [...ALWAYS_EXCLUDED_GLOBS, ...exclude],
       maxResults,
       literal,
       caseSensitive,
@@ -2782,6 +2934,7 @@ async function searchFilesTool(args) {
     });
     outputLines = fallback.lines;
     limitedByMaxResults = fallback.limitedByMaxResults;
+    searchEngine = "js";
   }
   if (contextLines && outputLines.length > 0) {
     const limited = limitSearchOutputByMatches(outputLines, maxResults);
@@ -2793,8 +2946,11 @@ async function searchFilesTool(args) {
     const match = line.match(/^(.*?):\d+:/);
     return match?.[1] ? [match[1]] : [];
   })));
+  const rawContent = outputLines.join("\n");
+  const content = truncateToolOutput(rawContent, SEARCH_OUTPUT_CHAR_LIMIT);
+  const truncatedByByteLimit = content.length !== rawContent.length;
   return {
-    content: outputLines.join("\n"),
+    content,
     metadata: {
       query,
       path: requestedPath,
@@ -2807,10 +2963,12 @@ async function searchFilesTool(args) {
       count: outputLines.length,
       matchCount: matchLines.length,
       matchedFiles,
-      truncated: limitedByMaxResults,
+      truncated: limitedByMaxResults || truncatedByByteLimit,
       limitedByMaxResults,
+      ...truncatedByByteLimit ? { truncatedByByteLimit: true } : {},
       ...maxResults ? { maxResults } : {},
       exitCode: result.exitCode,
+      searchEngine,
       ...extractActivity(parsed) ? { activity: extractActivity(parsed) } : {}
     }
   };
@@ -2841,6 +2999,14 @@ async function filterRootGitignoredFiles(args) {
   const globs = patterns.map((pattern) => createGlob(pattern));
   return args.files.filter((file) => !globs.some((glob) => glob.match(file)));
 }
+function dropAlwaysExcludedLines(lines) {
+  const globs = ALWAYS_EXCLUDED_GLOBS.map((pattern) => createGlob(pattern));
+  return lines.filter((line) => {
+    const filePath = line.match(/^(.*?):\d+[:-]/)?.[1];
+    if (!filePath) return true;
+    return !globs.some((glob) => glob.match(filePath));
+  });
+}
 function scanWorkspaceGlobFiles(args) {
   const pathPrefix = args.relativeSearchPath === "." ? "" : `${args.relativeSearchPath.replace(/\/+$/, "")}/`;
   return Array.from(createGlob(args.pattern).scanSync({
@@ -2933,38 +3099,76 @@ async function globFilesTool(args) {
     workspaceRoot: resolve(args.workspaceRoot),
     targetPath: searchPath
   });
-  const command = [
-    "rg",
-    "--files",
-    "--hidden",
-    ...includeIgnored ? ["--no-ignore"] : [],
-    "--glob",
-    pattern,
-    "--glob",
-    "!node_modules",
-    "--glob",
-    "!.git",
-    ...exclude.flatMap((excludePattern) => ["--glob", `!${excludePattern}`]),
-    ...relativeSearchPath === "." ? [] : [relativeSearchPath]
-  ];
-  const result = await runWorkspaceCommand({
-    workspaceRoot: args.workspaceRoot,
-    command
-  });
   const pathPrefix = relativeSearchPath === "." ? "" : `${relativeSearchPath.replace(/\/+$/, "")}/`;
-  let files = result.stdout.split(/\r?\n/).map((line) => line.trim().replace(/^\.\//, "")).filter(Boolean).filter((line) => !pathPrefix || line === relativeSearchPath || line.startsWith(pathPrefix)).sort((left, right) => left.localeCompare(right));
-  files = await filterRootGitignoredFiles({
-    workspaceRoot: args.workspaceRoot,
-    files,
-    includeIgnored
-  });
-  if (files.length === 0 && (includeIgnored || !await hasRootGitignore(args.workspaceRoot))) {
+  const rgBinary = (args.resolveRipgrepBinary ?? resolveRipgrepBinary)();
+  let searchEngine = "js";
+  let exitCode = 0;
+  let files = [];
+  if (rgBinary) {
+    const command = [
+      rgBinary,
+      "--files",
+      "--hidden",
+      ...includeIgnored ? ["--no-ignore"] : [],
+      "--glob",
+      pattern,
+      "--glob",
+      "!node_modules",
+      "--glob",
+      "!.git",
+      ...exclude.flatMap((excludePattern) => ["--glob", `!${excludePattern}`]),
+      ...relativeSearchPath === "." ? [] : [relativeSearchPath]
+    ];
+    const result = await runWorkspaceCommand({
+      workspaceRoot: args.workspaceRoot,
+      command
+    });
+    exitCode = result.exitCode;
+    if (result.spawnFailed) {
+      files = scanWorkspaceGlobFiles({
+        workspaceRoot: args.workspaceRoot,
+        pattern,
+        relativeSearchPath,
+        exclude
+      });
+      files = await filterRootGitignoredFiles({
+        workspaceRoot: args.workspaceRoot,
+        files,
+        includeIgnored
+      });
+      searchEngine = "js";
+    } else {
+      files = result.stdout.split(/\r?\n/).map((line) => line.trim().replace(/^\.\//, "")).filter(Boolean).filter((line) => !pathPrefix || line === relativeSearchPath || line.startsWith(pathPrefix)).sort((left, right) => left.localeCompare(right));
+      files = await filterRootGitignoredFiles({
+        workspaceRoot: args.workspaceRoot,
+        files,
+        includeIgnored
+      });
+      if (files.length === 0 && (includeIgnored || !await hasRootGitignore(args.workspaceRoot))) {
+        files = scanWorkspaceGlobFiles({
+          workspaceRoot: args.workspaceRoot,
+          pattern,
+          relativeSearchPath,
+          exclude
+        });
+        searchEngine = "js";
+      } else {
+        searchEngine = "ripgrep";
+      }
+    }
+  } else {
     files = scanWorkspaceGlobFiles({
       workspaceRoot: args.workspaceRoot,
       pattern,
       relativeSearchPath,
       exclude
     });
+    files = await filterRootGitignoredFiles({
+      workspaceRoot: args.workspaceRoot,
+      files,
+      includeIgnored
+    });
+    searchEngine = "js";
   }
   const commandLimitedByMaxResults = false;
   const totalCount = commandLimitedByMaxResults ? void 0 : files.length;
@@ -2985,7 +3189,8 @@ async function globFilesTool(args) {
       truncated: limitedByMaxResults,
       limitedByMaxResults,
       ...maxResults ? { maxResults } : {},
-      exitCode: result.exitCode,
+      exitCode,
+      searchEngine,
       ...activity ? { activity } : {}
     }
   };
@@ -3189,6 +3394,10 @@ async function listProcessesTool(args) {
 }
 function createLocalWorkspaceToolExecutors(args) {
   const fileAccess = args.confirmExternalFileAccess ? { confirmExternalFileAccess: args.confirmExternalFileAccess } : {};
+  const searchBinaryResolvers = {
+    ...args.resolveRipgrepBinary ? { resolveRipgrepBinary: args.resolveRipgrepBinary } : {},
+    ...args.resolveGrepBinary ? { resolveGrepBinary: args.resolveGrepBinary } : {}
+  };
   return {
     editFile: (call) => editFileTool({
       call,
@@ -3198,7 +3407,8 @@ function createLocalWorkspaceToolExecutors(args) {
     globFiles: (call) => globFilesTool({
       call,
       workspaceRoot: args.workspaceRoot,
-      ...fileAccess
+      ...fileAccess,
+      ...args.resolveRipgrepBinary ? { resolveRipgrepBinary: args.resolveRipgrepBinary } : {}
     }),
     listFiles: (call) => listFilesTool({
       call,
@@ -3218,7 +3428,8 @@ function createLocalWorkspaceToolExecutors(args) {
     searchFiles: (call) => searchFilesTool({
       call,
       workspaceRoot: args.workspaceRoot,
-      ...fileAccess
+      ...fileAccess,
+      ...searchBinaryResolvers
     }),
     captureVisualState: (call) => captureVisualStateTool({
       call,