reasonix 0.27.3 → 0.29.0

package/dist/cli/{prompt-YUL7CYKY.js → prompt-VF7B6BWR.js}

@@ -2,9 +2,9 @@
 import {
   CODE_SYSTEM_PROMPT,
   codeSystemPrompt
-} from "./chunk-R2L5YEEF.js";
+} from "./chunk-COFBA5FV.js";
 export {
   CODE_SYSTEM_PROMPT,
   codeSystemPrompt
 };
-//# sourceMappingURL=prompt-YUL7CYKY.js.map
+//# sourceMappingURL=prompt-VF7B6BWR.js.map

package/dist/index.d.ts

@@ -694,6 +694,8 @@ interface ToolDefinition<A = any, R = any> {
     readOnly?: boolean;
     /** Per-args check; takes precedence over `readOnly`. e.g. `run_command` + allowlisted argv. */
     readOnlyCheck?: (args: A) => boolean;
+    /** Safe to dispatch concurrently with other parallel-safe calls in the same turn. Default false — opt-in only. */
+    parallelSafe?: boolean;
     fn: (args: A, ctx?: ToolCallContext) => R | Promise<R>;
 }
 interface ToolRegistryOptions {
@@ -729,6 +731,8 @@ declare class ToolRegistry {
     get size(): number;
     /** True if a registered tool's schema was flattened for the model. */
     wasFlattened(name: string): boolean;
+    /** Unknown / unannotated tools default to false — third-party MCP tools must opt in. */
+    isParallelSafe(name: string): boolean;
     specs(): ToolSpec[];
     dispatch(name: string, argumentsRaw: string | Record<string, unknown>, opts?: {
         signal?: AbortSignal;
@@ -840,6 +844,7 @@ declare class CacheFirstLoop {
     private modelForCurrentCall;
     /** Returns true ONLY on the tipping call — caller surfaces a one-shot warning. */
     private noteToolFailureSignal;
+    private runOneToolCall;
     private buildMessages;
     abort(): void;
     /** Drop the last user message + everything after; caller re-sends. Persists to session file. */
@@ -1102,6 +1107,8 @@ declare function registerPlanTool(registry: ToolRegistry, opts?: PlanToolOptions
 /** Side-channel — subagents run inside a tool-dispatch frame, can't go through parent's `LoopEvent` stream. */
 interface SubagentEvent {
     kind: "start" | "progress" | "end" | "inner" | "phase";
+    /** Stable per-spawn id; lets the UI key parallel runs apart instead of overwriting one shared row. */
+    runId: string;
     task: string;
     skillName?: string;
     model?: string;

package/dist/index.js

@@ -1046,6 +1046,10 @@ var ToolRegistry = class {
   wasFlattened(name) {
     return Boolean(this._tools.get(name)?.flatSchema);
   }
+  /** Unknown / unannotated tools default to false — third-party MCP tools must opt in. */
+  isParallelSafe(name) {
+    return this._tools.get(name)?.parallelSafe === true;
+  }
   specs() {
     return [...this._tools.values()].map((t) => ({
       type: "function",
@@ -2640,6 +2644,48 @@ var CacheFirstLoop = class {
     this._escalateThisTurn = true;
     return true;
   }
+  async runOneToolCall(call, signal) {
+    const name = call.function?.name ?? "";
+    const args = call.function?.arguments ?? "{}";
+    const parsedArgs = safeParseToolArgs(args);
+    const preReport = await runHooks({
+      hooks: this.hooks,
+      payload: {
+        event: "PreToolUse",
+        cwd: this.hookCwd,
+        toolName: name,
+        toolArgs: parsedArgs
+      }
+    });
+    const preWarnings = [...hookWarnings(preReport.outcomes, this._turn)];
+    if (preReport.blocked) {
+      const blocking = preReport.outcomes[preReport.outcomes.length - 1];
+      const reason = (blocking?.stderr || blocking?.stdout || "blocked by PreToolUse hook").trim();
+      return {
+        preWarnings,
+        postWarnings: [],
+        result: `[hook block] ${blocking?.hook.command ?? "<unknown>"}
+${reason}`
+      };
+    }
+    const result = await this.tools.dispatch(name, args, {
+      signal,
+      maxResultTokens: DEFAULT_MAX_RESULT_TOKENS,
+      confirmationGate: this.confirmationGate
+    });
+    const postReport = await runHooks({
+      hooks: this.hooks,
+      payload: {
+        event: "PostToolUse",
+        cwd: this.hookCwd,
+        toolName: name,
+        toolArgs: parsedArgs,
+        toolResult: result
+      }
+    });
+    const postWarnings = [...hookWarnings(postReport.outcomes, this._turn)];
+    return { preWarnings, postWarnings, result };
+  }
   buildMessages(pendingUser) {
     const healed = healLoadedMessages(this.log.toMessages(), DEFAULT_MAX_RESULT_CHARS);
     const msgs = [...this.prefix.toMessages(), ...healed.messages];
@@ -3131,71 +3177,69 @@ var CacheFirstLoop = class {
         yield* forceSummaryAfterIterLimit(this.summaryContext(), { reason: "context-guard" });
         return;
       }
-      for (const call of repairedCalls) {
-        const name = call.function?.name ?? "";
-        const args = call.function?.arguments ?? "{}";
-        yield {
-          turn: this._turn,
-          role: "tool_start",
-          content: "",
-          toolName: name,
-          toolArgs: args
-        };
-        const parsedArgs = safeParseToolArgs(args);
-        const preReport = await runHooks({
-          hooks: this.hooks,
-          payload: {
-            event: "PreToolUse",
-            cwd: this.hookCwd,
-            toolName: name,
-            toolArgs: parsedArgs
+      const dispatchSerial = (process.env.REASONIX_TOOL_DISPATCH ?? "auto").toLowerCase() === "serial";
+      const parallelMaxParsed = Number.parseInt(process.env.REASONIX_PARALLEL_MAX ?? "", 10);
+      const parallelMax = Number.isFinite(parallelMaxParsed) && parallelMaxParsed >= 1 ? Math.min(parallelMaxParsed, 16) : 3;
+      let callIdx = 0;
+      while (callIdx < repairedCalls.length) {
+        const chunk = [];
+        if (!dispatchSerial) {
+          while (callIdx < repairedCalls.length && chunk.length < parallelMax && this.tools.isParallelSafe(repairedCalls[callIdx]?.function?.name ?? "")) {
+            chunk.push(repairedCalls[callIdx++]);
           }
-        });
-        for (const w of hookWarnings(preReport.outcomes, this._turn)) yield w;
-        let result;
-        if (preReport.blocked) {
-          const blocking = preReport.outcomes[preReport.outcomes.length - 1];
-          const reason = (blocking?.stderr || blocking?.stdout || "blocked by PreToolUse hook").trim();
-          result = `[hook block] ${blocking?.hook.command ?? "<unknown>"}
-${reason}`;
-        } else {
-          result = await this.tools.dispatch(name, args, {
-            signal,
-            maxResultTokens: DEFAULT_MAX_RESULT_TOKENS,
-            confirmationGate: this.confirmationGate
-          });
-          const postReport = await runHooks({
-            hooks: this.hooks,
-            payload: {
-              event: "PostToolUse",
-              cwd: this.hookCwd,
-              toolName: name,
-              toolArgs: parsedArgs,
-              toolResult: result
-            }
-          });
-          for (const w of hookWarnings(postReport.outcomes, this._turn)) yield w;
         }
-        this.appendAndPersist({
-          role: "tool",
-          tool_call_id: call.id ?? "",
-          name,
-          content: result
-        });
-        if (this.noteToolFailureSignal(result)) {
+        if (chunk.length === 0) {
+          chunk.push(repairedCalls[callIdx++]);
+        }
+        for (const call of chunk) {
           yield {
             turn: this._turn,
-            role: "warning",
-            content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this._turnFailures.formatBreakdown()}. Next turn falls back to ${this.model} unless /pro is armed.`
+            role: "tool_start",
+            content: "",
+            toolName: call.function?.name ?? "",
+            toolArgs: call.function?.arguments ?? "{}"
+          };
+        }
+        const settled = await Promise.allSettled(chunk.map((c) => this.runOneToolCall(c, signal)));
+        for (let k = 0; k < chunk.length; k++) {
+          const call = chunk[k];
+          const name = call.function?.name ?? "";
+          const args = call.function?.arguments ?? "{}";
+          const s = settled[k];
+          let result;
+          let preWarnings = [];
+          let postWarnings = [];
+          if (s.status === "fulfilled") {
+            preWarnings = s.value.preWarnings;
+            postWarnings = s.value.postWarnings;
+            result = s.value.result;
+          } else {
+            const err = s.reason instanceof Error ? s.reason : new Error(String(s.reason));
+            result = JSON.stringify({ error: `${err.name}: ${err.message}` });
+          }
+          for (const w of preWarnings) yield w;
+          for (const w of postWarnings) yield w;
+          this.appendAndPersist({
+            role: "tool",
+            tool_call_id: call.id ?? "",
+            name,
+            content: result
+          });
+          if (this.noteToolFailureSignal(result)) {
+            yield {
+              turn: this._turn,
+              role: "warning",
+              content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this._turnFailures.formatBreakdown()}. Next turn falls back to ${this.model} unless /pro is armed.`
+            };
+          }
+          yield {
+            turn: this._turn,
+            role: "tool",
+            content: result,
+            toolName: name,
+            toolArgs: args
           };
         }
-        yield {
-          turn: this._turn,
-          role: "tool",
-          content: result,
-          toolName: name,
-          toolArgs: args
-        };
       }
     }
     yield* forceSummaryAfterIterLimit(this.summaryContext(), { reason: "budget" });
@@ -3636,6 +3680,11 @@ function parseFrontmatter(raw) {
 function isValidSkillName(name) {
   return VALID_SKILL_NAME.test(name);
 }
+function parseAllowedTools(raw) {
+  if (raw === void 0) return void 0;
+  const names = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  return names.length > 0 ? Object.freeze(names) : void 0;
+}
 var SkillStore = class {
   homeDir;
   projectRoot;
@@ -3735,7 +3784,7 @@ var SkillStore = class {
       body: body.trim(),
       scope,
       path: path2,
-      allowedTools: data["allowed-tools"],
+      allowedTools: parseAllowedTools(data["allowed-tools"]),
       runAs: parseRunAs(data.runAs),
       model: data.model?.startsWith("deepseek-") ? data.model : void 0
     };
@@ -4599,6 +4648,7 @@ function registerFilesystemTools(registry, opts) {
   };
   registry.register({
     name: "read_file",
+    parallelSafe: true,
     description: `Read a file under the sandbox root. To save context, PREFER to scope the read instead of pulling the whole file:
   - head: N  \u2192 first N lines (imports, public API, small configs)
   - tail: N  \u2192 last N lines (recently-added code, log tails)
@@ -4682,6 +4732,7 @@ ${slice.join("\n")}`;
   });
   registry.register({
     name: "list_directory",
+    parallelSafe: true,
     description: "List entries in a directory under the sandbox root. Returns one line per entry, marking directories with a trailing slash. Not recursive \u2014 use directory_tree for that.",
     readOnly: true,
     parameters: {
@@ -4702,6 +4753,7 @@ ${slice.join("\n")}`;
   });
   registry.register({
     name: "directory_tree",
+    parallelSafe: true,
     description: `Recursively list entries in a directory. Shows indented tree structure with directories marked '/'. Budget-aware by default:
   - maxDepth defaults to 2 (root + one level). A depth-4 tree on a real repo blew ~5K tokens in one call. If you truly need deeper, pass maxDepth:N explicitly.
   - Skips ${[...SKIP_DIR_NAMES].sort().join(", ")} unless include_deps:true. Traversing into node_modules / .git / dist is almost always token-waste.
@@ -4780,6 +4832,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
   });
   registry.register({
     name: "search_files",
+    parallelSafe: true,
     description: "Find files whose NAME matches a substring or regex. Case-insensitive. Walks the directory recursively under the sandbox root. Returns one path per line. Skips dependency / VCS / build directories (node_modules, .git, dist, build, .next, target, .venv) by default.",
     readOnly: true,
     parameters: {
@@ -4805,6 +4858,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
   });
   registry.register({
     name: "search_content",
+    parallelSafe: true,
     description: "Recursively grep file CONTENTS for a substring or regex. This is the right tool for 'find all places that call X', 'where is Y referenced', 'what files contain Z'. Different from search_files (which matches FILE NAMES). Returns one match per line in 'path:line: text' format. Skips dependency / VCS / build directories (node_modules, .git, dist, build, .next, target, .venv) and binary files by default.",
     readOnly: true,
     parameters: {
@@ -4847,6 +4901,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
   });
   registry.register({
     name: "get_file_info",
+    parallelSafe: true,
     description: "Stat a path under the sandbox root. Returns type (file|directory|symlink), size in bytes, mtime in ISO-8601.",
     readOnly: true,
     parameters: {
@@ -5027,6 +5082,7 @@ function registerMemoryTools(registry, opts = {}) {
     name: "recall_memory",
     description: "Read the full body of a memory file when its MEMORY.md one-liner (already in the system prompt) isn't enough detail. Most of the time the index suffices \u2014 only call this when the user's question genuinely requires the full context.",
     readOnly: true,
+    parallelSafe: true,
     parameters: {
       type: "object",
       properties: {
@@ -5408,7 +5464,56 @@ function registerPlanTool(registry, opts = {}) {
   return registry;
 }
 
+// src/tools/subagent-types.ts
+var EXPLORE_SYSTEM = `You are an exploration subagent. Wide-net read-only investigation; return one distilled answer.
+
+How to operate:
+- Read-only tools only (read_file, search_files, search_content, directory_tree, list_directory, get_file_info).
+- For "find all places that call / reference / use X" \u2014 use search_content (content grep), NOT search_files (which only matches names).
+- Cast a wide net first to map the territory, then read the 3-10 most relevant files in full. Stop as soon as you can answer.
+- The parent does not see your tool calls \u2014 over-exploration is pure waste.
+
+Final answer:
+- One paragraph or short bullets; lead with the conclusion.
+- Cite file:line ranges when they back the claim.
+- No follow-up offers, no "let me know if you need more" \u2014 the parent will ask again.
+
+${NEGATIVE_CLAIM_RULE}
+
+${TUI_FORMATTING_RULES}`;
+var VERIFY_SYSTEM = `You are a verify subagent. Narrow check \u2014 return YES / NO / INCONCLUSIVE with evidence. Do not expand scope.
+
+How to operate:
+- Read only what's needed to verify the specific claim. No exploration past the claim.
+- Use search_content / read_file to confirm the exact behavior, type, or call site in question.
+- Cap at 6-8 tool calls. If you can't verify in that, return INCONCLUSIVE plus what's missing.
+
+Final answer:
+- Lead with VERIFIED / NOT VERIFIED / INCONCLUSIVE.
+- Cite file:line for the evidence.
+- One paragraph or a few bullets. No follow-up offers.
+
+${NEGATIVE_CLAIM_RULE}
+
+${TUI_FORMATTING_RULES}`;
+var TYPES = {
+  explore: { system: EXPLORE_SYSTEM, maxToolIters: 20 },
+  verify: { system: VERIFY_SYSTEM, maxToolIters: 8 }
+};
+var SUBAGENT_TYPE_NAMES = Object.freeze(
+  Object.keys(TYPES)
+);
+function getSubagentType(name) {
+  if (typeof name !== "string") return void 0;
+  return TYPES[name];
+}
+
 // src/tools/subagent.ts
+var runIdCounter = 0;
+function nextRunId() {
+  runIdCounter++;
+  return `sub-${runIdCounter.toString(36)}`;
+}
 var DEFAULT_SUBAGENT_SYSTEM = `You are a Reasonix subagent. The parent agent spawned you to handle one focused subtask, then return.
 
 Rules:
@@ -5424,6 +5529,8 @@ ${ESCALATION_CONTRACT}
 ${TUI_FORMATTING_RULES}`;
 var DEFAULT_MAX_RESULT_CHARS2 = 8e3;
 var DEFAULT_MAX_ITERS = 16;
+var MIN_MAX_ITERS = 1;
+var MAX_MAX_ITERS = 32;
 var DEFAULT_SUBAGENT_MODEL = "deepseek-v4-flash";
 var DEFAULT_SUBAGENT_EFFORT = "high";
 var SUBAGENT_TOOL_NAME = "spawn_subagent";
@@ -5435,16 +5542,53 @@ async function spawnSubagent(opts) {
   const sink = opts.sink;
   const skillName = opts.skillName;
   const startedAt = Date.now();
+  const runId = nextRunId();
   const taskPreview = opts.task.length > 30 ? `${opts.task.slice(0, 30)}\u2026` : opts.task;
   sink?.current?.({
     kind: "start",
+    runId,
     task: taskPreview,
     skillName,
     model,
     iter: 0,
     elapsedMs: 0
   });
-  const childTools = forkRegistryExcluding(opts.parentRegistry, NEVER_INHERITED_TOOLS);
+  if (opts.allowedTools) {
+    const missing = opts.allowedTools.filter((n) => !opts.parentRegistry.has(n));
+    if (missing.length > 0) {
+      const errorMessage2 = `subagent allow-list names tool(s) not registered in the parent: ${missing.join(", ")}. Fix the skill's \`allowed-tools\` frontmatter or check spelling.`;
+      sink?.current?.({
+        kind: "end",
+        runId,
+        task: taskPreview,
+        skillName,
+        model,
+        iter: 0,
+        elapsedMs: Date.now() - startedAt,
+        error: errorMessage2,
+        turns: 0,
+        costUsd: 0,
+        usage: new Usage()
+      });
+      return {
+        success: false,
+        output: "",
+        error: errorMessage2,
+        turns: 0,
+        toolIters: 0,
+        elapsedMs: Date.now() - startedAt,
+        costUsd: 0,
+        model,
+        skillName,
+        usage: new Usage()
+      };
+    }
+  }
+  const childTools = opts.allowedTools ? forkRegistryWithAllowList(
+    opts.parentRegistry,
+    new Set(opts.allowedTools),
+    NEVER_INHERITED_TOOLS
+  ) : forkRegistryExcluding(opts.parentRegistry, NEVER_INHERITED_TOOLS);
   const childPrefix = new ImmutablePrefix({
     system: opts.system,
     toolSpecs: childTools.specs()
@@ -5477,12 +5621,13 @@ async function spawnSubagent(opts) {
   let summarisingEmitted = false;
   try {
     for await (const ev of childLoop.step(opts.task)) {
-      sink?.current?.({ kind: "inner", task: taskPreview, skillName, model, inner: ev });
+      sink?.current?.({ kind: "inner", runId, task: taskPreview, skillName, model, inner: ev });
       if (ev.role === "tool") {
         toolIter++;
         summarisingEmitted = false;
         sink?.current?.({
           kind: "progress",
+          runId,
           task: taskPreview,
           skillName,
           model,
@@ -5494,6 +5639,7 @@ async function spawnSubagent(opts) {
         summarisingEmitted = true;
         sink?.current?.({
           kind: "phase",
+          runId,
           task: taskPreview,
           skillName,
           model,
@@ -5530,6 +5676,7 @@ async function spawnSubagent(opts) {
 [\u2026truncated ${final.length - maxResultChars} chars; ask the subagent for a tighter summary if you need more.]` : final;
   sink?.current?.({
     kind: "end",
+    runId,
     task: taskPreview,
     skillName,
     model,
@@ -5593,6 +5740,7 @@ function registerSubagentTool(parentRegistry, opts) {
   const sink = opts.sink;
   parentRegistry.register({
     name: SUBAGENT_TOOL_NAME,
+    parallelSafe: true,
     description: "Spawn an isolated subagent to handle a self-contained subtask in a fresh context, returning only its final answer. Use for: deep codebase exploration that would flood the main context, multi-step research where you only need the conclusion, or any focused subtask whose intermediate reasoning the user does not need to see. The subagent inherits all your tools (filesystem, shell, web, MCP, etc.) but runs in its own isolated message log \u2014 its tool calls and reasoning never enter your context. Only the final assistant message comes back as this tool's result. Keep tasks focused; the subagent has a stricter iter budget than you do.",
     parameters: {
       type: "object",
@@ -5609,6 +5757,17 @@ function registerSubagentTool(parentRegistry, opts) {
           type: "string",
           enum: ["deepseek-v4-flash", "deepseek-v4-pro"],
           description: "Which DeepSeek model the subagent runs on. Default is 'deepseek-v4-flash' \u2014 cheap and fast, fine for explore/research-style subtasks. Override to 'deepseek-v4-pro' (~12\xD7 more expensive) when the subtask genuinely needs the stronger model: cross-file architecture, subtle bug hunts, anything where flash has empirically underperformed."
+        },
+        max_iters: {
+          type: "integer",
+          minimum: MIN_MAX_ITERS,
+          maximum: MAX_MAX_ITERS,
+          description: `Cap on the subagent's tool-call iterations. Default 16 (or the type's default when 'type' is set). Hard range: ${MIN_MAX_ITERS}-${MAX_MAX_ITERS}; out-of-range values are clamped to the nearest end.`
+        },
+        type: {
+          type: "string",
+          enum: [...SUBAGENT_TYPE_NAMES],
+          description: "Optional persona shaping the system prompt and default iter budget. 'explore' = wide-net read-only investigation (20-iter budget, returns a distilled answer). 'verify' = narrow yes/no check with evidence (8-iter budget). Omit when supplying your own 'system' prompt or when the default generic persona fits. Caller-supplied 'system' / 'max_iters' override the type's defaults."
         }
       },
       required: ["task"]
@@ -5620,15 +5779,17 @@ function registerSubagentTool(parentRegistry, opts) {
           error: "spawn_subagent requires a non-empty 'task' argument."
         });
       }
-      const system = typeof args.system === "string" && args.system.trim().length > 0 ? args.system.trim() : defaultSystem;
+      const typeSpec = getSubagentType(args.type);
+      const system = typeof args.system === "string" && args.system.trim().length > 0 ? args.system.trim() : typeSpec?.system ?? defaultSystem;
       const model = typeof args.model === "string" && args.model.startsWith("deepseek-") ? args.model : defaultModel;
+      const callerIters = clampMaxIters(args.max_iters);
       const result = await spawnSubagent({
         client: opts.client,
         parentRegistry,
         system,
         task,
         model,
-        maxToolIters,
+        maxToolIters: callerIters ?? typeSpec?.maxToolIters ?? maxToolIters,
         maxResultChars,
         sink,
         parentSignal: ctx?.signal
@@ -5638,6 +5799,13 @@ function registerSubagentTool(parentRegistry, opts) {
   });
   return parentRegistry;
 }
+function clampMaxIters(raw) {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) return void 0;
+  const n = Math.floor(raw);
+  if (n < MIN_MAX_ITERS) return MIN_MAX_ITERS;
+  if (n > MAX_MAX_ITERS) return MAX_MAX_ITERS;
+  return n;
+}
 function forkRegistryExcluding(parent, exclude) {
   const child = new ToolRegistry();
   for (const spec of parent.specs()) {
@@ -5650,6 +5818,19 @@ function forkRegistryExcluding(parent, exclude) {
   if (parent.planMode) child.setPlanMode(true);
   return child;
 }
+function forkRegistryWithAllowList(parent, allow, alsoExclude) {
+  const child = new ToolRegistry();
+  for (const spec of parent.specs()) {
+    const name = spec.function.name;
+    if (!allow.has(name)) continue;
+    if (alsoExclude.has(name)) continue;
+    const def = parent.get(name);
+    if (!def) continue;
+    child.register(def);
+  }
+  if (parent.planMode) child.setPlanMode(true);
+  return child;
+}
 
 // src/tools/shell.ts
 import * as pathMod7 from "path";
@@ -6985,6 +7166,7 @@ function registerShellTools(registry, opts) {
     name: "job_output",
     description: "Read the latest output of a background job started with `run_background`. By default returns the tail of the buffer (last 80 lines). Pass `since` (the `byteLength` from a previous call) to stream only new content incrementally. Tells you whether the job is still running, so you can stop polling when it's done.",
     readOnly: true,
+    parallelSafe: true,
     parameters: {
       type: "object",
       properties: {
@@ -7029,6 +7211,7 @@ function registerShellTools(registry, opts) {
     name: "list_jobs",
     description: "List every background job started this session \u2014 running and exited \u2014 with id, command, pid, status. Use when you've lost track of which job_id corresponds to which process, or to see what's still alive.",
     readOnly: true,
+    parallelSafe: true,
     parameters: { type: "object", properties: {} },
     fn: async () => {
       const all = jobs.list();
@@ -7286,6 +7469,7 @@ function registerWebTools(registry, opts = {}) {
     name: "web_search",
     description: "Search the public web. Returns ranked results with title, url, and snippet. Call this when the answer's correctness depends on current state \u2014 anything that changes over time (events, prices, releases, status of a thing in the real world). Composing such answers from training memory invents stale numbers; search first, then ground the answer in the results. For evergreen / definitional questions you don't need this.",
     readOnly: true,
+    parallelSafe: true,
     parameters: {
       type: "object",
       properties: {
@@ -7309,6 +7493,7 @@ function registerWebTools(registry, opts = {}) {
     name: "web_fetch",
     description: "Download a URL and return its visible text content (HTML pages get scripts/styles/nav stripped). Truncated at the tool-result cap. Use after web_search when a snippet isn't enough.",
     readOnly: true,
+    parallelSafe: true,
     parameters: {
       type: "object",
       properties: {