@wrongstack/tools 0.270.0 → 0.272.0

package/dist/builtin.js

@@ -1,13 +1,13 @@
-import { spawn, execFileSync, spawnSync } from 'node:child_process';
+import { spawn, execFileSync } from 'node:child_process';
 import * as Core from '@wrongstack/core';
-import { buildChildEnv, detectNewlineStyle, normalizeToLf, toStyle, atomicWrite, unifiedDiff, isPrivateIPv4, isPrivateIPv6, assessCommitSafety, compileGlob, expectDefined, recordPackageAction, detectPackageEcosystem, mutatePlan, clearPlan, getPlanTemplate, addPlanItem, deriveTodosFromPlanItem, removePlanItem, setPlanItemStatus, mutateTasks, formatTaskList, formatPlan, computeTaskItemProgress, loadPlan, savePlan, loadTasks, saveTasks, wstackGlobalRoot, resolveWstackPaths, truncate } from '@wrongstack/core';
+import { buildChildEnv, detectNewlineStyle, normalizeToLf, toStyle, atomicWrite, unifiedDiff, isPrivateIPv4, isPrivateIPv6, assessCommitSafety, compileGlob, expectDefined, recordPackageAction, detectPackageEcosystem, mutatePlan, clearPlan, getPlanTemplate, addPlanItem, deriveTodosFromPlanItem, removePlanItem, setPlanItemStatus, mutateTasks, formatTaskList, formatPlan, toErrorMessage, computeTaskItemProgress, loadPlan, savePlan, loadTasks, saveTasks, wstackGlobalRoot, resolveWstackPaths, truncate } from '@wrongstack/core';
 import * as fs from 'node:fs';
-import { statSync, mkdirSync, createWriteStream, writeFileSync } from 'node:fs';
-import * as fs14 from 'node:fs/promises';
+import { statSync, mkdirSync, createWriteStream } from 'node:fs';
+import * as fs2 from 'node:fs/promises';
 import * as path3 from 'node:path';
 import { resolve, sep, dirname, join } from 'node:path';
-import * as os from 'node:os';
-import { toErrorMessage } from '@wrongstack/core/utils';
+import * as os2 from 'node:os';
+import { toErrorMessage as toErrorMessage$1 } from '@wrongstack/core/utils';
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
 import { Worker } from 'node:worker_threads';
