indusagi 0.12.34 → 0.13.1

package/dist/agent.js

@@ -3509,6 +3509,23 @@ var MODELS = {
       },
       contextWindow: 204800,
       maxTokens: 131072
+    },
+    "MiniMax-M3": {
+      id: "MiniMax-M3",
+      name: "MiniMax-M3",
+      api: "anthropic-messages",
+      provider: "minimax",
+      baseUrl: "https://api.minimax.io/anthropic",
+      reasoning: true,
+      input: ["text", "image"],
+      cost: {
+        input: 0.6,
+        output: 2.4,
+        cacheRead: 0.12,
+        cacheWrite: 0
+      },
+      contextWindow: 1048576,
+      maxTokens: 512e3
     }
   },
   "minimax-cn": {
@@ -3579,6 +3596,23 @@ var MODELS = {
       },
       contextWindow: 204800,
       maxTokens: 131072
+    },
+    "MiniMax-M3": {
+      id: "MiniMax-M3",
+      name: "MiniMax-M3",
+      api: "anthropic-messages",
+      provider: "minimax-cn",
+      baseUrl: "https://api.minimaxi.com/anthropic",
+      reasoning: true,
+      input: ["text", "image"],
+      cost: {
+        input: 0.6,
+        output: 2.4,
+        cacheRead: 0.12,
+        cacheWrite: 0
+      },
+      contextWindow: 1048576,
+      maxTokens: 512e3
     }
   },
   "mistral": {
@@ -13006,24 +13040,58 @@ function normalizeProviderError(error) {
   }
   return new SimpleOptionsProviderError("Unknown provider error", "unknown", error);
 }
+function abortReason(signal) {
+  const reason = signal.reason;
+  if (reason instanceof SimpleOptionsProviderError) return reason;
+  if (reason instanceof Error) return new SimpleOptionsProviderError(reason.message, "unknown", reason);
+  return new SimpleOptionsProviderError("Request was aborted", "unknown", reason);
+}
+function abortableSleep(ms, signal) {
+  return new Promise((resolve5, reject) => {
+    if (signal?.aborted) {
+      reject(abortReason(signal));
+      return;
+    }
+    let onAbort;
+    const timer = setTimeout(() => {
+      if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+      resolve5();
+    }, ms);
+    if (signal) {
+      onAbort = () => {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", onAbort);
+        reject(abortReason(signal));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
 async function executeWithRetry(operation, policy) {
   let attempt = 0;
   let lastError;
   while (attempt < policy.maxAttempts) {
+    if (policy.signal?.aborted) {
+      throw abortReason(policy.signal);
+    }
     attempt++;
     try {
       return await operation();
     } catch (error) {
       lastError = error;
       const normalized = normalizeProviderError(error);
+      if (policy.signal?.aborted) {
+        throw normalized;
+      }
       const defaultRetryable = normalized.code === "rate_limit" || normalized.code === "timeout" || normalized.code === "network";
       const retryable = policy.shouldRetry ? policy.shouldRetry(error, attempt) : defaultRetryable;
       if (!retryable || attempt >= policy.maxAttempts) {
         throw normalized;
       }
       const maxDelay = policy.maxDelayMs ?? Number.MAX_SAFE_INTEGER;
-      const backoff = Math.min(policy.baseDelayMs * 2 ** (attempt - 1), maxDelay);
-      await new Promise((resolve5) => setTimeout(resolve5, backoff));
+      const retryAfterMs = policy.getRetryAfterMs?.(error) ?? null;
+      const backoff = retryAfterMs != null ? Math.min(retryAfterMs, maxDelay) : Math.min(policy.baseDelayMs * 2 ** (attempt - 1), maxDelay);
+      await abortableSleep(backoff, policy.signal);
     }
   }
   throw normalizeProviderError(lastError);
@@ -13499,6 +13567,30 @@ var AnthropicEventReducer = class {
     calculateCost(this.model, this.output.usage);
   }
 };
+function parseAnthropicRetryAfterMs(error) {
+  if (error instanceof Anthropic.APIError) {
+    const header = error.headers?.get?.("retry-after");
+    const seconds = header ? parseInt(header, 10) : Number.NaN;
+    if (!Number.isNaN(seconds) && seconds >= 0) return seconds * 1e3;
+  }
+  return null;
+}
+function shouldRetryAnthropic(error, _attempt) {
+  if (error instanceof Anthropic.APIError) {
+    const status = error.status;
+    if (status === 408 || status === 409 || status === 429 || status === 529) return true;
+    if (typeof status === "number" && status >= 500) return true;
+    if (typeof status === "number" && status >= 400 && status < 500) return false;
+    const body = `${error.message} ${JSON.stringify(error.error ?? "")}`.toLowerCase();
+    if (body.includes('"type":"overloaded_error"') || body.includes("overloaded")) return true;
+    return false;
+  }
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    return msg.includes("rate limit") || msg.includes("rate_limit") || msg.includes("timeout") || msg.includes("timed out") || msg.includes("network") || msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("overloaded");
+  }
+  return false;
+}
 var streamAnthropic = (model, context, options) => {
   const stream = new AssistantMessageEventStream();
   const output = createAssistantMessageOutput(model);
@@ -13526,8 +13618,16 @@ var streamAnthropic = (model, context, options) => {
           });
         },
         {
-          maxAttempts: options?.signal ? 1 : 3,
-          baseDelayMs: 250
+          // Transient retries are NO LONGER gated on signal presence:
+          // the live path always carries a signal, so the old ternary
+          // collapsed to a single attempt = zero retries on 429/529/5xx.
+          // Abort still short-circuits immediately (see executeWithRetry).
+          maxAttempts: 3,
+          baseDelayMs: 500,
+          maxDelayMs: 32e3,
+          signal: options?.signal,
+          shouldRetry: shouldRetryAnthropic,
+          getRetryAfterMs: parseAnthropicRetryAfterMs
         }
       );
       if (options?.signal?.aborted) {
@@ -18407,6 +18507,63 @@ var AgentTelemetry = class {
 // src/facade/bot/agent-loop.ts
 var errorHandler = new AgentErrorHandler();
 var telemetry = new AgentTelemetry();
+var READ_ONLY_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "read",
+  "ls",
+  "grep",
+  "find",
+  "websearch",
+  "webfetch",
+  "todoread"
+]);
+function maxToolConcurrency(override) {
+  if (typeof override === "number" && Number.isFinite(override) && override >= 1) {
+    return Math.floor(override);
+  }
+  const fromEnv = parseInt(
+    process.env.CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY || process.env.INDUS_MAX_TOOL_CONCURRENCY || "",
+    10
+  );
+  return Number.isFinite(fromEnv) && fromEnv >= 1 ? fromEnv : 10;
+}
+function isConcurrencySafe(toolCall, tools, readOnly) {
+  if (!readOnly.has(toolCall.name)) return false;
+  return Boolean(tools?.some((candidate) => candidate.name === toolCall.name));
+}
+function partitionToolCalls(calls, tools, readOnly) {
+  const batches = [];
+  for (const call of calls) {
+    const concurrent = isConcurrencySafe(call, tools, readOnly);
+    const trailing = batches[batches.length - 1];
+    if (concurrent && trailing && trailing.concurrent) {
+      trailing.calls.push(call);
+    } else {
+      batches.push({ concurrent, calls: [call] });
+    }
+  }
+  return batches;
+}
+async function runToolBatchConcurrently(calls, tools, signal, stream, limit, canUseTool) {
+  const results = new Array(calls.length);
+  let next = 0;
+  const poolSize = Math.max(1, Math.min(limit, calls.length));
+  const worker = async () => {
+    for (; ; ) {
+      const index = next++;
+      if (index >= calls.length) return;
+      const toolCall = calls[index];
+      const key = `tool:${toolCall.name}:${toolCall.id}`;
+      telemetry.start(key);
+      results[index] = await executeToolCall(toolCall, tools, signal, stream, {
+        emitMessageEvents: true,
+        canUseTool
+      });
+      telemetry.log(`tool:${toolCall.name}`, telemetry.end(key));
+    }
+  };
+  await Promise.all(Array.from({ length: poolSize }, () => worker()));
+  return results;
+}
 function agentLoop(prompts, context, config, signal, streamFn) {
   const stream = createAgentStream();
   void (async () => {
@@ -18496,7 +18653,12 @@ async function runLoop(liveContext, produced, config, signal, stream, streamFn)
           assistantMessage,
           signal,
           stream,
-          config.getSteeringMessages
+          config.getSteeringMessages,
+          {
+            readOnlyToolNames: config.readOnlyToolNames ?? READ_ONLY_TOOL_NAMES,
+            maxConcurrency: maxToolConcurrency(config.maxToolConcurrency),
+            canUseTool: config.canUseTool
+          }
         );
         for (const result of dispatch.toolResults) {
           toolResults.push(result);
@@ -18581,7 +18743,40 @@ async function executeToolCall(toolCall, tools, signal, stream, options) {
   let isError = false;
   try {
     if (!matchedTool) throw new Error(`No registered tool named "${toolCall.name}".`);
-    const validatedArgs = validateToolArguments(matchedTool, toolCall);
+    let validatedArgs = validateToolArguments(matchedTool, toolCall);
+    if (options.canUseTool) {
+      const decision = await options.canUseTool(toolCall.name, validatedArgs, { signal });
+      if (decision.behavior === "deny") {
+        const denied = {
+          content: [{ type: "text", text: decision.message }],
+          details: {},
+          isError: true
+        };
+        stream.push({
+          type: "tool_execution_end",
+          toolCallId: toolCall.id,
+          toolName: toolCall.name,
+          result: denied,
+          isError: true
+        });
+        const deniedMessage = {
+          role: "toolResult",
+          toolCallId: toolCall.id,
+          toolName: toolCall.name,
+          content: denied.content,
+          details: denied.details,
+          isError: true,
+          timestamp: Date.now()
+        };
+        if (options.emitMessageEvents) {
+          emitMessageStartEnd(stream, deniedMessage);
+        }
+        return deniedMessage;
+      }
+      if (decision.updatedInput !== void 0) {
+        validatedArgs = decision.updatedInput;
+      }
+    }
     result = await matchedTool.execute(toolCall.id, validatedArgs, signal, (partialResult) => {
       stream.push({
         type: "tool_execution_update",
@@ -18621,16 +18816,30 @@ async function executeToolCall(toolCall, tools, signal, stream, options) {
   }
   return toolResultMessage;
 }
-async function executeToolCalls(tools, assistantMessage, signal, stream, getSteeringMessages) {
+async function executeToolCalls(tools, assistantMessage, signal, stream, getSteeringMessages, options) {
   const requestedCalls = assistantMessage.content.filter((c) => c.type === "toolCall");
+  const readOnly = options?.readOnlyToolNames ?? READ_ONLY_TOOL_NAMES;
+  const limit = options?.maxConcurrency ?? maxToolConcurrency();
+  const canUseTool = options?.canUseTool;
   const results = [];
   let steeringMessages;
-  for (let index = 0; index < requestedCalls.length; index++) {
-    const toolCall = requestedCalls[index];
-    telemetry.start(`tool:${toolCall.name}`);
-    const toolResult = await executeToolCall(toolCall, tools, signal, stream, { emitMessageEvents: true });
-    telemetry.log(`tool:${toolCall.name}`, telemetry.end(`tool:${toolCall.name}`));
-    results.push(toolResult);
+  const batches = partitionToolCalls(requestedCalls, tools, readOnly);
+  let dispatched = 0;
+  for (const batch of batches) {
+    if (batch.concurrent && batch.calls.length > 1) {
+      const batchResults = await runToolBatchConcurrently(batch.calls, tools, signal, stream, limit, canUseTool);
+      results.push(...batchResults);
+    } else {
+      const toolCall = batch.calls[0];
+      telemetry.start(`tool:${toolCall.name}`);
+      const toolResult = await executeToolCall(toolCall, tools, signal, stream, {
+        emitMessageEvents: true,
+        canUseTool
+      });
+      telemetry.log(`tool:${toolCall.name}`, telemetry.end(`tool:${toolCall.name}`));
+      results.push(toolResult);
+    }
+    dispatched += batch.calls.length;
     if (!getSteeringMessages) {
       continue;
     }
@@ -18639,7 +18848,7 @@ async function executeToolCalls(tools, assistantMessage, signal, stream, getStee
       continue;
     }
     steeringMessages = steering;
-    for (const skipped of requestedCalls.slice(index + 1)) {
+    for (const skipped of requestedCalls.slice(dispatched)) {
       results.push(skipToolCall(skipped, stream));
     }
     break;
@@ -18868,6 +19077,7 @@ var LoopConfigFactory = class {
       convertToLlm: args.convertToLlm,
       transformContext: args.transformContext,
       getApiKey: args.getApiKey,
+      canUseTool: args.canUseTool,
       getSteeringMessages: args.getSteeringMessages,
       getFollowUpMessages: args.getFollowUpMessages
     };
@@ -18940,6 +19150,7 @@ var Agent = class {
   streamFn;
   _sessionId;
   getApiKey;
+  canUseTool;
   runningPrompt;
   resolveRunningPrompt;
   _thinkingBudgets;
@@ -18950,6 +19161,7 @@ var Agent = class {
     this.streamFn = opts.streamFn || streamSimple;
     this._sessionId = opts.sessionId;
     this.getApiKey = opts.getApiKey;
+    this.canUseTool = opts.canUseTool;
     this._thinkingBudgets = opts.thinkingBudgets;
     this.queuePolicy = new MessageQueuePolicy(opts.steeringMode || "one-at-a-time", opts.followUpMode || "one-at-a-time");
   }
@@ -19109,6 +19321,7 @@ var Agent = class {
       convertToLlm: this.convertToLlm,
       transformContext: this.transformContext,
       getApiKey: this.getApiKey,
+      canUseTool: this.canUseTool,
       getSteeringMessages: async () => this.queuePolicy.dequeueSteeringMessages(),
       getFollowUpMessages: async () => this.queuePolicy.dequeueFollowUpMessages()
     });
@@ -19421,7 +19634,7 @@ function isToolCall(value) {
 // src/facade/bot/actions/bash.ts
 import { randomBytes } from "node:crypto";
 import { createWriteStream, existsSync as existsSync2 } from "node:fs";
-import { tmpdir } from "node:os";
+import { tmpdir as tmpdir2 } from "node:os";
 import { join } from "node:path";
 import { Type as Type2 } from "@sinclair/typebox";
 import { spawn as spawn2 } from "child_process";
@@ -19500,6 +19713,128 @@ function killProcessTree(pid) {
   }
 }
 
+// src/facade/bot/actions/sandbox-backend.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { tmpdir } from "node:os";
+function resolveWritableRoots(config, cwd) {
+  const tmp = config.tmpDir ?? tmpdir();
+  const extra = config.writableRoots ?? [];
+  const seen = /* @__PURE__ */ new Set();
+  const roots = [];
+  for (const p of [cwd, tmp, ...extra]) {
+    if (p && !seen.has(p)) {
+      seen.add(p);
+      roots.push(p);
+    }
+  }
+  return roots;
+}
+function escapeSeatbeltPath(p) {
+  return p.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function buildSeatbeltProfile(config, cwd) {
+  const roots = resolveWritableRoots(config, cwd);
+  const writeRules = roots.map((p) => `(allow file-write* (subpath "${escapeSeatbeltPath(p)}"))`).join("\n");
+  const networkRule = config.allowNetwork ? "(allow network*)" : "(deny network* (with no-log))";
+  return [
+    "(version 1)",
+    "(deny default)",
+    // Allow the command and its children to run.
+    "(allow process-exec)",
+    "(allow process-fork)",
+    "(allow signal (target same-sandbox))",
+    "(allow sysctl-read)",
+    // Read is permitted everywhere; the boundary we enforce is on writes.
+    "(allow file-read*)",
+    writeRules,
+    networkRule
+  ].filter((line) => line.length > 0).join("\n");
+}
+function buildSeatbeltArgv(config, cwd, command) {
+  const profile = buildSeatbeltProfile(config, cwd);
+  return ["sandbox-exec", "-p", profile, "/bin/sh", "-c", command];
+}
+function buildBwrapArgv(config, cwd, command) {
+  const roots = resolveWritableRoots(config, cwd);
+  const argv = ["bwrap", "--ro-bind", "/", "/"];
+  for (const root of roots) {
+    argv.push("--bind", root, root);
+  }
+  argv.push("--dev", "/dev", "--proc", "/proc");
+  if (!config.allowNetwork) {
+    argv.push("--unshare-net");
+  }
+  argv.push("--chdir", cwd, "/bin/sh", "-c", command);
+  return argv;
+}
+function binaryOnPath(binary) {
+  try {
+    const result = spawnSync2("/bin/sh", ["-c", `command -v ${binary}`], {
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    return result.status === 0 && typeof result.stdout === "string" && result.stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function sandboxAvailability(platform = process.platform, probe = binaryOnPath) {
+  if (platform === "darwin") {
+    const binaryPresent = probe("sandbox-exec");
+    return {
+      platform: "macos",
+      binary: "sandbox-exec",
+      binaryPresent,
+      reason: binaryPresent ? void 0 : "sandbox-exec not found on PATH"
+    };
+  }
+  if (platform === "linux") {
+    const binaryPresent = probe("bwrap");
+    return {
+      platform: "linux",
+      binary: "bwrap",
+      binaryPresent,
+      reason: binaryPresent ? void 0 : "bwrap (bubblewrap) not found on PATH"
+    };
+  }
+  return {
+    platform: "unsupported",
+    binary: null,
+    binaryPresent: false,
+    reason: `OS sandbox is not supported on platform "${platform}"`
+  };
+}
+function buildSandboxArgv(config, cwd, command, availability = sandboxAvailability()) {
+  if (!availability.binaryPresent) return null;
+  if (availability.platform === "macos") return buildSeatbeltArgv(config, cwd, command);
+  if (availability.platform === "linux") return buildBwrapArgv(config, cwd, command);
+  return null;
+}
+function shellQuote(token) {
+  return `'${token.replace(/'/g, "'\\''")}'`;
+}
+function argvToCommandString(argv) {
+  return argv.map(shellQuote).join(" ");
+}
+function createSandboxedBashOperations(config, options) {
+  if (!config.enabled) return options.base;
+  const availability = options.availability ?? sandboxAvailability();
+  return {
+    exec: (command, cwd, execOptions) => {
+      const argv = buildSandboxArgv(config, cwd, command, availability);
+      if (!argv) {
+        options.onNote?.(
+          `sandbox NOT applied (${availability.reason ?? "unavailable"}); ran un-sandboxed`
+        );
+        return options.base.exec(command, cwd, execOptions);
+      }
+      options.onNote?.(`sandbox applied via ${availability.binary}`);
+      const wrapped = argvToCommandString(argv);
+      return options.base.exec(wrapped, cwd, execOptions);
+    }
+  };
+}
+
 // src/facade/bot/actions/truncate.ts
 var DEFAULT_MAX_LINES = 2500;
 var DEFAULT_MAX_BYTES = 64 * 1024;
@@ -19687,7 +20022,7 @@ function truncateLine(line, maxChars = GREP_MAX_LINE_LENGTH) {
 // src/facade/bot/actions/bash.ts
 function allocateSpillFilePath() {
   const suffix = randomBytes(8).toString("hex");
-  return join(tmpdir(), `indusvx-bash-${suffix}.log`);
+  return join(tmpdir2(), `indusvx-bash-${suffix}.log`);
 }
 var BashCommandBuilder = class {
   constructor(prefix) {
@@ -19864,9 +20199,15 @@ ${note}` : note);
   }
 };
 var DEFAULT_BLOCKED_PATTERNS = [/\brm\s+-rf\s+\/$/, /:\(\)\s*\{\s*:\|:\s*&\s*\};:/];
+var DEFAULT_BASH_TIMEOUT_SECONDS = 120;
+var MAX_BASH_TIMEOUT_SECONDS = 600;
+function computeEffectiveTimeout(requested, def, max) {
+  const base = requested !== void 0 && requested > 0 ? requested : def;
+  return Math.min(base, max);
+}
 var bashSchema = Type2.Object({
   command: Type2.String({ description: "The bash command line to execute" }),
-  timeout: Type2.Optional(Type2.Number({ description: "Optional limit, in seconds, after which the command is terminated. No limit applies when omitted." }))
+  timeout: Type2.Optional(Type2.Number({ description: `Optional limit, in seconds, after which the command is terminated (default ${DEFAULT_BASH_TIMEOUT_SECONDS}s, max ${MAX_BASH_TIMEOUT_SECONDS}s).` }))
 });
 var defaultBashOperations = {
   exec: (command, cwd, { onData, signal, timeout, env }) => {
@@ -19932,21 +20273,28 @@ var defaultBashOperations = {
   }
 };
 function createBashTool(cwd, options) {
-  const ops = options?.operations ?? defaultBashOperations;
+  const baseOps = options?.operations ?? defaultBashOperations;
+  const ops = options?.sandbox?.enabled ? createSandboxedBashOperations(options.sandbox, {
+    base: baseOps,
+    onNote: options.onSandboxNote
+  }) : baseOps;
   const commandBuilder = new BashCommandBuilder(options?.commandPrefix);
   const securityPolicy = new BashSecurityPolicy(
     options?.security?.blockedPatterns ?? DEFAULT_BLOCKED_PATTERNS,
     options?.commandHistory
   );
   const hookRunner = options?.hookRunner;
+  const defaultTimeoutSeconds = options?.defaultTimeoutSeconds ?? DEFAULT_BASH_TIMEOUT_SECONDS;
+  const maxTimeoutSeconds = Math.max(options?.maxTimeoutSeconds ?? MAX_BASH_TIMEOUT_SECONDS, defaultTimeoutSeconds);
   return {
     name: "bash",
     label: "bash",
-    description: `Execute a bash command in the current working directory and return its merged stdout and stderr. At most the final ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB are returned, whichever limit is hit first; once that occurs the complete output is saved to a temp file. An optional timeout in seconds may be supplied.`,
+    description: `Execute a bash command in the current working directory and return its merged stdout and stderr. At most the final ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB are returned, whichever limit is hit first; once that occurs the complete output is saved to a temp file. An optional timeout in seconds may be supplied. Commands time out after ${defaultTimeoutSeconds}s by default (max ${maxTimeoutSeconds}s).`,
     parameters: bashSchema,
     execute: async (_toolCallId, { command, timeout }, signal, onUpdate) => {
       securityPolicy.assertAllowed(command);
       securityPolicy.record(command);
+      const effectiveTimeout = computeEffectiveTimeout(timeout, defaultTimeoutSeconds, maxTimeoutSeconds);
       const resolvedCommand = commandBuilder.build(command);
       const hookEnv = hookRunner?.hasHandlers("shell.env") ? (await hookRunner.trigger("shell.env", { cwd }, { env: {} })).env : void 0;
       const safeEnv = hookEnv ? Object.fromEntries(
@@ -19958,7 +20306,7 @@ function createBashTool(cwd, options) {
         ops.exec(resolvedCommand, cwd, {
           onData: (data) => outputCapture.appendChunk(data, emitPartial),
           signal,
-          timeout,
+          timeout: effectiveTimeout,
           env: safeEnv
         }).then(({ exitCode }) => {
           outputCapture.close();
@@ -20291,6 +20639,216 @@ async function computeEditDiff(path9, oldText, newText, cwd) {
   return computation.compute(path9, oldText, newText);
 }
 
+// src/facade/bot/actions/edit-utils.ts
+import { readdirSync } from "node:fs";
+import { realpath, stat } from "node:fs/promises";
+import { basename, dirname, extname, join as join2, relative, sep } from "node:path";
+var LEFT_SINGLE_CURLY_QUOTE = "\u2018";
+var RIGHT_SINGLE_CURLY_QUOTE = "\u2019";
+var LEFT_DOUBLE_CURLY_QUOTE = "\u201C";
+var RIGHT_DOUBLE_CURLY_QUOTE = "\u201D";
+function isOpeningContext(chars, index) {
+  if (index === 0) {
+    return true;
+  }
+  const prev = chars[index - 1];
+  return prev === " " || prev === "	" || prev === "\n" || prev === "\r" || prev === "(" || prev === "[" || prev === "{" || prev === "\u2014" || // em dash
+  prev === "\u2013";
+}
+function applyCurlyDoubleQuotes(str) {
+  const chars = [...str];
+  const result = [];
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] === '"') {
+      result.push(isOpeningContext(chars, i) ? LEFT_DOUBLE_CURLY_QUOTE : RIGHT_DOUBLE_CURLY_QUOTE);
+    } else {
+      result.push(chars[i]);
+    }
+  }
+  return result.join("");
+}
+function applyCurlySingleQuotes(str) {
+  const chars = [...str];
+  const result = [];
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] === "'") {
+      const prev = i > 0 ? chars[i - 1] : void 0;
+      const next = i < chars.length - 1 ? chars[i + 1] : void 0;
+      const prevIsLetter = prev !== void 0 && new RegExp("\\p{L}", "u").test(prev);
+      const nextIsLetter = next !== void 0 && new RegExp("\\p{L}", "u").test(next);
+      if (prevIsLetter && nextIsLetter) {
+        result.push(RIGHT_SINGLE_CURLY_QUOTE);
+      } else {
+        result.push(isOpeningContext(chars, i) ? LEFT_SINGLE_CURLY_QUOTE : RIGHT_SINGLE_CURLY_QUOTE);
+      }
+    } else {
+      result.push(chars[i]);
+    }
+  }
+  return result.join("");
+}
+function preserveQuoteStyle(oldString, actualOldString, newString) {
+  if (oldString === actualOldString) {
+    return newString;
+  }
+  const hasDoubleQuotes = actualOldString.includes(LEFT_DOUBLE_CURLY_QUOTE) || actualOldString.includes(RIGHT_DOUBLE_CURLY_QUOTE);
+  const hasSingleQuotes = actualOldString.includes(LEFT_SINGLE_CURLY_QUOTE) || actualOldString.includes(RIGHT_SINGLE_CURLY_QUOTE);
+  if (!hasDoubleQuotes && !hasSingleQuotes) {
+    return newString;
+  }
+  let result = newString;
+  if (hasDoubleQuotes) {
+    result = applyCurlyDoubleQuotes(result);
+  }
+  if (hasSingleQuotes) {
+    result = applyCurlySingleQuotes(result);
+  }
+  return result;
+}
+var DESANITIZATIONS = {
+  "<fnr>": "<function_results>",
+  "<n>": "<name>",
+  "</n>": "</name>",
+  "<o>": "<output>",
+  "</o>": "</output>",
+  "<e>": "<error>",
+  "</e>": "</error>",
+  "<s>": "<system>",
+  "</s>": "</system>",
+  "<r>": "<result>",
+  "</r>": "</result>",
+  "< META_START >": "<META_START>",
+  "< META_END >": "<META_END>",
+  "< EOT >": "<EOT>",
+  "< META >": "<META>",
+  "< SOS >": "<SOS>",
+  "\n\nH:": "\n\nHuman:",
+  "\n\nA:": "\n\nAssistant:"
+};
+function desanitizeMatchString(matchString) {
+  let result = matchString;
+  const appliedReplacements = [];
+  for (const [from, to] of Object.entries(DESANITIZATIONS)) {
+    const beforeReplace = result;
+    result = result.split(from).join(to);
+    if (beforeReplace !== result) {
+      appliedReplacements.push({ from, to });
+    }
+  }
+  return { result, appliedReplacements };
+}
+function findSimilarFile(filePath) {
+  try {
+    const dir = dirname(filePath);
+    const fileBaseName = basename(filePath, extname(filePath));
+    const files = readdirSync(dir, { withFileTypes: true });
+    const similarFiles = files.filter(
+      (file) => basename(file.name, extname(file.name)) === fileBaseName && join2(dir, file.name) !== filePath
+    );
+    const firstMatch = similarFiles[0];
+    return firstMatch ? firstMatch.name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var FILE_NOT_FOUND_CWD_NOTE = "Note: your current working directory is";
+async function suggestPathUnderCwd(requestedPath, cwd) {
+  const cwdParent = dirname(cwd);
+  let resolvedPath = requestedPath;
+  try {
+    const resolvedDir = await realpath(dirname(requestedPath));
+    resolvedPath = join2(resolvedDir, basename(requestedPath));
+  } catch {
+  }
+  const cwdParentPrefix = cwdParent === sep ? sep : cwdParent + sep;
+  if (!resolvedPath.startsWith(cwdParentPrefix) || resolvedPath.startsWith(cwd + sep) || resolvedPath === cwd) {
+    return void 0;
+  }
+  const relFromParent = relative(cwdParent, resolvedPath);
+  const correctedPath = join2(cwd, relFromParent);
+  try {
+    await stat(correctedPath);
+    return correctedPath;
+  } catch {
+    return void 0;
+  }
+}
+function replaceAllLiteral(haystack, needle, value) {
+  if (needle.length === 0) return haystack;
+  const pieces = [];
+  let from = 0;
+  for (; ; ) {
+    const at = haystack.indexOf(needle, from);
+    if (at === -1) {
+      pieces.push(haystack.slice(from));
+      break;
+    }
+    pieces.push(haystack.slice(from, at), value);
+    from = at + needle.length;
+  }
+  return pieces.join("");
+}
+
+// src/facade/bot/actions/checkpoint.ts
+import { readFileSync, statSync } from "node:fs";
+function recordCheckpoint(handle, absPath) {
+  if (!handle) return;
+  let previous;
+  try {
+    statSync(absPath);
+    previous = readFileSync(absPath, "utf-8");
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      previous = null;
+    } else {
+      return;
+    }
+  }
+  try {
+    handle.record(absPath, previous);
+  } catch {
+  }
+}
+
+// src/facade/bot/actions/read-state.ts
+import { statSync as statSync2 } from "node:fs";
+var READ_BEFORE_EDIT_MESSAGE = "File has not been read yet. Read it first before writing to it.";
+var MODIFIED_SINCE_READ_MESSAGE = "File has been modified since read, either by the user or by a linter. Read it again before attempting to write it.";
+function recordReadState(handle, absPath) {
+  if (!handle) return;
+  try {
+    const info = statSync2(absPath);
+    const mtimeMs = Math.floor(info.mtimeMs);
+    handle.set(absPath, {
+      mtimeMs,
+      size: info.size,
+      readAt: mtimeMs
+    });
+  } catch {
+  }
+}
+function enforceReadGate(handle, absPath) {
+  if (!handle) return { ok: true };
+  if (!handle.has(absPath)) {
+    return { ok: false, message: READ_BEFORE_EDIT_MESSAGE };
+  }
+  const recorded = handle.get(absPath);
+  if (!recorded) {
+    return { ok: false, message: READ_BEFORE_EDIT_MESSAGE };
+  }
+  let info;
+  try {
+    info = statSync2(absPath);
+  } catch {
+    return { ok: true };
+  }
+  const currentMtime = Math.floor(info.mtimeMs);
+  if (currentMtime > recorded.mtimeMs || info.size !== recorded.size) {
+    return { ok: false, message: MODIFIED_SINCE_READ_MESSAGE };
+  }
+  return { ok: true };
+}
+
 // src/facade/bot/actions/edit.ts
 var ExactThenFuzzyStrategy = class {
   find(content, oldText) {
@@ -20311,7 +20869,12 @@ function rejectWith(message) {
 var editSchema = Type3.Object({
   path: Type3.String({ description: "File to modify, given as a relative or absolute path" }),
   oldText: Type3.String({ description: "The current text to locate; it must be reproduced verbatim" }),
-  newText: Type3.String({ description: "The text that should take the place of oldText" })
+  newText: Type3.String({ description: "The text that should take the place of oldText" }),
+  replaceAll: Type3.Optional(
+    Type3.Boolean({
+      description: "Replace every occurrence of oldText instead of requiring a single unique match. Defaults to false, which refuses the edit when oldText appears more than once."
+    })
+  )
 });
 var defaultEditOperations = {
   readFile: (path9) => fsReadFile(path9),
@@ -20353,38 +20916,76 @@ function withAbort(signal, task) {
   });
 }
 var EditSession = class {
-  constructor(input, absolutePath, ops, matchingStrategy) {
+  constructor(input, absolutePath, ops, matchingStrategy, cwd, readState, checkpoint) {
     this.input = input;
     this.absolutePath = absolutePath;
     this.ops = ops;
     this.matchingStrategy = matchingStrategy;
+    this.cwd = cwd;
+    this.readState = readState;
+    this.checkpoint = checkpoint;
+    this.replaceAll = input.replaceAll === true;
   }
   input;
   absolutePath;
   ops;
   matchingStrategy;
+  cwd;
+  readState;
+  checkpoint;
+  /** Whether every occurrence should be swapped (vs. requiring a unique hit). */
+  replaceAll;
   async run(throwIfAborted2) {
     throwIfAborted2();
+    const gate = enforceReadGate(this.readState, this.absolutePath);
+    if (!gate.ok) {
+      rejectWith(gate.message);
+    }
+    recordCheckpoint(this.checkpoint, this.absolutePath);
     const { sourceText } = await this.loadSource();
     throwIfAborted2();
     const normalized = this.normalizeInputs(sourceText);
-    const match = this.locateUniqueMatch(normalized);
-    const replacement = this.applyReplacement(normalized, match);
+    const search = this.resolveSearch(normalized);
+    const match = this.locateUniqueMatch(normalized, search);
+    const replacement = this.applyReplacement(normalized, search, match);
     throwIfAborted2();
     await this.persist(replacement.finalContent);
     throwIfAborted2();
-    return this.buildResponse(replacement.editableBase, replacement.replacedContent);
+    return this.buildResponse(replacement.editableBase, replacement.replacedContent, replacement.replacements);
   }
   async loadSource() {
     try {
       await this.ops.access(this.absolutePath);
     } catch {
-      rejectWith(`No readable file at ${this.input.path}.`);
+      rejectWith(await this.buildNotFoundMessage());
     }
     const buffer = await this.ops.readFile(this.absolutePath);
     const sourceText = buffer.toString("utf-8");
     return { sourceText };
   }
+  /**
+   * Compose the "No readable file …" rejection, enriched with a "Did you mean
+   * …?" hint when we can spot either a sibling file sharing the base name or a
+   * corrected path re-rooted under the working directory. Falls back to the
+   * bare message when no suggestion applies, so the default behaviour is
+   * preserved for the common case.
+   */
+  async buildNotFoundMessage() {
+    let message = `No readable file at ${this.input.path}. ${FILE_NOT_FOUND_CWD_NOTE} ${this.cwd}.`;
+    try {
+      const cwdSuggestion = await suggestPathUnderCwd(this.absolutePath, this.cwd);
+      if (cwdSuggestion) {
+        message += ` Did you mean ${cwdSuggestion}?`;
+        return message;
+      }
+      const similarFilename = findSimilarFile(this.absolutePath);
+      if (similarFilename) {
+        message += ` Did you mean ${similarFilename}?`;
+      }
+    } catch {
+    }
+    return message;
+  }
   normalizeInputs(sourceText) {
     const { bom, text } = stripBom(sourceText);
     const originalEnding = detectLineEnding(text);
@@ -20399,41 +21000,106 @@ var EditSession = class {
       normalizedNewText
     };
   }
-  locateUniqueMatch(normalized) {
-    const matchResult = this.matchingStrategy.find(normalized.normalizedContent, normalized.normalizedOldText);
+  /**
+   * Decide which oldText/newText pair to actually edit with. The literal
+   * normalized inputs win whenever they appear in the file; only when they are
+   * absent do we try a de-sanitized variant (repairing mangled tag tokens like
+   * `<o>` → `<output>`), mirroring the same token expansions onto newText so
+   * the replacement stays consistent. The de-sanitize table overlaps ordinary
+   * code, so it is deliberately a *fallback*, never the first attempt.
+   */
+  resolveSearch(normalized) {
+    const literal = {
+      searchOldText: normalized.normalizedOldText,
+      searchNewText: normalized.normalizedNewText
+    };
+    if (this.matchingStrategy.find(normalized.normalizedContent, normalized.normalizedOldText).found) {
+      return literal;
+    }
+    const { result: desanitizedOldText, appliedReplacements } = desanitizeMatchString(
+      normalized.normalizedOldText
+    );
+    if (appliedReplacements.length === 0) {
+      return literal;
+    }
+    if (!this.matchingStrategy.find(normalized.normalizedContent, desanitizedOldText).found) {
+      return literal;
+    }
+    let desanitizedNewText = normalized.normalizedNewText;
+    for (const { from, to } of appliedReplacements) {
+      desanitizedNewText = desanitizedNewText.split(from).join(to);
+    }
+    return { searchOldText: desanitizedOldText, searchNewText: desanitizedNewText };
+  }
+  locateUniqueMatch(normalized, search) {
+    const matchResult = this.matchingStrategy.find(normalized.normalizedContent, search.searchOldText);
     if (!matchResult.found) {
       rejectWith(
         `The supplied text was not located in ${this.input.path}. It has to line up character for character, including every space and line break.`
       );
     }
     const fuzzyContent = normalizeForFuzzyMatch(normalized.normalizedContent);
-    const fuzzyOldText = normalizeForFuzzyMatch(normalized.normalizedOldText);
+    const fuzzyOldText = normalizeForFuzzyMatch(search.searchOldText);
     const matchCount = fuzzyContent.split(fuzzyOldText).length - 1;
-    if (matchCount > 1) {
+    if (matchCount > 1 && !this.replaceAll) {
       rejectWith(
-        `The text appears ${matchCount} times in ${this.input.path}, so the target is ambiguous. Include surrounding lines so it matches in exactly one place.`
+        `The text appears ${matchCount} times in ${this.input.path}, so the target is ambiguous. Include surrounding lines so it matches in exactly one place, or set replaceAll to true to change every occurrence.`
       );
     }
     return { matchResult, matchCount };
   }
-  applyReplacement(normalized, match) {
-    const editableBase = match.matchResult.contentForReplacement;
-    const replacedContent = editableBase.substring(0, match.matchResult.index) + normalized.normalizedNewText + editableBase.substring(match.matchResult.index + match.matchResult.matchLength);
+  applyReplacement(normalized, search, match) {
+    const usedFuzzy = match.matchResult.usedFuzzyMatch;
+    const matchedNeedle = usedFuzzy ? this.recoverOriginalSpan(normalized.normalizedContent, search.searchOldText) : search.searchOldText;
+    const editableBase = normalized.normalizedContent;
+    const replacementText = usedFuzzy ? preserveQuoteStyle(search.searchOldText, matchedNeedle, search.searchNewText) : search.searchNewText;
+    const firstIndex = editableBase.indexOf(matchedNeedle);
+    if (firstIndex === -1) {
+      rejectWith(
+        `The supplied text was not located in ${this.input.path}. It has to line up character for character, including every space and line break.`
+      );
+    }
+    const replacedContent = this.replaceAll ? replaceAllLiteral(editableBase, matchedNeedle, replacementText) : editableBase.substring(0, firstIndex) + replacementText + editableBase.substring(firstIndex + matchedNeedle.length);
     if (editableBase === replacedContent) {
       rejectWith(
         `The edit left ${this.input.path} unchanged because the replacement matches the original. Often this points to unexpected special characters or text that is not actually present.`
       );
     }
+    const replacements = this.replaceAll ? Math.max(match.matchCount, 1) : 1;
     const finalContent = normalized.bom + restoreLineEndings(replacedContent, normalized.originalEnding);
-    return { editableBase, replacedContent, finalContent };
+    return { editableBase, replacedContent, finalContent, replacements };
+  }
+  /**
+   * Recover the original (un-folded) span in `content` whose glyph-folded form
+   * equals the folded `searchOldText`. Mirrors induscode's `findActualString`:
+   * locate the match in fully-folded space, then slice the same window out of
+   * the original content so curly quotes and other glyphs are preserved. Falls
+   * back to the supplied text if the window can't be recovered.
+   */
+  recoverOriginalSpan(content, searchOldText) {
+    const foldedContent = normalizeForFuzzyMatch(content);
+    const foldedNeedle = normalizeForFuzzyMatch(searchOldText);
+    const at = foldedContent.indexOf(foldedNeedle);
+    if (at === -1) {
+      return searchOldText;
+    }
+    for (let len = foldedNeedle.length; at + len <= content.length; len++) {
+      const candidate = content.slice(at, at + len);
+      if (normalizeForFuzzyMatch(candidate) === foldedNeedle) {
+        return candidate;
+      }
+    }
+    return content.slice(at, at + foldedNeedle.length);
   }
   async persist(finalContent) {
     await this.ops.writeFile(this.absolutePath, finalContent);
+    recordReadState(this.readState, this.absolutePath);
   }
-  buildResponse(editableBase, replacedContent) {
+  buildResponse(editableBase, replacedContent, replacements) {
     const diffResult = generateDiffString(editableBase, replacedContent);
+    const summary = replacements > 1 ? `Replaced the target text in ${this.input.path} (${replacements} occurrences).` : `Replaced the target text in ${this.input.path}.`;
     return {
-      content: [{ type: "text", text: `Replaced the target text in ${this.input.path}.` }],
+      content: [{ type: "text", text: summary }],
       details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine }
     };
   }
@@ -20451,12 +21117,20 @@ function createEditTool(cwd, options) {
   return {
     name: "edit",
     label: "edit",
-    description: "Make a targeted change to a file by swapping one exact span of text for another. Provide oldText that reproduces the existing content character for character, whitespace included. Best for narrow, precise edits.",
+    description: "Make a targeted change to a file by swapping one exact span of text for another. Provide oldText that reproduces the existing content character for character, whitespace included. Best for narrow, precise edits. By default oldText must match exactly once; set replaceAll to true to change every occurrence instead.",
     parameters: editSchema,
     execute: async (_toolCallId, input, signal) => {
       validator.validate(input.path, input.oldText);
       const absolutePath = resolveToCwd(input.path, cwd);
-      const session = new EditSession(input, absolutePath, ops, matchingStrategy);
+      const session = new EditSession(
+        input,
+        absolutePath,
+        ops,
+        matchingStrategy,
+        cwd,
+        options?.readState,
+        options?.checkpoint
+      );
       return withAbort(signal, async ({ throwIfAborted: throwIfAborted2 }) => session.run(throwIfAborted2));
     }
   };
@@ -20465,28 +21139,96 @@ var editTool = createEditTool(process.cwd());
 
 // src/facade/bot/actions/find.ts
 import { Type as Type4 } from "@sinclair/typebox";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync3, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
 import path from "path";
 var findSchema = Type4.Object({
   pattern: Type4.String({
     description: 'Glob that the filenames should match, such as "*.ts", "**/*.json", or "lib/**/*.test.ts"'
   }),
   path: Type4.Optional(Type4.String({ description: "Directory tree to traverse. Falls back to the working directory." })),
+  type: Type4.Optional(
+    Type4.String({
+      description: `Restrict results to a language/category (for example "ts", "js", "py"). Filters by the entry's file extension. Defaults to no type filter.`
+    })
+  ),
   limit: Type4.Optional(Type4.Number({ description: "Maximum count of paths handed back. Defaults to 1024." }))
 });
 var DEFAULT_LIMIT = 1024;
 var DEFAULT_EXCLUDES = ["node_modules", ".git"];
 var MAX_DIRECTORY_DEPTH = 20;
+function escapeRegexLiteral(literal) {
+  return literal.replace(/[\\.*+?^${}()|[\]]/g, "\\$&");
+}
+function compileGlob(pattern) {
+  let body = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      if (pattern[i + 1] === "*") {
+        i++;
+        if (pattern[i + 1] === "/") {
+          i++;
+          body += "(?:[^/]*/)*";
+        } else {
+          body += ".*";
+        }
+      } else {
+        body += "[^/]*";
+      }
+    } else if (ch === "?") {
+      body += "[^/]";
+    } else {
+      body += escapeRegexLiteral(ch);
+    }
+  }
+  try {
+    return new RegExp(`^${body}$`);
+  } catch {
+    return null;
+  }
+}
 var GlobMatcher = class {
-  regex;
+  relRegex;
+  baseRegex;
+  hasSeparator;
   constructor(pattern) {
-    const regexPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".").replace(/\./g, "\\.");
-    this.regex = new RegExp(`^${regexPattern}$`);
-  }
-  matches(value) {
-    return this.regex.test(value);
+    this.hasSeparator = pattern.includes("/");
+    this.relRegex = compileGlob(pattern);
+    this.baseRegex = this.hasSeparator ? null : this.relRegex;
+  }
+  /** Test against the root-relative path (preferred), falling back to basename. */
+  matchesPath(relativePath) {
+    const normalized = relativePath.split(path.sep).join("/");
+    if (this.relRegex && this.relRegex.test(normalized)) {
+      return true;
+    }
+    if (this.baseRegex) {
+      const base = normalized.slice(normalized.lastIndexOf("/") + 1);
+      return this.baseRegex.test(base);
+    }
+    return false;
   }
 };
+function typeToExtensions(type) {
+  const key = type.trim().toLowerCase();
+  if (key.length === 0) return null;
+  const TABLE = {
+    ts: ["ts", "tsx", "mts", "cts"],
+    js: ["js", "jsx", "mjs", "cjs"],
+    py: ["py", "pyi"],
+    rs: ["rs"],
+    go: ["go"],
+    java: ["java"],
+    c: ["c", "h"],
+    cpp: ["cpp", "cc", "cxx", "hpp", "hh"],
+    md: ["md", "markdown"],
+    json: ["json"],
+    yaml: ["yaml", "yml"],
+    sh: ["sh", "bash", "zsh"]
+  };
+  const exts = TABLE[key] ?? [key];
+  return new Set(exts.map((e) => e.toLowerCase()));
+}
 var DirectoryWalkPolicy = class {
   constructor(limit) {
     this.limit = limit;
@@ -20500,39 +21242,50 @@ var DirectoryWalkPolicy = class {
   }
 };
 var DirectoryFinder = class {
-  constructor(matcher, walkPolicy, limit) {
+  constructor(matcher, walkPolicy, limit, root, typeExtensions) {
     this.matcher = matcher;
     this.walkPolicy = walkPolicy;
     this.limit = limit;
+    this.root = root;
+    this.typeExtensions = typeExtensions;
   }
   matcher;
   walkPolicy;
   limit;
-  fs = __require("fs");
+  root;
+  typeExtensions;
   async find(dir) {
     const results = [];
     await this.searchRecursive(dir, 0, results);
     return results;
   }
+  extensionOf(name) {
+    const dot = name.lastIndexOf(".");
+    return dot > 0 ? name.slice(dot + 1).toLowerCase() : "";
+  }
   async searchRecursive(currentDir, depth, results) {
     if (!this.walkPolicy.canContinue(results.length, depth)) {
       return;
     }
     try {
-      const entries = this.fs.readdirSync(currentDir);
+      const entries = readdirSync2(currentDir);
       for (const entry of entries) {
         if (results.length >= this.limit) {
           break;
         }
         const fullPath = path.join(currentDir, entry);
-        const stat2 = this.fs.statSync(fullPath);
-        if (stat2.isDirectory()) {
+        const stat3 = statSync3(fullPath);
+        if (stat3.isDirectory()) {
           if (this.walkPolicy.shouldDescend(entry)) {
             await this.searchRecursive(fullPath, depth + 1, results);
           }
           continue;
         }
-        if (this.matcher.matches(entry)) {
+        if (this.typeExtensions && !this.typeExtensions.has(this.extensionOf(entry))) {
+          continue;
+        }
+        const relativePath = path.relative(this.root, fullPath);
+        if (this.matcher.matchesPath(relativePath)) {
           results.push(fullPath);
         }
       }
@@ -20587,9 +21340,10 @@ function createFindTool(cwd, options) {
   return {
     name: "find",
     label: "find",
+    readOnly: true,
     description: `Find files whose names match a glob, returning each result as a path relative to the directory that was searched. The listing halts at ${DEFAULT_LIMIT} paths or ${DEFAULT_MAX_BYTES / 1024}KB of output, whichever it reaches first.`,
     parameters: findSchema,
-    execute: async (_toolCallId, { pattern, path: searchDir, limit }, signal) => {
+    execute: async (_toolCallId, { pattern, path: searchDir, type, limit }, signal) => {
       return new Promise((resolve5, reject) => {
         if (signal?.aborted) {
           reject(new Error("Operation aborted"));
@@ -20608,7 +21362,8 @@ function createFindTool(cwd, options) {
             }
             const matcher = new GlobMatcher(pattern);
             const walkPolicy = new DirectoryWalkPolicy(effectiveLimit);
-            const finder = new DirectoryFinder(matcher, walkPolicy, effectiveLimit);
+            const typeExtensions = type ? typeToExtensions(type) : null;
+            const finder = new DirectoryFinder(matcher, walkPolicy, effectiveLimit, searchPath, typeExtensions);
             let results = await finder.find(searchPath);
             results = results.filter(
               (entryPath) => ![...excludes].some((excluded) => entryPath.includes(`/${excluded}/`) || entryPath.endsWith(`/${excluded}`))
@@ -20634,7 +21389,7 @@ var findTool = createFindTool(process.cwd());
 
 // src/facade/bot/actions/grep.ts
 import { Type as Type5 } from "@sinclair/typebox";
-import { readFileSync, statSync } from "fs";
+import { readFileSync as readFileSync2, statSync as statSync4, readdirSync as readdirSync3 } from "fs";
 import path2 from "path";
 var grepSchema = Type5.Object({
   pattern: Type5.String({ description: "What to search for, given either as a regular expression or as ordinary text" }),
@@ -20644,20 +21399,158 @@ var grepSchema = Type5.Object({
     Type5.Boolean({ description: "Set to true to treat the pattern as exact text instead of a regex. Defaults to regex mode." })
   ),
   context: Type5.Optional(
-    Type5.Number({ description: "Number of neighboring lines to print above and below each hit. Defaults to zero." })
+    Type5.Number({ description: "Number of neighboring lines to print above and below each hit (content mode). Defaults to zero." })
+  ),
+  before: Type5.Optional(
+    Type5.Number({ description: "Number of lines to print BEFORE each hit (-B). Overrides `context` for leading lines." })
+  ),
+  after: Type5.Optional(
+    Type5.Number({ description: "Number of lines to print AFTER each hit (-A). Overrides `context` for trailing lines." })
+  ),
+  output_mode: Type5.Optional(
+    Type5.Union(
+      [Type5.Literal("content"), Type5.Literal("files_with_matches"), Type5.Literal("count")],
+      {
+        description: 'How results are reported: "content" (default) shows matching lines, "files_with_matches" lists matching file paths, "count" reports per-file occurrence totals.'
+      }
+    )
+  ),
+  glob: Type5.Optional(
+    Type5.String({
+      description: 'Only search files whose root-relative path matches this glob (e.g. "*.ts" or "src/**/*.test.ts"). Multiple globs may be comma-separated. Defaults to no glob filter.'
+    })
+  ),
+  type: Type5.Optional(
+    Type5.String({
+      description: 'Only search files of this language/category (for example "ts", "js", "py"), matched by extension. Defaults to no type filter.'
+    })
   ),
   limit: Type5.Optional(Type5.Number({ description: "Upper bound on the count of hits returned. Defaults to 128." }))
 });
 var DEFAULT_LIMIT2 = 128;
 var regexCache = /* @__PURE__ */ new Map();
 var REGEX_CACHE_MAX_SIZE = 256;
-var defaultGrepOperations = {
-  isDirectory: (p) => statSync(p).isDirectory(),
-  readFile: (p) => readFileSync(p, "utf-8"),
-  readdir: (p) => {
-    const fs8 = __require("fs");
-    return fs8.readdirSync(p);
+var PRUNED_DIRS = /* @__PURE__ */ new Set([".git", ".svn", ".hg", ".bzr", ".jj", ".sl", "node_modules"]);
+function escapeGlobLiteral(literal) {
+  return literal.replace(/[\\.*+?^${}()|[\]]/g, "\\$&");
+}
+function compileGlob2(glob) {
+  let body = "";
+  for (let i = 0; i < glob.length; i++) {
+    const ch = glob[i];
+    if (ch === "*") {
+      if (glob[i + 1] === "*") {
+        i++;
+        if (glob[i + 1] === "/") {
+          i++;
+          body += "(?:[^/]*/)*";
+        } else {
+          body += ".*";
+        }
+      } else {
+        body += "[^/]*";
+      }
+    } else if (ch === "?") {
+      body += "[^/]";
+    } else {
+      body += escapeGlobLiteral(ch);
+    }
+  }
+  try {
+    return new RegExp(`^${body}$`);
+  } catch {
+    return null;
+  }
+}
+function buildIncludePredicate(glob, type) {
+  const globRegexes = [];
+  if (glob && glob.trim().length > 0) {
+    for (const part of glob.split(",")) {
+      const trimmed = part.trim();
+      if (trimmed.length === 0) continue;
+      const re = compileGlob2(trimmed);
+      if (re) globRegexes.push(re);
+    }
+  }
+  const extensions = type ? typeToExtensions2(type) : null;
+  if (globRegexes.length === 0 && !extensions) return null;
+  return (relPath) => {
+    const normalized = relPath.split(path2.sep).join("/");
+    if (globRegexes.length > 0) {
+      const matchesGlob = globRegexes.some((re) => {
+        if (re.test(normalized)) return true;
+        const base = normalized.slice(normalized.lastIndexOf("/") + 1);
+        return re.test(base);
+      });
+      if (!matchesGlob) return false;
+    }
+    if (extensions) {
+      const base = normalized.slice(normalized.lastIndexOf("/") + 1);
+      const dot = base.lastIndexOf(".");
+      const ext = dot > 0 ? base.slice(dot + 1).toLowerCase() : "";
+      if (!extensions.has(ext)) return false;
+    }
+    return true;
+  };
+}
+function typeToExtensions2(type) {
+  const key = type.trim().toLowerCase();
+  if (key.length === 0) return null;
+  const TABLE = {
+    ts: ["ts", "tsx", "mts", "cts"],
+    js: ["js", "jsx", "mjs", "cjs"],
+    py: ["py", "pyi"],
+    rs: ["rs"],
+    go: ["go"],
+    java: ["java"],
+    c: ["c", "h"],
+    cpp: ["cpp", "cc", "cxx", "hpp", "hh"],
+    md: ["md", "markdown"],
+    json: ["json"],
+    yaml: ["yaml", "yml"],
+    sh: ["sh", "bash", "zsh"]
+  };
+  const exts = TABLE[key] ?? [key];
+  return new Set(exts.map((e) => e.toLowerCase()));
+}
+async function loadGitignore(rootDir, readFile3) {
+  let body;
+  try {
+    body = await readFile3(path2.join(rootDir, ".gitignore"));
+  } catch {
+    return () => false;
+  }
+  const regexes = [];
+  for (const raw of body.split("\n")) {
+    const line = raw.trim();
+    if (line.length === 0 || line.startsWith("#")) continue;
+    const anchored = line.startsWith("/");
+    const pat = anchored ? line.slice(1) : line;
+    const re = compileGlob2(pat.replace(/\/$/, ""));
+    if (!re) continue;
+    if (anchored) {
+      regexes.push(new RegExp(`${re.source.slice(0, -1)}(?:/.*)?$`));
+    } else {
+      regexes.push(new RegExp(`(?:^|/)${re.source.slice(1, -1)}(?:/.*)?$`));
+    }
+  }
+  if (regexes.length === 0) return () => false;
+  return (relPath) => {
+    const normalized = relPath.split(path2.sep).join("/");
+    return regexes.some((re) => re.test(normalized));
+  };
+}
+function looksBinary(text) {
+  const limit = Math.min(text.length, 4096);
+  for (let i = 0; i < limit; i++) {
+    if (text.charCodeAt(i) === 0) return true;
   }
+  return false;
+}
+var defaultGrepOperations = {
+  isDirectory: (p) => statSync4(p).isDirectory(),
+  readFile: (p) => readFileSync2(p, "utf-8"),
+  readdir: (p) => readdirSync3(p)
 };
 var RegexFactory = class {
   static create(pattern, ignoreCase, literal) {
@@ -20678,12 +21571,22 @@ var RegexFactory = class {
   }
 };
 var SearchPlan = class {
-  constructor(searchPath, ops) {
+  constructor(searchPath, ops, options) {
     this.searchPath = searchPath;
     this.ops = ops;
+    this.include = options?.include ?? null;
+    this.ignored = options?.ignored ?? null;
   }
   searchPath;
   ops;
+  include;
+  ignored;
+  /**
+   * Fully recursive (depth-first) enumeration of every readable file beneath
+   * the search root. Pruned VCS/dependency folders and dot-directories are
+   * skipped, directories are NEVER pushed as if they were files, and the
+   * optional include/gitignore predicates scope or exclude the result set.
+   */
   async collectFiles() {
     const filesToSearch = [];
     const isDir = await this.ops.isDirectory(this.searchPath);
@@ -20691,38 +21594,57 @@ var SearchPlan = class {
       filesToSearch.push(this.searchPath);
       return filesToSearch;
     }
-    const entries = await this.ops.readdir(this.searchPath);
+    await this.walk(this.searchPath, filesToSearch);
+    return filesToSearch;
+  }
+  relativeOf(fullPath) {
+    return path2.relative(this.searchPath, fullPath);
+  }
+  async walk(dir, sink) {
+    let entries;
+    try {
+      entries = await this.ops.readdir(dir);
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
     for (const entry of entries) {
-      const fullPath = path2.join(this.searchPath, entry);
+      const fullPath = path2.join(dir, entry);
+      let entryIsDir;
       try {
-        if (await this.ops.isDirectory(fullPath) && !entry.startsWith(".")) {
-          const subEntries = await this.ops.readdir(fullPath);
-          for (const subEntry of subEntries) {
-            filesToSearch.push(path2.join(fullPath, subEntry));
-          }
-        } else if (!await this.ops.isDirectory(fullPath)) {
-          filesToSearch.push(fullPath);
-        }
+        entryIsDir = await this.ops.isDirectory(fullPath);
       } catch {
+        continue;
       }
+      const rel = this.relativeOf(fullPath);
+      if (entryIsDir) {
+        if (PRUNED_DIRS.has(entry) || entry.startsWith(".")) continue;
+        if (this.ignored && this.ignored(rel)) continue;
+        await this.walk(fullPath, sink);
+        continue;
+      }
+      if (this.ignored && this.ignored(rel)) continue;
+      if (this.include && !this.include(rel)) continue;
+      sink.push(fullPath);
     }
-    return filesToSearch;
   }
 };
 var MatchRenderer = class {
-  constructor(searchPath, contextValue) {
+  constructor(searchPath, contextValue, before, after) {
     this.searchPath = searchPath;
-    this.contextValue = contextValue;
+    this.before = before !== void 0 && before > 0 ? before : contextValue;
+    this.after = after !== void 0 && after > 0 ? after : contextValue;
   }
   searchPath;
-  contextValue;
+  before;
+  after;
   renderMatch(filePath, lines, lineIndex) {
     const relativePath = path2.relative(this.searchPath, filePath);
     const line = lines[lineIndex] ?? "";
     const { wasTruncated } = truncateLine(line, GREP_MAX_LINE_LENGTH);
     const output = [];
-    const start = Math.max(0, lineIndex - this.contextValue);
-    const end = Math.min(lines.length - 1, lineIndex + this.contextValue);
+    const start = Math.max(0, lineIndex - this.before);
+    const end = Math.min(lines.length - 1, lineIndex + this.after);
     for (let j = start; j <= end; j++) {
       const isMatch = j === lineIndex;
       const prefix = isMatch ? ":" : "-";
@@ -20768,12 +21690,32 @@ var MatchRenderer = class {
       details: Object.keys(details).length > 0 ? details : void 0
     };
   }
+  /** `files_with_matches` mode: one root-relative path per matching file. */
+  formatFilesWithMatches(files) {
+    if (files.length === 0) {
+      return { output: "Pattern not found in any file" };
+    }
+    return { output: files.join("\n") };
+  }
+  /** `count` mode: `path:N` lines plus a roll-up of occurrences across files. */
+  formatCount(counts) {
+    if (counts.length === 0) {
+      return { output: "Pattern not found in any file" };
+    }
+    const lines = counts.map((c) => `${c.file}:${c.count}`);
+    const total = counts.reduce((sum, c) => sum + c.count, 0);
+    const fileWord = counts.length === 1 ? "file" : "files";
+    const occWord = total === 1 ? "occurrence" : "occurrences";
+    lines.push("", `Found ${total} ${occWord} across ${counts.length} ${fileWord}`);
+    return { output: lines.join("\n") };
+  }
 };
 function createGrepTool(cwd, options) {
   const customOps = options?.operations;
   return {
     name: "grep",
     label: "grep",
+    readOnly: true,
     description: `Search file contents for a pattern, returning every hit alongside its path and line number. The search halts at ${DEFAULT_LIMIT2} hits or ${DEFAULT_MAX_BYTES / 1024}KB of output, whichever it reaches first. Any line over ${GREP_MAX_LINE_LENGTH} characters is shortened.`,
     parameters: grepSchema,
     execute: async (_toolCallId, {
@@ -20782,6 +21724,11 @@ function createGrepTool(cwd, options) {
       ignoreCase,
       literal,
       context,
+      before,
+      after,
+      output_mode,
+      glob,
+      type,
       limit
     }, signal) => {
       return new Promise((resolve5, reject) => {
@@ -20797,7 +21744,10 @@ function createGrepTool(cwd, options) {
             const ops = customOps ?? defaultGrepOperations;
             const effectiveLimit = limit ?? DEFAULT_LIMIT2;
             const contextValue = context && context > 0 ? context : 0;
-            const searchPlan = new SearchPlan(searchPath, ops);
+            const mode = output_mode ?? "content";
+            const include = buildIncludePredicate(glob, type);
+            const ignored = await loadGitignore(searchPath, (p) => ops.readFile(p));
+            const searchPlan = new SearchPlan(searchPath, ops, { include, ignored });
             const filesToSearch = await searchPlan.collectFiles();
             if (filesToSearch.length === 0) {
               signal?.removeEventListener("abort", onAbort);
@@ -20812,34 +21762,63 @@ function createGrepTool(cwd, options) {
               reject(new Error(`Invalid regex pattern: ${e.message}`));
               return;
             }
-            const matchRenderer = new MatchRenderer(searchPath, contextValue);
+            const matchRenderer = new MatchRenderer(searchPath, contextValue, before, after);
             const matches = [];
+            const filesWithMatches = [];
+            const counts = [];
             let linesTruncated = false;
+            let stopScanning = false;
             for (const filePath of filesToSearch) {
-              if (matches.length >= effectiveLimit) {
+              if (stopScanning) break;
+              if (mode === "content" && matches.length >= effectiveLimit) {
                 break;
               }
               try {
                 const content = await ops.readFile(filePath);
+                if (looksBinary(content)) {
+                  continue;
+                }
                 const lines = content.split("\n");
+                const relativePath = path2.relative(searchPath, filePath);
+                let fileCount = 0;
                 for (let i = 0; i < lines.length; i++) {
-                  if (matches.length >= effectiveLimit) {
+                  if (mode === "content" && matches.length >= effectiveLimit) {
+                    stopScanning = true;
                     break;
                   }
                   const line = lines[i] ?? "";
                   if (regex.test(line)) {
-                    const rendered = matchRenderer.renderMatch(filePath, lines, i);
-                    if (rendered.lineTruncated) {
-                      linesTruncated = true;
+                    fileCount++;
+                    if (mode === "content") {
+                      const rendered = matchRenderer.renderMatch(filePath, lines, i);
+                      if (rendered.lineTruncated) {
+                        linesTruncated = true;
+                      }
+                      matches.push({ file: relativePath, line: i + 1, text: rendered.text });
+                    } else if (mode === "files_with_matches") {
+                      break;
                     }
-                    matches.push({ file: path2.relative(searchPath, filePath), line: i + 1, text: rendered.text });
+                  }
+                }
+                if (fileCount > 0) {
+                  if (mode === "files_with_matches") {
+                    filesWithMatches.push(relativePath);
+                  } else if (mode === "count") {
+                    counts.push({ file: relativePath, count: fileCount });
                   }
                 }
               } catch {
               }
             }
             signal?.removeEventListener("abort", onAbort);
-            const formatted = matchRenderer.formatOutput(matches, effectiveLimit, linesTruncated);
+            let formatted;
+            if (mode === "files_with_matches") {
+              formatted = matchRenderer.formatFilesWithMatches(filesWithMatches);
+            } else if (mode === "count") {
+              formatted = matchRenderer.formatCount(counts);
+            } else {
+              formatted = matchRenderer.formatOutput(matches, effectiveLimit, linesTruncated);
+            }
             resolve5({
               content: [{ type: "text", text: formatted.output }],
               details: formatted.details
@@ -20857,7 +21836,7 @@ var grepTool = createGrepTool(process.cwd());
 
 // src/facade/bot/actions/ls.ts
 import { Type as Type6 } from "@sinclair/typebox";
-import { existsSync as existsSync4, readdirSync, statSync as statSync2 } from "fs";
+import { existsSync as existsSync4, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
 import nodePath from "path";
 var lsSchema = Type6.Object({
   path: Type6.Optional(Type6.String({ description: "Directory whose entries should be listed. Falls back to the working directory." })),
@@ -20866,8 +21845,8 @@ var lsSchema = Type6.Object({
 var DEFAULT_LIMIT3 = 512;
 var defaultLsOperations = {
   exists: existsSync4,
-  stat: statSync2,
-  readdir: readdirSync
+  stat: statSync5,
+  readdir: readdirSync4
 };
 function createAbortGuard(signal) {
   let aborted = signal?.aborted ?? false;
@@ -20952,8 +21931,8 @@ var DirectoryListRunner = class {
     if (!await this.ops.exists(resolvedDir)) {
       throw new Error(`No such path: ${resolvedDir}`);
     }
-    const stat2 = await this.ops.stat(resolvedDir);
-    if (!stat2.isDirectory()) {
+    const stat3 = await this.ops.stat(resolvedDir);
+    if (!stat3.isDirectory()) {
       throw new Error(`Target is not a directory: ${resolvedDir}`);
     }
   }
@@ -21009,6 +21988,7 @@ function createLsTool(cwd, options) {
   return {
     name: "ls",
     label: "ls",
+    readOnly: true,
     description: `List the contents of a directory. Names are returned sorted alphabetically with dotfiles kept in, and subdirectories carry a trailing '/'. The listing halts at ${DEFAULT_LIMIT3} entries or ${DEFAULT_MAX_BYTES / 1024}KB of output, whichever it reaches first.`,
     parameters: lsSchema,
     execute: async (_toolCallId, { path: path9, limit }, signal) => {
@@ -22435,24 +23415,25 @@ function withAbort2(signal, task) {
   });
 }
 var ReadExecutionPipeline = class {
-  constructor(cwd, ops, autoResizeImages) {
+  constructor(cwd, ops, autoResizeImages, readState) {
     this.cwd = cwd;
     this.ops = ops;
     this.autoResizeImages = autoResizeImages;
+    this.readState = readState;
   }
   cwd;
   ops;
   autoResizeImages;
+  readState;
   async run(input, throwIfAborted2) {
     const absolutePath = resolveReadPath(input.path, this.cwd);
     await this.ops.access(absolutePath);
     throwIfAborted2();
     const mimeType = this.ops.detectImageMimeType ? await this.ops.detectImageMimeType(absolutePath) : void 0;
     throwIfAborted2();
-    if (mimeType) {
-      return this.readImageVariant(absolutePath, mimeType, throwIfAborted2);
-    }
-    return this.readTextVariant(absolutePath, input.path, input.offset, input.limit, throwIfAborted2);
+    const result = mimeType ? await this.readImageVariant(absolutePath, mimeType, throwIfAborted2) : await this.readTextVariant(absolutePath, input.path, input.offset, input.limit, throwIfAborted2);
+    recordReadState(this.readState, absolutePath);
+    return result;
   }
   async readImageVariant(absolutePath, mimeType, throwIfAborted2) {
     const buffer = await this.ops.readFile(absolutePath);
@@ -22500,12 +23481,14 @@ ${dimensionNote}`;
       renderedText = `[Line ${startLineDisplay} weighs ${firstLineSize}, over the ${formatSize(DEFAULT_MAX_BYTES)} cap. Pull a byte slice via bash: sed -n '${startLineDisplay}p' ${requestedPath} | head -c ${DEFAULT_MAX_BYTES}]`;
       details = { truncation };
     } else if (truncation.truncated) {
-      renderedText = this.formatTruncationNotice(truncation, totalFileLines, startLineDisplay);
+      const gutteredBody = this.addGutter(truncation.content, startLineDisplay);
+      renderedText = this.formatTruncationNotice(gutteredBody, truncation, totalFileLines, startLineDisplay);
       details = { truncation };
     } else if (requestedLineCount !== void 0 && startLine + requestedLineCount < fileLines.length) {
-      renderedText = this.formatUserLimitNotice(truncation.content, fileLines.length, startLine, requestedLineCount);
+      const gutteredBody = this.addGutter(truncation.content, startLineDisplay);
+      renderedText = this.formatUserLimitNotice(gutteredBody, fileLines.length, startLine, requestedLineCount);
     } else {
-      renderedText = truncation.content;
+      renderedText = this.addGutter(truncation.content, startLineDisplay);
     }
     throwIfAborted2();
     return {
@@ -22533,14 +23516,30 @@ ${dimensionNote}`;
       requestedLineCount: void 0
     };
   }
-  formatTruncationNotice(truncation, totalFileLines, startLineDisplay) {
+  formatTruncationNotice(body, truncation, totalFileLines, startLineDisplay) {
     const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
     const nextOffset = endLineDisplay + 1;
     const continuationHint = this.buildContinuationHint(truncation, totalFileLines, startLineDisplay, endLineDisplay, nextOffset);
-    return `${truncation.content}
+    return `${body}
 
 ${continuationHint}`;
   }
+  /**
+   * Prefix each line with a right-aligned 1-based absolute line number in the
+   * cat -n style, giving the model stable edit/diff coordinates. `content` is
+   * already windowed; `startLineDisplay` is the whole-file number of its first
+   * line so the gutter stays correct under offset/limit paging. Empty content
+   * (e.g. binary or an over-budget first line yielding "") passes through
+   * unchanged so non-text output stays stable.
+   */
+  addGutter(content, startLineDisplay) {
+    if (content.length === 0) return content;
+    return content.split(/\r?\n/).map((line, i) => {
+      const numStr = String(startLineDisplay + i);
+      const label = numStr.length >= 6 ? numStr : numStr.padStart(6, " ");
+      return `${label}\u2192${line}`;
+    }).join("\n");
+  }
   formatUserLimitNotice(baseText, totalLines, startLine, requestedLineCount) {
     const remaining = totalLines - (startLine + requestedLineCount);
     const nextOffset = startLine + requestedLineCount + 1;
@@ -22558,11 +23557,12 @@ ${continuationHint}`;
 function createReadTool(cwd, options) {
   const autoResizeImages = options?.autoResizeImages ?? true;
   const ops = options?.operations ?? defaultReadOperations;
-  const pipeline = new ReadExecutionPipeline(cwd, ops, autoResizeImages);
+  const pipeline = new ReadExecutionPipeline(cwd, ops, autoResizeImages, options?.readState);
   return {
     name: "read",
     label: "read",
-    description: `Open a file and return its contents. Both text and images (jpg, png, gif, webp) work; images come back as attachments. Text output is capped at ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB, whichever comes first. For big files, page through with offset and limit, advancing offset until you have read everything you need.`,
+    readOnly: true,
+    description: `Open a file and return its contents. Both text and images (jpg, png, gif, webp) work; images come back as attachments. Output uses cat -n format - each line is prefixed with its 1-based line number. Text output is capped at ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB, whichever comes first. For big files, page through with offset and limit, advancing offset until you have read everything you need.`,
     parameters: readSchema,
     execute: async (_toolCallId, { path: path9, offset, limit }, signal) => {
       return withAbort2(signal, async ({ throwIfAborted: throwIfAborted2 }) => {
@@ -22579,9 +23579,9 @@ import { Type as Type15 } from "@sinclair/typebox";
 // src/facade/bot/actions/process-manager.ts
 import { spawn as spawn3 } from "node:child_process";
 import { EventEmitter } from "node:events";
-import { appendFileSync, existsSync as existsSync5, mkdirSync, readFileSync as readFileSync2, rmSync, statSync as statSync3 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { isAbsolute as isAbsolute2, join as join2 } from "node:path";
+import { appendFileSync, existsSync as existsSync5, mkdirSync, readFileSync as readFileSync3, rmSync, statSync as statSync6 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { isAbsolute as isAbsolute2, join as join3 } from "node:path";
 
 // src/facade/bot/actions/process-types.ts
 var MESSAGE_TYPE_PROCESS_UPDATE = "ad-process:update";
@@ -22646,7 +23646,7 @@ var ProcessManager = class {
   watcher = null;
   getConfiguredShellPath;
   constructor(options) {
-    this.logDir = join2(tmpdir2(), `indusagi-processes-${Date.now()}`);
+    this.logDir = join3(tmpdir3(), `indusagi-processes-${Date.now()}`);
     mkdirSync(this.logDir, { recursive: true });
     this.getConfiguredShellPath = options?.getConfiguredShellPath ?? (() => void 0);
   }
@@ -22715,9 +23715,9 @@ var ProcessManager = class {
   }
   start(name, command, cwd, options) {
     const id = `proc_${++this.counter}`;
-    const stdoutFile = join2(this.logDir, `${id}-stdout.log`);
-    const stderrFile = join2(this.logDir, `${id}-stderr.log`);
-    const combinedFile = join2(this.logDir, `${id}-combined.log`);
+    const stdoutFile = join3(this.logDir, `${id}-stdout.log`);
+    const stderrFile = join3(this.logDir, `${id}-stderr.log`);
+    const combinedFile = join3(this.logDir, `${id}-combined.log`);
     appendFileSync(stdoutFile, "");
     appendFileSync(stderrFile, "");
     appendFileSync(combinedFile, "");
@@ -22867,8 +23867,8 @@ var ProcessManager = class {
     }
     try {
       return {
-        stdout: readFileSync2(managed.stdoutFile, "utf-8"),
-        stderr: readFileSync2(managed.stderrFile, "utf-8")
+        stdout: readFileSync3(managed.stdoutFile, "utf-8"),
+        stderr: readFileSync3(managed.stderrFile, "utf-8")
       };
     } catch {
       return { stdout: "", stderr: "" };
@@ -23024,8 +24024,8 @@ var ProcessManager = class {
     }
     try {
       return {
-        stdout: statSync3(managed.stdoutFile).size,
-        stderr: statSync3(managed.stderrFile).size
+        stdout: statSync6(managed.stdoutFile).size,
+        stderr: statSync6(managed.stderrFile).size
       };
     } catch {
       return { stdout: 0, stderr: 0 };
@@ -23033,7 +24033,7 @@ var ProcessManager = class {
   }
   readTailLines(filePath, lines) {
     try {
-      const content = readFileSync2(filePath, "utf-8");
+      const content = readFileSync3(filePath, "utf-8");
       const allLines = content.split("\n");
       if (allLines.length > 0 && allLines[allLines.length - 1] === "") {
         allLines.pop();
@@ -23596,6 +24596,7 @@ function createTodoReadTool(store) {
   return {
     name: "todoread",
     label: "todoread",
+    readOnly: true,
     description: "Read the current todo list. Returns items with content, status, and priority.",
     parameters: TodoReadSchema,
     execute: async () => {
@@ -23736,6 +24737,7 @@ function createWebFetchTool(options) {
   return {
     name: "webfetch",
     label: "webfetch",
+    readOnly: true,
     description: "Fetches content from a specified URL. Takes a URL and optional format as input. Fetches URL content, converts to requested format (markdown by default). Returns content in the specified format. Use this tool when you need to retrieve and analyze web content. The URL must be a fully-formed valid URL starting with http:// or https://. Format options: 'markdown' (default), 'text', or 'html'. This tool is read-only and does not modify any files.",
     parameters: webFetchSchema,
     execute: async (_toolCallId, params, signal) => {
@@ -23832,6 +24834,62 @@ var webFetchTool = createWebFetchTool();
 
 // src/facade/bot/actions/websearch.ts
 import { Type as Type18 } from "@sinclair/typebox";
+var SEARCH_ENDPOINT = "https://html.duckduckgo.com/html/";
+var USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36";
+function toPlainText(html) {
+  const withoutTags = html.replace(/<[^>]*>/g, "");
+  const decoded = withoutTags.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&#x27;/g, "'").replace(/&nbsp;/g, " ");
+  return decoded.replace(/\s+/g, " ").trim();
+}
+function unwrapTarget(href) {
+  let candidate = href;
+  const redirectMatch = /[?&]uddg=([^&]+)/.exec(candidate);
+  if (redirectMatch) {
+    try {
+      candidate = decodeURIComponent(redirectMatch[1]);
+    } catch {
+    }
+  }
+  if (candidate.startsWith("//")) {
+    candidate = `https:${candidate}`;
+  }
+  return candidate;
+}
+function extractHits(body, limit) {
+  const hits = [];
+  const seen = /* @__PURE__ */ new Set();
+  const titleAnchor = /<a\b[^>]*\bclass="[^"]*\bresult__a\b[^"]*"[^>]*\bhref="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi;
+  const snippetBlock = /\bclass="[^"]*\bresult__snippet\b[^"]*"[^>]*>([\s\S]*?)<\/[a-z]+>/i;
+  let match;
+  while ((match = titleAnchor.exec(body)) !== null) {
+    if (hits.length >= limit) break;
+    const url = unwrapTarget(match[1]);
+    const title = toPlainText(match[2]);
+    if (url.length === 0 || title.length === 0) continue;
+    if (seen.has(url)) continue;
+    const tail = body.slice(titleAnchor.lastIndex);
+    const snippetMatch = snippetBlock.exec(tail);
+    const snippet = snippetMatch ? toPlainText(snippetMatch[1]) : "";
+    seen.add(url);
+    hits.push({ title, url, snippet });
+  }
+  return hits;
+}
+function renderHits(query, hits) {
+  const lines = [
+    `${hits.length} result${hits.length === 1 ? "" : "s"} for "${query}":`,
+    ""
+  ];
+  hits.forEach((hit, index) => {
+    lines.push(`${index + 1}. ${hit.title}`);
+    lines.push(`   ${hit.url}`);
+    if (hit.snippet.length > 0) {
+      lines.push(`   ${hit.snippet}`);
+    }
+    lines.push("");
+  });
+  return lines.join("\n").trimEnd();
+}
 var webSearchSchema = Type18.Object({
   query: Type18.String({ description: "Web search query" }),
   numResults: Type18.Optional(
@@ -23843,48 +24901,31 @@ var requestCount = 0;
 async function defaultWebSearch(query, numResults, signal) {
   const count = Math.min(numResults ?? 8, 10);
   try {
-    const searchUrl = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1&skip_disambig=1`;
-    const response = await fetch(searchUrl, {
+    const form = new URLSearchParams({ q: query });
+    const response = await fetch(SEARCH_ENDPOINT, {
+      method: "POST",
       signal,
       headers: {
-        "Accept": "application/json"
-      }
+        "Content-Type": "application/x-www-form-urlencoded",
+        "User-Agent": USER_AGENT,
+        Accept: "text/html"
+      },
+      body: form.toString()
     });
     if (!response.ok) {
       throw new Error(`Search request failed: ${response.status}`);
     }
-    const data = await response.json();
-    const results = [];
-    if (data.AbstractText) {
-      results.push(`**Summary:** ${data.AbstractText}`);
-      if (data.AbstractURL) {
-        results.push(`Source: ${data.AbstractURL}`);
-      }
-    }
-    if (data.RelatedTopics && Array.isArray(data.RelatedTopics)) {
-      const topics = data.RelatedTopics.filter((t) => t.Text && t.FirstURL).slice(0, count);
-      if (topics.length > 0) {
-        results.push(`
-**Related Results:**`);
-        for (const topic of topics) {
-          results.push(`- ${topic.Text}`);
-          results.push(`  URL: ${topic.FirstURL}`);
-        }
-      }
-    }
-    if (results.length === 0) {
+    const body = await response.text();
+    const hits = extractHits(body, count);
+    if (hits.length === 0) {
       return `No results found for: "${query}". Try a different search query.`;
     }
-    return `Web search results for: "${query}"
-
-${results.join("\n")}`;
+    return renderHits(query, hits);
   } catch (error) {
-    if (error.name === "AbortError") {
+    if (error?.name === "AbortError") {
       throw new Error("Web search request timed out or was aborted");
     }
-    return `Search query: "${query}"
-
-Unable to perform live search. Please try again or use a different query.`;
+    throw error;
   }
 }
 function createWebSearchTool(options) {
@@ -23892,6 +24933,7 @@ function createWebSearchTool(options) {
   return {
     name: "websearch",
     label: "websearch",
+    readOnly: true,
     description: "Search the web - performs real-time web searches and can scrape content from specific URLs. Provides up-to-date information for current events and recent data. Use this tool for accessing information beyond knowledge cutoff. The current year is 2026. You MUST use this year when searching for recent information or current events (e.g., search for 'AI news 2026', NOT 'AI news 2025').",
     parameters: webSearchSchema,
     execute: async (_toolCallId, { query, numResults }, signal) => {
@@ -23950,8 +24992,9 @@ var webSearchTool = createWebSearchTool();
 
 // src/facade/bot/actions/write.ts
 import { Type as Type19 } from "@sinclair/typebox";
+import { existsSync as existsSync6 } from "fs";
 import { copyFile as fsCopyFile, mkdir as fsMkdir, writeFile as fsWriteFile2 } from "fs/promises";
-import { dirname } from "path";
+import { dirname as dirname2 } from "path";
 var writeSchema = Type19.Object({
   path: Type19.String({ description: "Destination file, given as a relative or absolute path" }),
   content: Type19.String({ description: "The text that will become the file's contents" })
@@ -23970,22 +25013,48 @@ var FileValidator = class {
   }
 };
 var WriteSession = class {
-  constructor(cwd, relativePath, fileContent, operations, createBackup) {
+  constructor(cwd, relativePath, fileContent, operations, createBackup, readState, checkpoint) {
     this.cwd = cwd;
     this.relativePath = relativePath;
     this.fileContent = fileContent;
     this.operations = operations;
     this.createBackup = createBackup;
+    this.readState = readState;
+    this.checkpoint = checkpoint;
     this.absolutePath = resolveToCwd(relativePath, cwd);
-    this.targetDir = dirname(this.absolutePath);
+    this.targetDir = dirname2(this.absolutePath);
   }
   cwd;
   relativePath;
   fileContent;
   operations;
   createBackup;
+  readState;
+  checkpoint;
   absolutePath;
   targetDir;
+  /**
+   * Enforce the read-before-edit + staleness gate ahead of an OVERWRITE.
+   * Brand-new files (those not yet on disk) are exempt — there is nothing the
+   * model could have clobbered. No-op without a handle.
+   */
+  enforceGate() {
+    if (!this.readState) return;
+    if (!existsSync6(this.absolutePath)) return;
+    const gate = enforceReadGate(this.readState, this.absolutePath);
+    if (!gate.ok) {
+      throw new Error(gate.message);
+    }
+  }
+  /**
+   * Snapshot the file's pre-mutation on-disk content for rewind. Runs AFTER the
+   * read-state gate and BEFORE any mutation (mkdir/write), so the captured bytes
+   * are the OLD content; a brand-new file is recorded as `null`. No-op without a
+   * handle.
+   */
+  recordCheckpoint() {
+    recordCheckpoint(this.checkpoint, this.absolutePath);
+  }
   async prepareDirectories() {
     await this.operations.mkdir(this.targetDir);
   }
@@ -24000,6 +25069,7 @@ var WriteSession = class {
   }
   async persistContent() {
     await this.operations.writeFile(this.absolutePath, this.fileContent);
+    recordReadState(this.readState, this.absolutePath);
   }
   buildResponse() {
     return {
@@ -24064,8 +25134,20 @@ function createWriteTool(cwd, options) {
     parameters: writeSchema,
     execute: async (_toolCallId, { path: path9, content }, signal) => {
       validator.validate(path9);
-      const writeSession = new WriteSession(cwd, path9, content, operations, Boolean(options?.createBackup));
+      const writeSession = new WriteSession(
+        cwd,
+        path9,
+        content,
+        operations,
+        Boolean(options?.createBackup),
+        options?.readState,
+        options?.checkpoint
+      );
       return withAbort3(signal, async (isAborted) => {
+        writeSession.enforceGate();
+        throwIfAborted(isAborted);
+        writeSession.recordCheckpoint();
+        throwIfAborted(isAborted);
         await writeSession.prepareDirectories();
         throwIfAborted(isAborted);
         await writeSession.backupIfEnabled();
@@ -24689,13 +25771,13 @@ async function gcStaleTeamDirs(opts) {
       continue;
     }
     const teamDir = path4.join(teamsRootAbs, teamId);
-    let stat2;
+    let stat3;
     try {
-      stat2 = await fs2.promises.stat(teamDir);
+      stat3 = await fs2.promises.stat(teamDir);
     } catch {
       continue;
     }
-    if (!stat2.isDirectory()) continue;
+    if (!stat3.isDirectory()) continue;
     let ageMs;
     try {
       const configPath = path4.join(teamDir, "config.json");
@@ -24704,12 +25786,12 @@ async function gcStaleTeamDirs(opts) {
       const createdAt = typeof config === "object" && config !== null && "createdAt" in config ? config.createdAt : void 0;
       if (typeof createdAt === "string") {
         const ts = Date.parse(createdAt);
-        ageMs = Number.isFinite(ts) ? now - ts : now - stat2.mtimeMs;
+        ageMs = Number.isFinite(ts) ? now - ts : now - stat3.mtimeMs;
       } else {
-        ageMs = now - stat2.mtimeMs;
+        ageMs = now - stat3.mtimeMs;
       }
     } catch {
-      ageMs = now - stat2.mtimeMs;
+      ageMs = now - stat3.mtimeMs;
     }
     if (ageMs < maxAgeMs) {
       skipped.push({ teamId, reason: "too recent" });
@@ -26352,17 +27434,17 @@ import { homedir as homedir2 } from "os";
 import {
   appendFileSync as appendFileSync2,
   closeSync as closeSync2,
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   mkdirSync as mkdirSync2,
   openSync as openSync2,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync3,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync4,
   readSync,
-  statSync as statSync5,
+  statSync as statSync8,
   writeFileSync as writeFileSync2
 } from "fs";
-import { readdir, readFile as readFile2, stat } from "fs/promises";
-import { join as join9, resolve as resolve4 } from "path";
+import { readdir, readFile as readFile2, stat as stat2 } from "fs/promises";
+import { join as join10, resolve as resolve4 } from "path";
 var CURRENT_SESSION_VERSION = 3;
 function generateId(byId) {
   let attempt = 0;
@@ -26542,11 +27624,11 @@ function getDefaultAgentDir() {
     return expandHomePath(explicitAgentDir);
   }
   const rawBase = process.env[ENV_BASE_DIR];
-  const baseDir = rawBase ? expandHomePath(rawBase) : join9(homedir2(), DEFAULT_CONFIG_DIR);
-  return join9(baseDir, "agent");
+  const baseDir = rawBase ? expandHomePath(rawBase) : join10(homedir2(), DEFAULT_CONFIG_DIR);
+  return join10(baseDir, "agent");
 }
 function getSessionsDir() {
-  return join9(getDefaultAgentDir(), "sessions");
+  return join10(getDefaultAgentDir(), "sessions");
 }
 function encodeCwdForDir(cwd) {
   const trimmedLeadingSlash = cwd.replace(/^[/\\]/, "");
@@ -26554,8 +27636,8 @@ function encodeCwdForDir(cwd) {
   return `--${sanitized}--`;
 }
 function getDefaultSessionDir(cwd) {
-  const sessionDir = join9(getDefaultAgentDir(), "sessions", encodeCwdForDir(cwd));
-  if (!existsSync7(sessionDir)) {
+  const sessionDir = join10(getDefaultAgentDir(), "sessions", encodeCwdForDir(cwd));
+  if (!existsSync8(sessionDir)) {
     mkdirSync2(sessionDir, { recursive: true });
   }
   return sessionDir;
@@ -26565,10 +27647,10 @@ function hasValidSessionHeader(entries) {
   return first !== void 0 && first.type === "session" && typeof first.id === "string";
 }
 function loadEntriesFromFile(filePath) {
-  if (!existsSync7(filePath)) {
+  if (!existsSync8(filePath)) {
     return [];
   }
-  const entries = decodeJsonlLines(readFileSync3(filePath, "utf8"));
+  const entries = decodeJsonlLines(readFileSync4(filePath, "utf8"));
   if (entries.length === 0) {
     return entries;
   }
@@ -26596,7 +27678,7 @@ function isValidSessionFile(filePath) {
 }
 function findMostRecentSession(sessionDir) {
   try {
-    const ranked = readdirSync2(sessionDir).filter((f) => f.endsWith(".jsonl")).map((f) => join9(sessionDir, f)).filter(isValidSessionFile).map((path9) => ({ path: path9, mtime: statSync5(path9).mtime })).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    const ranked = readdirSync5(sessionDir).filter((f) => f.endsWith(".jsonl")).map((f) => join10(sessionDir, f)).filter(isValidSessionFile).map((path9) => ({ path: path9, mtime: statSync8(path9).mtime })).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
     return ranked[0]?.path || null;
   } catch {
     return null;
@@ -26665,7 +27747,7 @@ async function buildSessionInfo(filePath) {
       return null;
     }
     const sessionHeader = header;
-    const stats = await stat(filePath);
+    const stats = await stat2(filePath);
     let messageCount = 0;
     let firstMessage = "";
     let name;
@@ -26710,11 +27792,11 @@ async function buildSessionInfo(filePath) {
   }
 }
 async function listSessionsFromDir(dir, onProgress, progressOffset = 0, progressTotal) {
-  if (!existsSync7(dir)) {
+  if (!existsSync8(dir)) {
     return [];
   }
   try {
-    const files = (await readdir(dir)).filter((f) => f.endsWith(".jsonl")).map((f) => join9(dir, f));
+    const files = (await readdir(dir)).filter((f) => f.endsWith(".jsonl")).map((f) => join10(dir, f));
     const total = progressTotal ?? files.length;
     let loaded = 0;
     const results = await Promise.all(
@@ -26745,7 +27827,7 @@ var SessionManager = class _SessionManager {
     this.cwd = cwd;
     this.sessionDir = sessionDir;
     this.persist = persist;
-    if (persist && sessionDir && !existsSync7(sessionDir)) {
+    if (persist && sessionDir && !existsSync8(sessionDir)) {
       mkdirSync2(sessionDir, { recursive: true });
     }
     if (sessionFile) {
@@ -26758,7 +27840,7 @@ var SessionManager = class _SessionManager {
   setSessionFile(sessionFile) {
     const resolved = resolve4(sessionFile);
     this.sessionFile = resolved;
-    if (!existsSync7(resolved)) {
+    if (!existsSync8(resolved)) {
       this.newSession();
       this.sessionFile = resolved;
       return;
@@ -26797,7 +27879,7 @@ var SessionManager = class _SessionManager {
     this.flushed = false;
     if (this.persist) {
       const fileTimestamp = timestamp.replace(/[:.]/g, "-");
-      this.sessionFile = join9(this.getSessionDir(), `${fileTimestamp}_${this.sessionId}.jsonl`);
+      this.sessionFile = join10(this.getSessionDir(), `${fileTimestamp}_${this.sessionId}.jsonl`);
     }
     return this.sessionFile;
   }
@@ -27153,7 +28235,7 @@ var SessionManager = class _SessionManager {
     const newSessionId = randomUUID();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const fileTimestamp = timestamp.replace(/[:.]/g, "-");
-    const newSessionFile = join9(this.getSessionDir(), `${fileTimestamp}_${newSessionId}.jsonl`);
+    const newSessionFile = join10(this.getSessionDir(), `${fileTimestamp}_${newSessionId}.jsonl`);
     const header = {
       type: "session",
       version: CURRENT_SESSION_VERSION,
@@ -27270,13 +28352,13 @@ var SessionManager = class _SessionManager {
       throw new Error(`Fork aborted \u2014 source session ${sourcePath} is missing its header record`);
     }
     const dir = sessionDir ?? getDefaultSessionDir(targetCwd);
-    if (!existsSync7(dir)) {
+    if (!existsSync8(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
     const newSessionId = randomUUID();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const fileTimestamp = timestamp.replace(/[:.]/g, "-");
-    const newSessionFile = join9(dir, `${fileTimestamp}_${newSessionId}.jsonl`);
+    const newSessionFile = join10(dir, `${fileTimestamp}_${newSessionId}.jsonl`);
     const newHeader = {
       type: "session",
       version: CURRENT_SESSION_VERSION,
@@ -27314,16 +28396,16 @@ var SessionManager = class _SessionManager {
   static async listAll(onProgress) {
     const sessionsDir = getSessionsDir();
     try {
-      if (!existsSync7(sessionsDir)) {
+      if (!existsSync8(sessionsDir)) {
         return [];
       }
       const rootEntries = await readdir(sessionsDir, { withFileTypes: true });
-      const dirs = rootEntries.filter((e) => e.isDirectory()).map((e) => join9(sessionsDir, e.name));
+      const dirs = rootEntries.filter((e) => e.isDirectory()).map((e) => join10(sessionsDir, e.name));
       const perDirFiles = [];
       let totalFiles = 0;
       for (const dir of dirs) {
         try {
-          const jsonlFiles = (await readdir(dir)).filter((f) => f.endsWith(".jsonl")).map((f) => join9(dir, f));
+          const jsonlFiles = (await readdir(dir)).filter((f) => f.endsWith(".jsonl")).map((f) => join10(dir, f));
           perDirFiles.push(jsonlFiles);
           totalFiles += jsonlFiles.length;
         } catch {
@@ -27361,11 +28443,14 @@ export {
   ComposioService,
   DEFAULT_MAX_BYTES,
   DEFAULT_MAX_LINES,
+  DESANITIZATIONS,
+  FILE_NOT_FOUND_CWD_NOTE,
   IndusagiComposioProvider,
   LIVE_STATUSES,
   MESSAGE_TYPE_PROCESS_UPDATE,
   PIRATE_NAME_POOL,
   ProcessManager,
+  READ_ONLY_TOOL_NAMES,
   SessionManager,
   TEAM_ATTACH_CLAIM_FILE,
   TEAM_ATTACH_CLAIM_STALE_MS,
@@ -27384,10 +28469,15 @@ export {
   agentLoop,
   agentLoopContinue,
   allTools,
+  argvToCommandString,
   assertTeamDirWithinTeamsRoot,
   assessAttachClaimFreshness,
   bashExecutionToText,
   bashTool,
+  buildBwrapArgv,
+  buildSandboxArgv,
+  buildSeatbeltArgv,
+  buildSeatbeltProfile,
   buildSessionContext,
   claimNextAvailableTask,
   claimTask,
@@ -27424,6 +28514,7 @@ export {
   createProcessTool,
   createReadOnlyTools,
   createReadTool,
+  createSandboxedBashOperations,
   createTask,
   createTodoReadTool,
   createTodoWriteTool,
@@ -27431,11 +28522,13 @@ export {
   createWebFetchTool,
   createWebSearchTool,
   createWriteTool,
+  desanitizeMatchString,
   editTool,
   ensureTeamConfig,
   ensureWorktreeCwd,
   expandPath,
   findMostRecentSession,
+  findSimilarFile,
   findTool,
   formatProviderModel,
   formatSize,
@@ -27477,21 +28570,25 @@ export {
   pickNamesFromPool,
   pickPirateNames,
   popUnreadMessages,
+  preserveQuoteStyle,
   processTool,
   readOnlyTools,
   readTeamAttachClaim,
   readTool,
   releaseTeamAttachClaim,
   removeTaskDependency,
+  replaceAllLiteral,
   resolveReadPath,
   resolveTeammateModelSelection,
   resolveToCwd,
+  sandboxAvailability,
   sanitizeName,
   setMemberStatus,
   setTeamStyle,
   shortTaskId,
   startAssignedTask,
   streamProxy,
+  suggestPathUnderCwd,
   taskAssignmentPayload,
   todoReadTool,
   todoWriteTool,