@@ -31,12 +31,12 @@ function sweepOldSpoolFiles(dir) {
   void (async () => {
     try {
       const now = Date.now();
-      for (const name of await fs14.readdir(dir)) {
+      for (const name of await fs2.readdir(dir)) {
         if (!name.endsWith(".log")) continue;
         const p = path3.join(dir, name);
         try {
-          const st = await fs14.stat(p);
-          if (now - st.mtimeMs > SPOOL_RETENTION_MS) await fs14.unlink(p);
+          const st = await fs2.stat(p);
+          if (now - st.mtimeMs > SPOOL_RETENTION_MS) await fs2.unlink(p);
         } catch {
         }
       }
@@ -345,10 +345,13 @@ function redactCommand(cmd) {
 var DEFAULT_GRACE_MS = 2e3;
 function killWin32Tree(pid) {
   try {
-    spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+    const child = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
       stdio: "ignore",
       windowsHide: true
-    }).unref();
+    });
+    child.on("error", () => {
+    });
+    child.unref();
     return true;
   } catch {
     return false;
@@ -550,7 +553,7 @@ var ProcessRegistryImpl = class {
     if (p.killed) return true;
     if (p.protected) return false;
     const { force = false, graceMs = DEFAULT_GRACE_MS } = opts;
-    const isWin3 = os.platform() === "win32";
+    const isWin3 = os2.platform() === "win32";
     if (isWin3) {
       const liveRealChild = p.child.exitCode === null && typeof p.child.pid === "number";
       if (liveRealChild && killWin32Tree(pid)) {
@@ -756,8 +759,10 @@ async function* spawnStream(opts) {
     queue.push({ kind: "close", data: "", code: 124 });
     wake();
   };
-  if (opts.signal.aborted) onAbort();
-  else opts.signal.addEventListener("abort", onAbort, { once: true });
+  if (isWin) {
+    if (opts.signal.aborted) onAbort();
+    else opts.signal.addEventListener("abort", onAbort, { once: true });
+  }
   let exitCode = 0;
   let spawnFailed = false;
   try {
@@ -801,7 +806,7 @@ async function* spawnStream(opts) {
     };
   } finally {
     spool.finalize();
-    opts.signal.removeEventListener("abort", onAbort);
+    if (isWin) opts.signal.removeEventListener("abort", onAbort);
     child.stdout?.off("data", onOut);
     child.stderr?.off("data", onErr);
     child.stdout?.destroy();
@@ -856,13 +861,13 @@ function safeResolve(input, ctx) {
 async function assertRealInsideRoot(absPath, ctx) {
   if (ctx.allowOutsideProjectRoot) return;
   const realRoots = await Promise.all(
-    allowedRoots(ctx).map((r) => fs14.realpath(r).catch(() => path3.resolve(r)))
+    allowedRoots(ctx).map((r) => fs2.realpath(r).catch(() => path3.resolve(r)))
   );
   let probe = absPath;
   for (; ; ) {
     let real;
     try {
-      real = await fs14.realpath(probe);
+      real = await fs2.realpath(probe);
     } catch (err) {
       if (err.code === "ENOENT") {
         const parent = path3.dirname(probe);
@@ -1067,6 +1072,560 @@ function parseAuditOutput(json, exitCode) {
     };
   }
 }
+var REGISTRY_FILE = ".wrongstack/process-registry.json";
+var HEARTBEAT_INTERVAL_MS = 5e3;
+var STALE_THRESHOLD_MS = 3e4;
+var LOCKFILE = ".wrongstack/.process-registry.lock";
+function generateInstanceId() {
+  const hostname2 = os2.hostname();
+  const pid = process.pid;
+  const random = Math.random().toString(36).slice(2, 8);
+  return `${hostname2}:${pid}:${random}`;
+}
+async function acquireLock(lockfilePath, timeoutMs = 5e3) {
+  const start = Date.now();
+  const pidStr = String(process.pid);
+  const hostStr = os2.hostname();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      await fs2.writeFile(lockfilePath, `${pidStr}:${hostStr}:${Date.now()}`, { flag: "wx" });
+      return async () => {
+        try {
+          await fs2.unlink(lockfilePath);
+        } catch {
+        }
+      };
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        try {
+          const content = await fs2.readFile(lockfilePath, "utf-8");
+          const parts = content.split(":");
+          const lockPidStr = parts[0] ?? "0";
+          const lockPid = parseInt(lockPidStr, 10);
+          if (process.platform !== "win32") {
+            try {
+              process.kill(lockPid, 0);
+            } catch {
+              await fs2.unlink(lockfilePath);
+              continue;
+            }
+          }
+        } catch {
+          try {
+            await fs2.unlink(lockfilePath);
+          } catch {
+          }
+        }
+        await new Promise((r) => setTimeout(r, 100));
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error(`Failed to acquire lock after ${timeoutMs}ms`);
+}
+async function readRegistryFile(filePath) {
+  try {
+    const content = await fs2.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (parsed.instances && Array.isArray(parsed.instances)) {
+      parsed.instances = new Map(parsed.instances);
+    }
+    return parsed;
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return {
+        version: 1,
+        instances: /* @__PURE__ */ new Map(),
+        protectedPatterns: ["wrongstack", "node"],
+        lastCleanup: Date.now()
+      };
+    }
+    throw err;
+  }
+}
+async function writeRegistryFile(filePath, data) {
+  const tmpPath = `${filePath}.tmp.${process.pid}`;
+  const content = JSON.stringify(data, (_k, v) => {
+    if (v instanceof Map) {
+      return Array.from(v.entries());
+    }
+    return v;
+  }, 2);
+  await fs2.writeFile(tmpPath, content, "utf-8");
+  await fs2.rename(tmpPath, filePath);
+}
+var PersistentProcessRegistry = class {
+  instanceId;
+  registryPath;
+  lockPath;
+  baseRegistry;
+  heartbeatInterval = null;
+  isShuttingDown = false;
+  constructor(baseRegistry) {
+    this.instanceId = generateInstanceId();
+    const homeDir = os2.homedir();
+    this.registryPath = path3.join(homeDir, REGISTRY_FILE);
+    this.lockPath = path3.join(homeDir, LOCKFILE);
+    this.baseRegistry = baseRegistry ?? getProcessRegistry();
+    this.ensureDirectory().catch((err) => {
+      console.error("PersistentProcessRegistry: failed to create .wrongstack dir", err);
+    });
+  }
+  async ensureDirectory() {
+    const dir = path3.dirname(this.registryPath);
+    try {
+      await fs2.mkdir(dir, { recursive: true });
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+  }
+  /**
+   * Start the heartbeat and periodic cleanup tasks.
+   */
+  start() {
+    if (this.heartbeatInterval) return;
+    this.syncToPersistent();
+    this.heartbeatInterval = setInterval(() => {
+      this.heartbeat();
+    }, HEARTBEAT_INTERVAL_MS);
+    this.heartbeatInterval.unref?.();
+    setInterval(() => {
+      this.cleanupStaleEntries();
+    }, STALE_THRESHOLD_MS).unref?.();
+    this.registerMainProcess();
+    process.on("exit", () => this.syncToPersistent());
+  }
+  /**
+   * Stop the heartbeat and clean up.
+   */
+  stop() {
+    this.isShuttingDown = true;
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    this.syncToPersistent();
+  }
+  /**
+   * Register the main WrongStack process as protected.
+   */
+  registerMainProcess() {
+    const mainPid = process.pid;
+    this.updatePersistentEntry({
+      pid: mainPid,
+      name: "wrongstack-main",
+      command: process.argv.slice(0, 3).join(" "),
+      startedAt: Date.now(),
+      lastHeartbeat: Date.now(),
+      instanceId: this.instanceId,
+      hostname: os2.hostname(),
+      protected: true,
+      spawnMode: "main",
+      parentPid: process.ppid,
+      platform: process.platform
+    });
+  }
+  /**
+   * Register a spawned child process with the persistent registry.
+   */
+  registerChildProcess(pid, name, command, sessionId, spawnMode = "spawn") {
+    const entry = {
+      pid,
+      name,
+      command,
+      startedAt: Date.now(),
+      lastHeartbeat: Date.now(),
+      instanceId: this.instanceId,
+      hostname: os2.hostname(),
+      protected: true,
+      // All WrongStack child processes are protected by default
+      spawnMode,
+      parentPid: process.pid,
+      platform: process.platform
+    };
+    if (sessionId) {
+      entry.sessionId = sessionId;
+    }
+    this.updatePersistentEntry(entry);
+  }
+  /**
+   * Update or add an entry in the persistent registry.
+   */
+  async updatePersistentEntry(entry) {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      data.instances.set(String(entry.pid), entry);
+      this.baseRegistry.register({
+        pid: entry.pid,
+        name: entry.name,
+        command: entry.command,
+        startedAt: entry.startedAt,
+        sessionId: entry.sessionId,
+        protected: entry.protected,
+        child: null
+        // Main process has no child handle
+      });
+      await writeRegistryFile(this.registryPath, data);
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Unregister a process from the persistent registry.
+   */
+  async unregister(pid) {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      data.instances.delete(String(pid));
+      await writeRegistryFile(this.registryPath, data);
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Send heartbeat to mark all this instance's processes as alive.
+   */
+  heartbeat() {
+    if (this.isShuttingDown) return;
+    this.syncToPersistent();
+  }
+  /**
+   * Sync this instance's processes to the persistent registry.
+   */
+  async syncToPersistent() {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      const now = Date.now();
+      const updatedInstances = /* @__PURE__ */ new Map();
+      for (const [_pidStr, entry] of data.instances) {
+        if (entry.instanceId === this.instanceId) {
+          entry.lastHeartbeat = now;
+        }
+        if (entry.instanceId === this.instanceId || now - entry.lastHeartbeat < STALE_THRESHOLD_MS) {
+          updatedInstances.set(_pidStr, entry);
+        }
+      }
+      data.instances = updatedInstances;
+      data.lastCleanup = now;
+      await writeRegistryFile(this.registryPath, data);
+    } catch (err) {
+      console.error("PersistentProcessRegistry: sync failed", err);
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Remove entries for processes that are no longer running.
+   */
+  async cleanupStaleEntries() {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      const now = Date.now();
+      const stalePids = [];
+      for (const [_pidStr, entry] of data.instances) {
+        const age = now - entry.lastHeartbeat;
+        if (age > STALE_THRESHOLD_MS) {
+          try {
+            if (process.platform !== "win32") {
+              process.kill(entry.pid, 0);
+            } else {
+              console.log(`PersistentProcessRegistry: checking stale pid ${entry.pid} (${age}ms old)`);
+            }
+          } catch {
+            stalePids.push(_pidStr);
+          }
+        }
+      }
+      if (stalePids.length > 0) {
+        for (const pidStr of stalePids) {
+          data.instances.delete(pidStr);
+        }
+        await writeRegistryFile(this.registryPath, data);
+      }
+    } catch (err) {
+      console.error("PersistentProcessRegistry: cleanup failed", err);
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Check if a PID belongs to a WrongStack process and should be protected.
+   */
+  async isProtectedPid(pid) {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      const entry = data.instances.get(String(pid));
+      if (!entry) return false;
+      if (Date.now() - entry.lastHeartbeat > STALE_THRESHOLD_MS) {
+        return false;
+      }
+      return entry.protected;
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Get all protected PIDs from all WrongStack instances.
+   */
+  async getAllProtectedPids() {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      const now = Date.now();
+      const protectedPids = [];
+      for (const [_pidStr, entry] of data.instances) {
+        if (entry.protected && now - entry.lastHeartbeat < STALE_THRESHOLD_MS) {
+          protectedPids.push(entry.pid);
+        }
+      }
+      return protectedPids;
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Get complete status of all tracked processes across all instances.
+   */
+  async getGlobalStatus() {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      const now = Date.now();
+      const instances = /* @__PURE__ */ new Map();
+      let protectedCount = 0;
+      let staleCount = 0;
+      for (const [_pidStr, entry] of data.instances) {
+        const instanceEntries = instances.get(entry.instanceId) ?? [];
+        instanceEntries.push(entry);
+        instances.set(entry.instanceId, instanceEntries);
+        if (entry.protected) protectedCount++;
+        if (now - entry.lastHeartbeat > STALE_THRESHOLD_MS) staleCount++;
+      }
+      return {
+        instances,
+        totalProcesses: data.instances.size,
+        protectedCount,
+        staleCount
+      };
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Get the instance ID for this process.
+   */
+  getInstanceId() {
+    return this.instanceId;
+  }
+  /**
+   * Check if a kill command should be blocked.
+   * Returns true if the kill should be blocked (target is a WrongStack process).
+   */
+  async shouldBlockKill(pid) {
+    const protectedPids = await this.getAllProtectedPids();
+    return protectedPids.includes(pid);
+  }
+  /**
+   * Add a pattern-based protection rule.
+   * Processes whose command matches any protected pattern are protected.
+   */
+  async addProtectedPattern(pattern) {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      if (!data.protectedPatterns.includes(pattern)) {
+        data.protectedPatterns.push(pattern);
+        await writeRegistryFile(this.registryPath, data);
+      }
+    } finally {
+      await release();
+    }
+  }
+};
+var _persistentRegistry;
+function getPersistentProcessRegistry() {
+  if (!_persistentRegistry) {
+    _persistentRegistry = new PersistentProcessRegistry();
+  }
+  return _persistentRegistry;
+}
+
+// src/bash-kill-guard.ts
+function extractKillCommand(command) {
+  const normalized = command.replace(/\s+/g, " ").trim();
+  const shellCMatch = normalized.match(
+    /^(?:\/\w+)?\/?(?:bin|usr)\/(?:ba)?sh\s+-[c]\s+['"](.+?)['"]$/
+  );
+  if (shellCMatch?.[1]) {
+    const inner = shellCMatch[1].trim();
+    return isKillRelatedCommand(inner) ? inner : null;
+  }
+  const shellCUnquoted = normalized.match(
+    /^(?:\/\w+)?\/?(?:bin|usr)\/(?:ba)?sh\s+-[c]\s+(kill(?:\s+-[a-zA-Z]+)?(?:\s+\d+)+)$/
+  );
+  if (shellCUnquoted?.[1]) {
+    return shellCUnquoted[1];
+  }
+  return null;
+}
+function isKillRelatedCommand(cmd) {
+  const normalized = cmd.toLowerCase().replace(/\s+/g, " ").trim();
+  if (/^kill(\s|$)/.test(normalized)) return true;
+  if (/^(pkill|killall|pgrep|skill)\s/.test(normalized)) return true;
+  if (/^taskkill\s/i.test(normalized)) return true;
+  if (/^tskill\s/i.test(normalized)) return true;
+  if (/^\/proc\/\d+\/(?:kill|fd)/.test(normalized)) return true;
+  return false;
+}
+function parseKillCommand(command) {
+  const normalized = command.replace(/\s+/g, " ").trim();
+  const simpleMatch = normalized.match(/^kill\s+(?:(-[a-zA-Z]+)\s+)?(\d+|-?\d+)$/);
+  if (simpleMatch) {
+    const signal = simpleMatch[1] ?? "-TERM";
+    const pidOrGroup = simpleMatch[2];
+    if (!pidOrGroup) return null;
+    const isGroupKill = pidOrGroup.startsWith("-");
+    const pid = isGroupKill ? parseInt(pidOrGroup.slice(1), 10) : parseInt(pidOrGroup, 10);
+    return {
+      pid,
+      signal: signal.slice(1),
+      isGroupKill,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  const pkillMatch = normalized.match(/^pkill\s+(?:(-[a-zA-Z]+)\s+)?(.+)$/);
+  if (pkillMatch?.[2]) {
+    const name = pkillMatch[2];
+    const signalMatch = pkillMatch[1];
+    return {
+      name,
+      signal: signalMatch ? signalMatch.slice(1) : "TERM",
+      isGroupKill: false,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  const killallMatch = normalized.match(/^killall\s+(?:(-[a-zA-Z]+)\s+)?(.+)$/);
+  if (killallMatch?.[2]) {
+    const name = killallMatch[2];
+    const signalMatch = killallMatch[1];
+    return {
+      name,
+      signal: signalMatch ? signalMatch.slice(1) : "TERM",
+      isGroupKill: false,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  const pgrepMatch = normalized.match(/^pgrep\s+(.+)$/);
+  if (pgrepMatch) {
+    return null;
+  }
+  const taskkillMatch = normalized.match(/^taskkill\s+(?:\/[a-zA-Z]+\s+)*\/PID\s+(\d+)/i);
+  if (taskkillMatch?.[1]) {
+    const pidStr = taskkillMatch[1];
+    return {
+      pid: parseInt(pidStr, 10),
+      signal: normalized.includes("/F") ? "FORCE" : "TERM",
+      isGroupKill: false,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  const tskillMatch = normalized.match(/^tskill\s+(\d+)/i);
+  if (tskillMatch?.[1]) {
+    const pidStr = tskillMatch[1];
+    return {
+      pid: parseInt(pidStr, 10),
+      signal: "TERM",
+      isGroupKill: false,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  return null;
+}
+async function getProtectedEntries() {
+  const registry = getPersistentProcessRegistry();
+  const status = await registry.getGlobalStatus();
+  const entries = [];
+  for (const instanceEntries of status.instances.values()) {
+    for (const entry of instanceEntries) {
+      if (entry.protected && Date.now() - entry.lastHeartbeat < 3e4) {
+        entries.push(entry);
+      }
+    }
+  }
+  return entries;
+}
+async function isKillProtected(kill) {
+  const registry = getPersistentProcessRegistry();
+  if (kill.name) {
+    const entries = await getProtectedEntries();
+    const killNameLower = kill.name.toLowerCase();
+    for (const entry of entries) {
+      if (entry.name && entry.name.toLowerCase().includes(killNameLower)) {
+        return true;
+      }
+    }
+    if (killNameLower.includes("wrongstack")) {
+      return true;
+    }
+    if (killNameLower.includes("node") && entries.length > 0) {
+      return true;
+    }
+    return false;
+  }
+  if (kill.isGroupKill) {
+    const protectedPids = await registry.getAllProtectedPids();
+    return protectedPids.length > 0;
+  }
+  if (kill.pid !== void 0) {
+    return registry.shouldBlockKill(kill.pid);
+  }
+  return false;
+}
+async function checkAndBlockKillCommand(command) {
+  const normalized = command.replace(/\s+/g, " ").trim();
+  const killCmd = extractKillCommand(normalized) || (isKillRelatedCommand(normalized) ? normalized : null);
+  if (!killCmd) {
+    return { blocked: false };
+  }
+  const parsed = parseKillCommand(killCmd);
+  if (!parsed) {
+    if (killCmd.includes("kill") && /kill\s+.*\|/.test(killCmd)) {
+      return {
+        blocked: true,
+        reason: `Blocked: complex kill pipeline detected \u2014 "${killCmd.slice(0, 50)}..."`
+      };
+    }
+    return { blocked: false };
+  }
+  if (await isKillProtected(parsed)) {
+    let target;
+    if (parsed.name) {
+      target = `process name "${parsed.name}"`;
+    } else if (parsed.pid !== void 0) {
+      target = `PID ${parsed.pid}`;
+    } else {
+      target = "(unknown target)";
+    }
+    const signal = parsed.signal ? ` (${parsed.signal})` : "";
+    const groupNote = parsed.isGroupKill ? " (process group)" : "";
+    return {
+      blocked: true,
+      reason: `Blocked: kill${signal} ${target}${groupNote} targets a protected WrongStack process.`
+    };
+  }
+  return { blocked: false };
+}
 
 // src/bash.ts
 var MAX_OUTPUT = 32768;
@@ -1136,6 +1695,20 @@ var bashTool = {
       };
       return;
     }
+    const killCheck = await checkAndBlockKillCommand(input.command);
+    if (killCheck.blocked) {
+      yield {
+        type: "final",
+        output: {
+          output: "",
+          exit_code: 1,
+          timed_out: false,
+          pid: null,
+          error: killCheck.reason || "Kill command blocked: targets a protected WrongStack process."
+        }
+      };
+      return;
+    }
     const PIPE_TO_SHELL_PATTERN = /\|\s*(sh|bash|ksh|zsh|fish|cmd|powershell|pwsh)/i;
     if (PIPE_TO_SHELL_PATTERN.test(input.command)) {
       console.warn(JSON.stringify({
@@ -1148,7 +1721,7 @@ var bashTool = {
       }));
     }
     const timeoutMs = Math.max(1, Math.min(input.timeout_ms ?? DEFAULT_TIMEOUT_MS, 6e5));
-    const isWin3 = os.platform() === "win32";
+    const isWin3 = os2.platform() === "win32";
     const shell = (() => {
       const explicit = process.env[isWin3 ? "WRONGSTACK_COMSPEC" : "WRONGSTACK_SHELL"];
       if (explicit) return explicit;
@@ -1762,7 +2335,7 @@ function loadDatabaseSync() {
     DatabaseSyncCtor = req("node:sqlite").DatabaseSync;
   } catch (err) {
     throw new Error(
-      `The codebase index needs Node's built-in SQLite (node:sqlite), available since Node 22.5. This runtime doesn't provide it: ${toErrorMessage(err)}`
+      `The codebase index needs Node's built-in SQLite (node:sqlite), available since Node 22.5. This runtime doesn't provide it: ${toErrorMessage$1(err)}`
     );
   }
   return DatabaseSyncCtor;
@@ -1911,33 +2484,53 @@ var IndexStore = class {
     }
   }
   // ─── Symbol CRUD ─────────────────────────────────────────────────────────────
-  insertSymbols(symbols, nextId) {
+  /**
+   * Insert symbols, assigning IDs atomically inside `BEGIN IMMEDIATE` /
+   * `COMMIT`. The ID allocation (`SELECT MAX(id)`) and all `INSERT`s share
+   * the same transaction, preventing UNIQUE constraint violations when two
+   * processes index concurrently (each would see a different `MAX(id)` and
+   * neither can insert with the other's IDs).
+   *
+   * @returns The symbols array with `id` fields populated so the caller can
+   *          use them for refs without re-reading from the DB.
+   */
+  insertSymbols(symbols) {
     return this.runWithRetry(() => {
-      const stmt = this.db.prepare(
-        `INSERT INTO symbols(id, lang, kind, name, file, line, col, signature, doc_comment, scope, text, file_fk)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-      );
-      const ftsStmt = this.ftsAvailable ? this.db.prepare("INSERT INTO symbols_fts(rowid, text) VALUES (?, ?)") : null;
-      let id = nextId;
-      for (const s of symbols) {
-        stmt.run(
-          id,
-          s.lang,
-          s.kind,
-          s.name,
-          s.file,
-          s.line,
-          s.col,
-          s.signature,
-          s.docComment,
-          s.scope,
-          s.text,
-          s.file
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        const maxRows = this.db.prepare("SELECT MAX(id) AS m FROM symbols").all();
+        let nextId = (maxRows[0]?.m ?? 0) + 1;
+        const stmt = this.db.prepare(
+          `INSERT INTO symbols(id, lang, kind, name, file, line, col, signature, doc_comment, scope, text, file_fk)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
         );
-        ftsStmt?.run(id, buildIndexableText(s.name, s.signature, s.docComment));
-        id++;
+        const ftsStmt = this.ftsAvailable ? this.db.prepare("INSERT INTO symbols_fts(rowid, text) VALUES (?, ?)") : null;
+        const result = [];
+        for (const s of symbols) {
+          const id = nextId++;
+          stmt.run(
+            id,
+            s.lang,
+            s.kind,
+            s.name,
+            s.file,
+            s.line,
+            s.col,
+            s.signature,
+            s.docComment,
+            s.scope,
+            s.text,
+            s.file
+          );
+          ftsStmt?.run(id, buildIndexableText(s.name, s.signature, s.docComment));
+          result.push({ ...s, id });
+        }
+        this.db.exec("COMMIT");
+        return result;
+      } catch (err) {
+        this.db.exec("ROLLBACK");
+        throw err;
       }
-      return id;
     });
   }
   deleteSymbolsForFile(file) {
@@ -2491,10 +3084,10 @@ function detectLang(file) {
   if (idx < 0) return null;
   return extToLang(file.slice(idx));
 }
-function parseSymbols2(opts) {
+async function parseSymbols2(opts) {
   const { file, content, lang } = opts;
   try {
-    return syncGoParse(file, content, lang);
+    return await syncGoParse(file, content, lang);
   } catch {
     return { file, lang, symbols: [], mtimeMs: Date.now() };
   }
@@ -2731,19 +3324,34 @@ func formatType(t ast.Expr) string {
 	}
 }
 `;
-function syncGoParse(filePath, content, lang) {
-  const tmpDir = path3.join(os.tmpdir(), "ws-go-parse");
+async function syncGoParse(filePath, content, lang) {
+  const tmpDir = path3.join(os2.tmpdir(), "ws-go-parse");
   try {
-    mkdirSync(tmpDir, { recursive: true });
+    await fs2.mkdir(tmpDir, { recursive: true });
     const scriptPath = path3.join(tmpDir, "parse.go");
-    writeFileSync(scriptPath, GO_PARSE_SCRIPT, "utf8");
-    const stdout = execFileSync("go", ["run", scriptPath], {
-      input: content,
-      timeout: 15e3,
-      encoding: "utf8",
+    await fs2.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
+    const proc = spawn("go", ["run", scriptPath], {
+      stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
     });
-    if (!stdout.trim()) {
+    let stdout = "";
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.stdin?.write(content);
+    proc.stdin?.end();
+    const { code } = await Promise.race([
+      new Promise((resolve6) => {
+        proc.on("close", (c) => resolve6({ code: c }));
+      }),
+      new Promise(
+        (_, reject) => setTimeout(() => {
+          proc.kill("SIGKILL");
+          reject(new Error("timeout"));
+        }, 15e3)
+      )
+    ]).catch(() => ({ code: -1 }));
+    if (code !== 0 || !stdout.trim()) {
       return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
     }
     const raw = JSON.parse(stdout.trim());
@@ -2765,10 +3373,10 @@ function syncGoParse(filePath, content, lang) {
     return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
   }
 }
-function parseSymbols3(opts) {
+async function parseSymbols3(opts) {
   const { file, lang } = opts;
   try {
-    return syncPyParse(file, lang);
+    return await syncPyParse(file, lang);
   } catch {
     return { file, lang, symbols: [], mtimeMs: Date.now() };
   }
@@ -2977,18 +3585,32 @@ visitor.visit(tree)
 
 print(json.dumps([s.to_dict() for s in syms]))
 `;
-function syncPyParse(filePath, lang) {
+async function syncPyParse(filePath, lang) {
   try {
-    const tmpDir = path3.join(os.tmpdir(), "ws-py-parse");
-    mkdirSync(tmpDir, { recursive: true });
+    const tmpDir = path3.join(os2.tmpdir(), "ws-py-parse");
+    await fs2.mkdir(tmpDir, { recursive: true });
     const scriptPath = path3.join(tmpDir, "parse.py");
-    writeFileSync(scriptPath, PY_PARSE_SCRIPT, "utf8");
-    const stdout = execFileSync("python", [scriptPath, filePath], {
-      timeout: 15e3,
-      encoding: "utf8",
+    await fs2.writeFile(scriptPath, PY_PARSE_SCRIPT, "utf8");
+    const proc = spawn("python", [scriptPath, filePath], {
+      stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
     });
-    if (!stdout.trim()) {
+    let stdout = "";
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    const { code } = await Promise.race([
+      new Promise((resolve6) => {
+        proc.on("close", (c) => resolve6({ code: c }));
+      }),
+      new Promise(
+        (_, reject) => setTimeout(() => {
+          proc.kill("SIGKILL");
+          reject(new Error("timeout"));
+        }, 15e3)
+      )
+    ]).catch(() => ({ code: -1 }));
+    if (code !== 0 || !stdout.trim()) {
       return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
     }
     const raw = JSON.parse(stdout.trim());
@@ -3010,11 +3632,11 @@ function syncPyParse(filePath, lang) {
     return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
   }
 }
-function parseSymbols4(opts) {
+async function parseSymbols4(opts) {
   const { file, content, lang } = opts;
   const nativeAvailable = checkNativeParser();
   if (nativeAvailable) {
-    const result = tryNativeParse(file, content);
+    const result = await tryNativeParse(file, content);
     if (result) return result;
   }
   return regexParse({ file, content, lang });
@@ -3044,25 +3666,34 @@ function checkNativeParser() {
     return false;
   }
 }
-function tryNativeParse(file, content) {
+async function tryNativeParse(file, content) {
   try {
     const toolsDir = path3.join(process.cwd(), "tools");
     const crateDir = path3.join(toolsDir, "syn-parser");
     const tmpFile = path3.join(crateDir, "src", "input.rs");
-    writeFileSync(tmpFile, content, "utf8");
-    const result = spawnSync(
-      "cargo",
-      ["run", "--manifest-path", path3.join(toolsDir, "Cargo.toml")],
-      {
-        cwd: process.cwd(),
-        encoding: "utf8",
-        timeout: 15e3,
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true
-      }
-    );
-    if (result.status === 0 && result.stdout) {
-      const symbols = JSON.parse(result.stdout);
+    await fs2.writeFile(tmpFile, content, "utf8");
+    const proc = spawn("cargo", ["run", "--manifest-path", path3.join(toolsDir, "Cargo.toml")], {
+      cwd: process.cwd(),
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true
+    });
+    let stdout = "";
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    const { code } = await Promise.race([
+      new Promise((resolve6) => {
+        proc.on("close", (c) => resolve6({ code: c }));
+      }),
+      new Promise(
+        (_, reject) => setTimeout(() => {
+          proc.kill("SIGKILL");
+          reject(new Error("timeout"));
+        }, 15e3)
+      )
+    ]).catch(() => ({ code: -1 }));
+    if (code === 0 && stdout.trim()) {
+      const symbols = JSON.parse(stdout.trim());
       return {
         file,
         lang: "rs",
@@ -3531,7 +4162,7 @@ function compileGitignore(lines) {
 async function loadGitignoreMatcher(projectRoot) {
   let lines = [];
   try {
-    const raw = await fs14.readFile(path3.join(projectRoot, ".gitignore"), "utf8");
+    const raw = await fs2.readFile(path3.join(projectRoot, ".gitignore"), "utf8");
     lines = raw.split("\n");
   } catch {
   }
@@ -3589,7 +4220,7 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
     }
     let entries;
     try {
-      entries = await fs14.readdir(dir, { withFileTypes: true });
+      entries = await fs2.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -3687,7 +4318,7 @@ async function runIndexerWithStore(store, opts) {
       batchFiles.map(async (file) => {
         let stat11;
         try {
-          stat11 = await fs14.stat(file, statOpts);
+          stat11 = await fs2.stat(file, statOpts);
         } catch (e) {
           if (isAbortError(e)) throw e;
           return { file, stat: null, lang: "", parsed: null, error: `stat error: ${e instanceof Error ? e.message : String(e)}` };
@@ -3701,7 +4332,7 @@ async function runIndexerWithStore(store, opts) {
         }
         let content;
         try {
-          content = await fs14.readFile(file, { encoding: "utf8", signal });
+          content = await fs2.readFile(file, { encoding: "utf8", signal });
         } catch (e) {
           if (isAbortError(e)) throw e;
           return { file, stat: stat11, lang, parsed: null, error: `read error: ${e instanceof Error ? e.message : String(e)}` };
@@ -3751,9 +4382,7 @@ async function runIndexerWithStore(store, opts) {
         filesIndexed++;
         continue;
       }
-      const nextId = store.getMaxSymbolId() + 1;
-      const symbolsWithIds = parsed.symbols.map((s, i) => ({ ...s, id: nextId + i }));
-      store.insertSymbols(symbolsWithIds, nextId);
+      const symbolsWithIds = store.insertSymbols(parsed.symbols);
       const count = symbolsWithIds.length;
       symbolsIndexed += count;
       langStats[lang] = (langStats[lang] ?? 0) + count;
@@ -3782,7 +4411,7 @@ async function runIndexerWithStore(store, opts) {
   }
   for (const [file_] of existingMeta) {
     try {
-      await fs14.stat(file_);
+      await fs2.stat(file_);
     } catch {
       store.deleteFile(file_);
     }
@@ -4032,10 +4661,10 @@ function circuitOpenError() {
     "Codebase indexing is temporarily paused after repeated failures" + (c.lastFailure ? ` (last: ${c.lastFailure})` : "") + (c.cooldownRemainingMs > 0 ? `; auto-retry in ${Math.ceil(c.cooldownRemainingMs / 1e3)}s` : "") + ". Use /codebase-reindex to retry now."
   );
 }
-function isUniqueConstraintError(err) {
+function isRecoverableConstraintError(err) {
   if (err instanceof Error) {
     const msg = err.message.toLowerCase();
-    return msg.includes("unique constraint") || msg.includes("UNIQUE constraint");
+    return msg.includes("unique constraint") || msg.includes("constraint failed");
   }
   return false;
 }
@@ -4068,7 +4697,7 @@ async function runStartupIndex(opts) {
     return result;
   } catch (err) {
     _lastError = err instanceof Error ? err.message : String(err);
-    if (isUniqueConstraintError(err) && !opts.force) {
+    if (isRecoverableConstraintError(err) && !opts.force) {
       _lastError = null;
       const rebuildResult = await runStartupIndex({
         ...opts,
@@ -4428,9 +5057,9 @@ async function fileDiff(input, ctx, _signal) {
   const results = [];
   for (const file of files) {
     const absPath = safeResolve(file, ctx);
-    const stat11 = await fs14.stat(absPath).catch(() => null);
+    const stat11 = await fs2.stat(absPath).catch(() => null);
     if (!stat11?.isFile()) continue;
-    const content = await fs14.readFile(absPath, "utf8");
+    const content = await fs2.readFile(absPath, "utf8");
     const lines = content.split(/\r?\n/);
     results.push(formatWithLineNumbers(file, lines));
   }
@@ -4490,7 +5119,7 @@ var documentTool = {
     const fileList = input.files ? await resolveFiles(Array.isArray(input.files) ? input.files.join(",") : input.files, cwd) : input.path ? [safeResolve(input.path, ctx)] : [];
     for (const absPath of fileList) {
       try {
-        const content = await fs14.readFile(absPath, "utf8");
+        const content = await fs2.readFile(absPath, "utf8");
         filesProcessed++;
         const processed = processFile(
           content,
@@ -4526,7 +5155,7 @@ async function resolveFiles(filesInput, cwd) {
   for (const f of files) {
     const absPath = f.trim().startsWith("/") ? f.trim() : `${cwd}/${f.trim()}`;
     try {
-      const stat11 = await fs14.stat(absPath);
+      const stat11 = await fs2.stat(absPath);
       if (stat11.isFile()) resolved.push(absPath);
     } catch {
     }
@@ -4619,7 +5248,7 @@ var editTool = {
     if (input.new_string === void 0) throw new Error("edit: new_string is required");
     if (input.old_string === "") throw new Error("edit: old_string cannot be empty");
     const absPath = await safeResolveReal(input.path, ctx);
-    const stat11 = await fs14.stat(absPath).catch((err) => {
+    const stat11 = await fs2.stat(absPath).catch((err) => {
       if (err.code === "ENOENT") {
         throw new Error(`edit: file "${input.path}" does not exist. Use \`write\` instead.`);
       }
@@ -4627,8 +5256,8 @@ var editTool = {
     });
     if (!stat11.isFile()) throw new Error(`edit: "${input.path}" is not a regular file`);
     const autoRead = !ctx.hasRead(absPath);
-    const original = await fs14.readFile(absPath, "utf8");
-    const updated = await fs14.stat(absPath);
+    const original = await fs2.readFile(absPath, "utf8");
+    const updated = await fs2.stat(absPath);
     const mtimeTolerance = process.platform === "win32" ? 2e3 : 1;
     const lastReadMtime = ctx.lastReadMtime(absPath);
     if (lastReadMtime !== void 0 && updated.mtimeMs > lastReadMtime + mtimeTolerance) {
@@ -4674,7 +5303,7 @@ var editTool = {
     const newFileLf = input.replace_all ? fileLf.split(oldLf).join(newLf) : fileLf.replace(oldLf, newLf);
     const newFile = toStyle(newFileLf, style);
     await atomicWrite(absPath, newFile, { mode: updated.mode & 511 });
-    const written = await fs14.stat(absPath);
+    const written = await fs2.stat(absPath);
     ctx.recordRead(absPath, written.mtimeMs);
     ctx.session.recordFileChange({
       path: absPath,
@@ -5023,8 +5652,8 @@ if (ALLOW_PRIVATE && !process.env["CI"]) {
   );
 }
 var combineSignals = (signals) => AbortSignal.any(signals);
-function guardedLookup(hostname, options, callback) {
-  dns.lookup(hostname, { all: true }).then((records) => {
+function guardedLookup(hostname2, options, callback) {
+  dns.lookup(hostname2, { all: true }).then((records) => {
     const family = options?.family;
     const byFamily = family === 4 || family === 6 ? records.filter((r) => r.family === family) : records;
     const list = byFamily.length > 0 ? byFamily : records;
@@ -5051,7 +5680,7 @@ function guardedLookup(hostname, options, callback) {
     const first = list.at(0);
     if (!first) {
       callback(
-        Object.assign(new Error(`fetch: no address for ${hostname}`), { code: "ENOTFOUND" })
+        Object.assign(new Error(`fetch: no address for ${hostname2}`), { code: "ENOTFOUND" })
       );
       return;
     }
@@ -5165,7 +5794,13 @@ var fetchTool = {
     const timer = setTimeout(() => ctrl.abort(new Error("fetch timeout")), TIMEOUT_MS);
     const combined = combineSignals([opts.signal, ctrl.signal]);
     try {
-      const res = await guardedFetch(input.url, 5, combined);
+      let res;
+      try {
+        res = await guardedFetch(input.url, 5, combined);
+      } catch (err) {
+        if (opts.signal.aborted) throw err;
+        throw describeFetchError(err, input.url, ctrl.signal.aborted);
+      }
       const ct = res.headers.get("content-type") ?? "application/octet-stream";
       if (/^image\/|^audio\/|^video\/|application\/octet-stream/.test(ct)) {
         throw new Error(`fetch: refusing to read binary content-type "${ct}"`);
@@ -5221,9 +5856,9 @@ var fetchTool = {
     }
   }
 };
-async function assertNotPrivate(hostname) {
+async function assertNotPrivate(hostname2) {
   if (ALLOW_PRIVATE) return;
-  const host = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  const host = hostname2.startsWith("[") && hostname2.endsWith("]") ? hostname2.slice(1, -1) : hostname2;
   if (host === "localhost" || host.endsWith(".localhost")) {
     throw new Error("fetch: blocked localhost target");
   }
@@ -5250,6 +5885,23 @@ async function assertNotPrivate(hostname) {
     }
   }
 }
+function describeFetchError(err, url, timedOut) {
+  if (timedOut) {
+    return new Error(`fetch: GET ${url} timed out after ${TIMEOUT_MS}ms`);
+  }
+  const parts = [];
+  const seen = /* @__PURE__ */ new Set();
+  let cur = err;
+  while (cur instanceof Error && !seen.has(cur)) {
+    seen.add(cur);
+    const code = cur.code;
+    const label = code ? `${code}: ${cur.message}` : cur.message;
+    if (label && label !== "fetch failed" && !parts.includes(label)) parts.push(label);
+    cur = cur.cause;
+  }
+  const detail = parts.length > 0 ? parts.join(" \u2192 ") : "fetch failed";
+  return new Error(`fetch: GET ${url} failed \u2014 ${detail}`);
+}
 function prettyJson(s) {
   try {
     return JSON.stringify(JSON.parse(s), null, 2);
@@ -5681,7 +6333,7 @@ var globTool = {
       }
       let entries;
       try {
-        entries = await fs14.readdir(dir, { withFileTypes: true });
+        entries = await fs2.readdir(dir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -5697,7 +6349,7 @@ var globTool = {
         } else if (e.isFile()) {
           if (re.test(rel) || re.test(name)) {
             try {
-              const st = await fs14.stat(full);
+              const st = await fs2.stat(full);
               results.push({ rel: full, mtime: st.mtimeMs });
               if (results.length >= limit) {
                 truncated = true;
@@ -5716,7 +6368,7 @@ var globTool = {
 };
 async function readGitignore(dir) {
   try {
-    const raw = await fs14.readFile(path3.join(dir, ".gitignore"), "utf8");
+    const raw = await fs2.readFile(path3.join(dir, ".gitignore"), "utf8");
     return raw.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
   } catch {
     return [];
@@ -5770,6 +6422,7 @@ function capSubject(line) {
 
 // src/grep.ts
 var DEFAULT_IGNORE3 = ["node_modules", ".git", "dist", "build", ".next", "coverage"];
+var NATIVE_SCAN_CONCURRENCY = 32;
 var grepTool = {
   name: "grep",
   category: "Search",
@@ -5997,14 +6650,52 @@ async function runNative(input, base, mode, limit, signal) {
   const fileMatches = /* @__PURE__ */ new Map();
   let total = 0;
   let stopped = false;
+  const scanFile = async (full, name) => {
+    if (stopped || signal.aborted) return;
+    if (globRe && !globRe.test(name) && !globRe.test(full)) return;
+    if (globRe) globRe.lastIndex = 0;
+    try {
+      const stat11 = await fs2.stat(full);
+      if (stat11.size > 1e6 || stopped || signal.aborted) return;
+      const head = await fs2.readFile(full);
+      if (isBinaryBuffer(head) || stopped || signal.aborted) return;
+      const text = head.toString("utf8");
+      const lines = text.split(/\r?\n/);
+      let fileHits = 0;
+      for (let i = 0; i < lines.length; i++) {
+        if (stopped || signal.aborted) break;
+        const ln = capSubject(lines[i] ?? "");
+        re.lastIndex = 0;
+        if (re.test(ln)) {
+          fileHits++;
+          total++;
+          if (mode === "content" && matches.length < limit) {
+            matches.push(`${full}:${i + 1}:${ln}`);
+          }
+        }
+      }
+      if (fileHits > 0) {
+        fileMatches.set(full, fileHits);
+        if (mode === "files_with_matches" && matches.length < limit) {
+          matches.push(full);
+        }
+        if (mode === "count" && matches.length < limit) {
+          matches.push(`${full}:${fileHits}`);
+        }
+      }
+      if (matches.length >= limit) stopped = true;
+    } catch {
+    }
+  };
   const walk = async (dir) => {
     if (stopped || signal.aborted) return;
     let entries;
     try {
-      entries = await fs14.readdir(dir, { withFileTypes: true });
+      entries = await fs2.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
+    const files = [];
     for (const e of entries) {
       if (stopped) return;
       if (DEFAULT_IGNORE3.includes(e.name)) continue;
@@ -6013,41 +6704,10 @@ async function runNative(input, base, mode, limit, signal) {
       if (e.isDirectory()) {
         await walk(full);
       } else if (e.isFile()) {
-        if (globRe && !globRe.test(e.name) && !globRe.test(full)) continue;
-        if (globRe) globRe.lastIndex = 0;
-        try {
-          const stat11 = await fs14.stat(full);
-          if (stat11.size > 1e6) continue;
-          const head = await fs14.readFile(full);
-          if (isBinaryBuffer(head)) continue;
-          const text = head.toString("utf8");
-          const lines = text.split(/\r?\n/);
-          let fileHits = 0;
-          for (let i = 0; i < lines.length; i++) {
-            const ln = capSubject(lines[i] ?? "");
-            re.lastIndex = 0;
-            if (re.test(ln)) {
-              fileHits++;
-              total++;
-              if (mode === "content" && matches.length < limit) {
-                matches.push(`${full}:${i + 1}:${ln}`);
-              }
-            }
-          }
-          if (fileHits > 0) {
-            fileMatches.set(full, fileHits);
-            if (mode === "files_with_matches" && matches.length < limit) {
-              matches.push(full);
-            }
-            if (mode === "count" && matches.length < limit) {
-              matches.push(`${full}:${fileHits}`);
-            }
-          }
-          if (matches.length >= limit) stopped = true;
-        } catch {
-        }
+        files.push({ full, name: e.name });
       }
     }
+    await mapWithConcurrency(files, NATIVE_SCAN_CONCURRENCY, ({ full, name }) => scanFile(full, name));
   };
   await walk(base);
   return {
@@ -6057,6 +6717,20 @@ async function runNative(input, base, mode, limit, signal) {
     used: "native"
   };
 }
+async function mapWithConcurrency(items, concurrency, fn) {
+  if (items.length === 0) return;
+  let next = 0;
+  const workerCount = Math.min(Math.max(1, concurrency), items.length);
+  const workers = Array.from({ length: workerCount }, async () => {
+    for (; ; ) {
+      const idx = next++;
+      if (idx >= items.length) return;
+      const item = items[idx];
+      if (item !== void 0) await fn(item);
+    }
+  });
+  await Promise.all(workers);
+}
 var installTool = {
   name: "install",
   category: "Package Management",
@@ -6231,7 +6905,7 @@ var jsonTool = {
     let raw;
     if (input.file) {
       try {
-        raw = await fs14.readFile(input.file, "utf8");
+        raw = await fs2.readFile(input.file, "utf8");
       } catch {
         return { data: null, formatted: "", type: "unknown", error: `Could not read file` };
       }
@@ -6270,8 +6944,8 @@ var jsonTool = {
     };
   }
 };
-function query(data, path20) {
-  const parts = path20.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+function query(data, path21) {
+  const parts = path21.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
   let current = data;
   for (const part of parts) {
     if (current === null || current === void 0) return void 0;
@@ -6548,7 +7222,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
 }
 var DOCKER_LOGS_TIMEOUT_MS = 3e3;
 var MAX_TAIL_LINES = 1e5;
-async function fileLogs(path20, lines, filterRe, stream) {
+async function fileLogs(path21, lines, filterRe, stream) {
   const { createInterface } = await import('node:readline');
   const { createReadStream } = await import('node:fs');
   const entries = [];
@@ -6557,7 +7231,7 @@ async function fileLogs(path20, lines, filterRe, stream) {
   let writeIdx = 0;
   let totalLines = 0;
   const rl = createInterface({
-    input: createReadStream(path20),
+    input: createReadStream(path21),
     crlfDelay: Number.POSITIVE_INFINITY
   });
   for await (const line of rl) {
@@ -6578,7 +7252,7 @@ async function fileLogs(path20, lines, filterRe, stream) {
     if (parsed) entries.push(parsed);
   }
   return {
-    source: path20,
+    source: path21,
     entries,
     total: entries.length,
     truncated: totalLines > effLines,
@@ -6779,12 +7453,12 @@ var patchTool = {
         };
       }
     }
-    const tmpDir = await fs14.mkdtemp(path3.join(os.tmpdir(), ".wstack_patch_"));
+    const tmpDir = await fs2.mkdtemp(path3.join(os2.tmpdir(), ".wstack_patch_"));
     try {
-      await fs14.chmod(tmpDir, 448).catch(() => {
+      await fs2.chmod(tmpDir, 448).catch(() => {
       });
       const patchFile = path3.join(tmpDir, "in.diff");
-      await fs14.writeFile(patchFile, input.patch, { mode: 384 });
+      await fs2.writeFile(patchFile, input.patch, { mode: 384 });
       const args = [`-p${strip}`, "--merge", ...dryRun ? ["--dry-run"] : [], "-i", patchFile];
       const result = await runPatch(args, dir, opts.signal);
       if (result.exitCode !== 0 && !dryRun) {
@@ -6805,7 +7479,7 @@ var patchTool = {
         message: result.stdout || "patch applied"
       };
     } finally {
-      await fs14.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+      await fs2.rm(tmpDir, { recursive: true, force: true }).catch(() => {
       });
     }
   }
@@ -7151,7 +7825,7 @@ var readTool = {
     const absPath = await safeResolveReal(input.path, ctx);
     let stat11;
     try {
-      stat11 = await fs14.stat(absPath);
+      stat11 = await fs2.stat(absPath);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") throw new Error(`read: file not found "${input.path}"`);
@@ -7176,7 +7850,7 @@ var readTool = {
         note: "Repeated read suppressed to save tokens."
       };
     }
-    const buf = await fs14.readFile(absPath);
+    const buf = await fs2.readFile(absPath);
     if (isBinaryBuffer(buf)) {
       throw new Error(`read: "${input.path}" appears to be binary`);
     }
@@ -7322,11 +7996,11 @@ var replaceTool = {
     const dryRun = input.dry_run ?? false;
     const filesInput = Array.isArray(input.files) ? input.files.join(",") : input.files;
     const fileList = await resolveFiles2(filesInput, ctx, globRe);
-    const realRoot = await fs14.realpath(ctx.projectRoot).catch(() => ctx.projectRoot);
+    const realRoot = await fs2.realpath(ctx.projectRoot).catch(() => ctx.projectRoot);
     const results = [];
     let totalReplacements = 0;
     for (const absPath of fileList) {
-      const lstat2 = await fs14.lstat(absPath).catch((err) => {
+      const lstat2 = await fs2.lstat(absPath).catch((err) => {
         if (err.code === "ENOENT") return null;
         throw err;
       });
@@ -7334,17 +8008,17 @@ var replaceTool = {
       if (lstat2.isSymbolicLink()) continue;
       let realPath;
       try {
-        realPath = await fs14.realpath(absPath);
+        realPath = await fs2.realpath(absPath);
       } catch {
         continue;
       }
       const rel = path3.relative(realRoot, realPath);
       if (rel.startsWith("..") || path3.isAbsolute(rel)) continue;
-      const stat11 = await fs14.stat(realPath).catch(() => null);
+      const stat11 = await fs2.stat(realPath).catch(() => null);
       if (!stat11 || !stat11.isFile()) continue;
       let content;
       try {
-        const buf = await fs14.readFile(realPath);
+        const buf = await fs2.readFile(realPath);
         if (isBinaryBuffer(buf)) continue;
         content = buf.toString("utf8");
       } catch {
@@ -7396,7 +8070,7 @@ async function resolveFiles2(filesInput, ctx, extraGlob) {
   const resolved = [];
   for (const p of parts) {
     const absPath = safeResolve(p, ctx);
-    const stat11 = await fs14.stat(absPath).catch(() => null);
+    const stat11 = await fs2.stat(absPath).catch(() => null);
     if (stat11?.isFile()) {
       resolved.push(absPath);
     }
@@ -7452,7 +8126,7 @@ async function globNative(pattern, base, extraGlob) {
   const walk = async (dir) => {
     let entries;
     try {
-      entries = await fs14.readdir(dir, { withFileTypes: true });
+      entries = await fs2.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -7460,7 +8134,7 @@ async function globNative(pattern, base, extraGlob) {
       if (DEFAULT_IGNORE4.includes(e.name)) continue;
       const full = path3.join(dir, e.name);
       try {
-        const stat11 = await fs14.lstat(full);
+        const stat11 = await fs2.lstat(full);
         if (stat11.isSymbolicLink()) continue;
       } catch {
         continue;
@@ -7638,7 +8312,7 @@ async function handleBuiltIn(name, templateFiles, cwd, ctx, dryRun, vars) {
     }
     const fullPath = target;
     if (!dryRun) {
-      await fs14.mkdir(path3.dirname(fullPath), { recursive: true });
+      await fs2.mkdir(path3.dirname(fullPath), { recursive: true });
       await atomicWrite(fullPath, substituteVars(content, name, vars));
     }
     files.push(resolvedPath);
@@ -7751,7 +8425,7 @@ async function duckduckgoSearch(query2, num, signal) {
       truncated: results.length >= num
     };
   } catch (err) {
-    console.log(JSON.stringify({ level: "debug", event: "search_failed", query: query2, error: toErrorMessage(err) }));
+    console.log(JSON.stringify({ level: "debug", event: "search_failed", query: query2, error: toErrorMessage$1(err) }));
     return {
       query: query2,
       results: [{ title: "Search unavailable", url: "", snippet: "Could not reach DuckDuckGo" }],
@@ -7915,11 +8589,11 @@ var setWorkingDirTool = {
     } catch (err) {
       return {
         current: ctx.workingDir,
-        error: toErrorMessage(err)
+        error: toErrorMessage$1(err)
       };
     }
     try {
-      await fs14.access(resolved);
+      await fs2.access(resolved);
     } catch {
       try {
         ctx.setWorkingDir(previous);
@@ -8975,7 +9649,7 @@ var treeTool = {
   }
 };
 async function walkDir(dir, depth, opts) {
-  const entries = await fs14.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs2.readdir(dir, { withFileTypes: true }).catch(() => []);
   const filtered = entries.filter((e) => {
     if (!opts.showHidden && e.name.startsWith(".")) return false;
     if (opts.exclude.has(e.name)) return false;
@@ -9133,14 +9807,14 @@ var writeTool = {
     let existed = false;
     let prev = "";
     try {
-      const stat12 = await fs14.stat(absPath);
+      const stat12 = await fs2.stat(absPath);
       existed = stat12.isFile();
       if (existed) {
         if (!ctx.hasRead(absPath)) {
-          prev = await fs14.readFile(absPath, "utf8");
+          prev = await fs2.readFile(absPath, "utf8");
           ctx.recordRead(absPath, stat12.mtimeMs);
         } else {
-          prev = await fs14.readFile(absPath, "utf8");
+          prev = await fs2.readFile(absPath, "utf8");
         }
       }
     } catch (err) {
@@ -9151,7 +9825,7 @@ var writeTool = {
     await atomicWrite(absPath, input.content);
     const diff = existed ? unifiedDiff(prev, input.content, { fromFile: input.path, toFile: input.path }) : `+++ ${input.path}
 + (new file, ${input.content.split("\n").length} lines)`;
-    const stat11 = await fs14.stat(absPath);
+    const stat11 = await fs2.stat(absPath);
     ctx.recordRead(absPath, stat11.mtimeMs);
     ctx.session.recordFileChange({
       path: absPath,