zidane 5.3.2 → 5.4.0

package/dist/{presets-0_IRJAYF.js.map → presets-M8f6lDnW.js.map}

@@ -1 +1 @@
-{"version":3,"file":"presets-0_IRJAYF.js","names":[],"sources":["../src/presets/basic.ts","../src/presets/index.ts"],"sourcesContent":["import { definePreset } from '.'\nimport { edit, listFiles, multiEdit, readFile, shell, writeFile } from '../tools'\nimport { createSpawnTool } from '../tools/spawn'\n\n/**\n * Core tools available in every basic preset (without spawn).\n *\n * `edit` and `multi_edit` ship in the basic set because surgical edits are the\n * default modality for production agents — `write_file` is for full overwrites.\n * `glob` and `grep` are exported but opt-in: not every agent needs codebase\n * search, and shipping them by default would force `tool:gate` work onto\n * consumers that prefer the model to use `shell` + classic Unix tools.\n */\nexport const basicTools = { shell, readFile, writeFile, listFiles, edit, multiEdit }\n\nexport default definePreset({\n  name: 'basic',\n  system: 'You are a helpful assistant with access to shell, file reading, file writing, surgical and multi-edit tools, directory listing, and sub-agent spawning. Prefer `edit` / `multi_edit` for in-place changes and `write_file` for full file overwrites. Use them to accomplish tasks in the project directory.',\n  // `persist: true` shares the parent's session with every child agent — child\n  // turns land in `session.turns` tagged with their own `runId`, and the run\n  // itself is recorded in `session.runs` with `parentRunId` + `depth`. That's\n  // what lets a reloaded TUI session reconstruct the full subagent tree (see\n  // `eventsFromTurns` in `tui/store.ts`). Hosts that want children in-memory\n  // only can construct their own preset with `createSpawnTool()`.\n  tools: { ...basicTools, spawn: createSpawnTool({ persist: true }) },\n})\n","import type { AgentHooks, AgentOptions } from '../agent'\n\nexport type { AgentHookMap } from '../agent'\n\n/**\n * A preset is a reusable slice of `AgentOptions` — spread it into `createAgent()`\n * to configure tools, a default system prompt, aliases, behavior defaults, and\n * agent-lifetime hooks.\n *\n * `provider`, `execution`, `session`, and internal fields are excluded so presets\n * remain shareable and composable.\n *\n * ```ts\n * import { basic } from 'zidane/presets'\n * createAgent({ ...basic, provider })\n * ```\n *\n * ### Composing multiple presets\n *\n * Bare `...spread` is shallow — `{ ...a, ...b }` overwrites every key `b`\n * defines, including `hooks`. Use {@link composePresets} when you want\n * field-aware merging (per-event hook concat, tools shallow-merge, etc.):\n *\n * ```ts\n * createAgent({ ...composePresets(basic, telemetry, mine), provider })\n * ```\n */\nexport type Preset = Omit<Partial<AgentOptions>, 'provider' | 'execution' | 'session' | 'mcpConnector'>\n\n/**\n * Identity helper for type inference when defining a preset.\n */\nexport function definePreset(config: Preset): Preset {\n  return config\n}\n\n/**\n * Field-aware composition of presets. Right-most preset wins for scalar fields;\n * objects shallow-merge; arrays and hook handler lists concatenate. Designed so\n * stacking presets does the obvious thing without the spread-collision footgun:\n *\n * - `name`, `system`, `eager`, `skills`              → last-defined wins\n * - `tools`, `toolAliases`, `behavior`               → shallow-merge (later keys override)\n * - `behavior.dedupTools`, `behavior.toolBudgets`    → **deep-merge** (per-tool-name; later wins on collision)\n * - `mcpServers`                                     → concat with last-wins on `name` collision\n * - `hooks`                                          → per-event concat; every handler fires\n *\n * `hooks` always emerges as `event → handler[]` so downstream registration\n * (in `createAgent`) sees a uniform shape. Order of handlers within an event\n * follows preset order: earlier presets register first.\n *\n * `mcpServers` is deduped by `name` because shipping two servers with the same\n * name would trip the connector at runtime — a later preset overriding an\n * earlier preset's `github` server is the practical intent.\n *\n * `behavior.dedupTools` and `behavior.toolBudgets` get the same per-key deep-merge\n * because they are tool-name-keyed records — a preset that ships a dedup hasher\n * for one tool should not erase a hasher another preset ships for a different\n * tool. Last-wins still applies on a per-tool collision so a downstream preset\n * can override an upstream preset's policy for one specific tool. Other\n * `behavior` fields keep last-wins semantics.\n */\nexport function composePresets(...presets: Preset[]): Preset {\n  const out: Preset = {}\n  const hooksByEvent: { [K in keyof AgentHooks]?: AgentHooks[K][] } = {}\n  // Keep mcpServers in source-order on first sight, but allow later\n  // declarations to override earlier ones with the same `name`. A `Map`\n  // keyed by name gives O(1) override + stable iteration.\n  const mcpByName = new Map<string, NonNullable<Preset['mcpServers']>[number]>()\n\n  for (const p of presets) {\n    if (p.name !== undefined)\n      out.name = p.name\n    if (p.system !== undefined)\n      out.system = p.system\n    if (p.eager !== undefined)\n      out.eager = p.eager\n    if (p.skills !== undefined)\n      out.skills = p.skills\n    if (p.tools)\n      out.tools = { ...out.tools, ...p.tools }\n    if (p.toolAliases)\n      out.toolAliases = { ...out.toolAliases, ...p.toolAliases }\n    if (p.behavior) {\n      // Top-level shallow-merge first; then deep-merge the two tool-name-keyed\n      // sub-records so per-tool entries from earlier presets aren't clobbered.\n      const merged: NonNullable<Preset['behavior']> = { ...out.behavior, ...p.behavior }\n      if (out.behavior?.dedupTools || p.behavior.dedupTools) {\n        merged.dedupTools = { ...out.behavior?.dedupTools, ...p.behavior.dedupTools }\n      }\n      if (out.behavior?.toolBudgets || p.behavior.toolBudgets) {\n        merged.toolBudgets = { ...out.behavior?.toolBudgets, ...p.behavior.toolBudgets }\n      }\n      out.behavior = merged\n    }\n    if (p.mcpServers) {\n      for (const server of p.mcpServers)\n        mcpByName.set(server.name, server)\n    }\n    if (p.hooks) {\n      for (const [event, handler] of Object.entries(p.hooks)) {\n        if (handler === undefined)\n          continue\n        const list = Array.isArray(handler) ? handler : [handler]\n        const key = event as keyof AgentHooks\n        // Safe cast: we read the loose `AgentHookMap` shape (handler-or-array)\n        // and re-emit only as arrays. Each `list` element matches the event's\n        // handler signature by construction (the input was typed `AgentHookMap`).\n        const bucket = (hooksByEvent[key] ??= []) as unknown[]\n        bucket.push(...(list as unknown[]))\n      }\n    }\n  }\n\n  if (mcpByName.size > 0)\n    out.mcpServers = [...mcpByName.values()]\n\n  if (Object.keys(hooksByEvent).length > 0)\n    out.hooks = hooksByEvent\n\n  return out\n}\n\nexport { default as basic, basicTools } from './basic'\n"],"mappings":";;;;;;;;;;;AAaA,MAAa,aAAa;CAAE;CAAO;CAAU;CAAW;CAAW;CAAM;CAAW;AAEpF,IAAA,gBAAe,aAAa;CAC1B,MAAM;CACN,QAAQ;CAOR,OAAO;EAAE,GAAG;EAAY,OAAO,gBAAgB,EAAE,SAAS,MAAM,CAAC;EAAE;CACpE,CAAC;;;;;;ACOF,SAAgB,aAAa,QAAwB;CACnD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BT,SAAgB,eAAe,GAAG,SAA2B;CAC3D,MAAM,MAAc,EAAE;CACtB,MAAM,eAA8D,EAAE;CAItE,MAAM,4BAAY,IAAI,KAAwD;CAE9E,KAAK,MAAM,KAAK,SAAS;EACvB,IAAI,EAAE,SAAS,KAAA,GACb,IAAI,OAAO,EAAE;EACf,IAAI,EAAE,WAAW,KAAA,GACf,IAAI,SAAS,EAAE;EACjB,IAAI,EAAE,UAAU,KAAA,GACd,IAAI,QAAQ,EAAE;EAChB,IAAI,EAAE,WAAW,KAAA,GACf,IAAI,SAAS,EAAE;EACjB,IAAI,EAAE,OACJ,IAAI,QAAQ;GAAE,GAAG,IAAI;GAAO,GAAG,EAAE;GAAO;EAC1C,IAAI,EAAE,aACJ,IAAI,cAAc;GAAE,GAAG,IAAI;GAAa,GAAG,EAAE;GAAa;EAC5D,IAAI,EAAE,UAAU;GAGd,MAAM,SAA0C;IAAE,GAAG,IAAI;IAAU,GAAG,EAAE;IAAU;GAClF,IAAI,IAAI,UAAU,cAAc,EAAE,SAAS,YACzC,OAAO,aAAa;IAAE,GAAG,IAAI,UAAU;IAAY,GAAG,EAAE,SAAS;IAAY;GAE/E,IAAI,IAAI,UAAU,eAAe,EAAE,SAAS,aAC1C,OAAO,cAAc;IAAE,GAAG,IAAI,UAAU;IAAa,GAAG,EAAE,SAAS;IAAa;GAElF,IAAI,WAAW;;EAEjB,IAAI,EAAE,YACJ,KAAK,MAAM,UAAU,EAAE,YACrB,UAAU,IAAI,OAAO,MAAM,OAAO;EAEtC,IAAI,EAAE,OACJ,KAAK,MAAM,CAAC,OAAO,YAAY,OAAO,QAAQ,EAAE,MAAM,EAAE;GACtD,IAAI,YAAY,KAAA,GACd;GACF,MAAM,OAAO,MAAM,QAAQ,QAAQ,GAAG,UAAU,CAAC,QAAQ;GACzD,MAAM,MAAM;GAKZ,CADgB,aAAa,SAAS,EAAE,EACjC,KAAK,GAAI,KAAmB;;;CAKzC,IAAI,UAAU,OAAO,GACnB,IAAI,aAAa,CAAC,GAAG,UAAU,QAAQ,CAAC;CAE1C,IAAI,OAAO,KAAK,aAAa,CAAC,SAAS,GACrC,IAAI,QAAQ;CAEd,OAAO"}
+{"version":3,"file":"presets-M8f6lDnW.js","names":[],"sources":["../src/presets/basic.ts","../src/presets/index.ts"],"sourcesContent":["import { definePreset } from '.'\nimport { edit, listFiles, multiEdit, readFile, shell, writeFile } from '../tools'\nimport { createSpawnTool } from '../tools/spawn'\n\n/**\n * Core tools available in every basic preset (without spawn).\n *\n * `edit` and `multi_edit` ship in the basic set because surgical edits are the\n * default modality for production agents — `write_file` is for full overwrites.\n * `glob` and `grep` are exported but opt-in: not every agent needs codebase\n * search, and shipping them by default would force `tool:gate` work onto\n * consumers that prefer the model to use `shell` + classic Unix tools.\n */\nexport const basicTools = { shell, readFile, writeFile, listFiles, edit, multiEdit }\n\nexport default definePreset({\n  name: 'basic',\n  system: 'You are a helpful assistant with access to shell, file reading, file writing, surgical and multi-edit tools, directory listing, and sub-agent spawning. Prefer `edit` / `multi_edit` for in-place changes and `write_file` for full file overwrites. Use them to accomplish tasks in the project directory.',\n  // `persist: true` shares the parent's session with every child agent — child\n  // turns land in `session.turns` tagged with their own `runId`, and the run\n  // itself is recorded in `session.runs` with `parentRunId` + `depth`. That's\n  // what lets a reloaded TUI session reconstruct the full subagent tree (see\n  // `eventsFromTurns` in `tui/store.ts`). Hosts that want children in-memory\n  // only can construct their own preset with `createSpawnTool()`.\n  tools: { ...basicTools, spawn: createSpawnTool({ persist: true }) },\n})\n","import type { AgentHooks, AgentOptions } from '../agent'\n\nexport type { AgentHookMap } from '../agent'\n\n/**\n * A preset is a reusable slice of `AgentOptions` — spread it into `createAgent()`\n * to configure tools, a default system prompt, aliases, behavior defaults, and\n * agent-lifetime hooks.\n *\n * `provider`, `execution`, `session`, and internal fields are excluded so presets\n * remain shareable and composable.\n *\n * ```ts\n * import { basic } from 'zidane/presets'\n * createAgent({ ...basic, provider })\n * ```\n *\n * ### Composing multiple presets\n *\n * Bare `...spread` is shallow — `{ ...a, ...b }` overwrites every key `b`\n * defines, including `hooks`. Use {@link composePresets} when you want\n * field-aware merging (per-event hook concat, tools shallow-merge, etc.):\n *\n * ```ts\n * createAgent({ ...composePresets(basic, telemetry, mine), provider })\n * ```\n */\nexport type Preset = Omit<Partial<AgentOptions>, 'provider' | 'execution' | 'session' | 'mcpConnector'>\n\n/**\n * Identity helper for type inference when defining a preset.\n */\nexport function definePreset(config: Preset): Preset {\n  return config\n}\n\n/**\n * Field-aware composition of presets. Right-most preset wins for scalar fields;\n * objects shallow-merge; arrays and hook handler lists concatenate. Designed so\n * stacking presets does the obvious thing without the spread-collision footgun:\n *\n * - `name`, `system`, `eager`, `skills`              → last-defined wins\n * - `tools`, `toolAliases`, `behavior`               → shallow-merge (later keys override)\n * - `behavior.dedupTools`, `behavior.toolBudgets`    → **deep-merge** (per-tool-name; later wins on collision)\n * - `mcpServers`                                     → concat with last-wins on `name` collision\n * - `hooks`                                          → per-event concat; every handler fires\n *\n * `hooks` always emerges as `event → handler[]` so downstream registration\n * (in `createAgent`) sees a uniform shape. Order of handlers within an event\n * follows preset order: earlier presets register first.\n *\n * `mcpServers` is deduped by `name` because shipping two servers with the same\n * name would trip the connector at runtime — a later preset overriding an\n * earlier preset's `github` server is the practical intent.\n *\n * `behavior.dedupTools` and `behavior.toolBudgets` get the same per-key deep-merge\n * because they are tool-name-keyed records — a preset that ships a dedup hasher\n * for one tool should not erase a hasher another preset ships for a different\n * tool. Last-wins still applies on a per-tool collision so a downstream preset\n * can override an upstream preset's policy for one specific tool. Other\n * `behavior` fields keep last-wins semantics.\n */\nexport function composePresets(...presets: Preset[]): Preset {\n  const out: Preset = {}\n  const hooksByEvent: { [K in keyof AgentHooks]?: AgentHooks[K][] } = {}\n  // Keep mcpServers in source-order on first sight, but allow later\n  // declarations to override earlier ones with the same `name`. A `Map`\n  // keyed by name gives O(1) override + stable iteration.\n  const mcpByName = new Map<string, NonNullable<Preset['mcpServers']>[number]>()\n\n  for (const p of presets) {\n    if (p.name !== undefined)\n      out.name = p.name\n    if (p.system !== undefined)\n      out.system = p.system\n    if (p.eager !== undefined)\n      out.eager = p.eager\n    if (p.skills !== undefined)\n      out.skills = p.skills\n    if (p.tools)\n      out.tools = { ...out.tools, ...p.tools }\n    if (p.toolAliases)\n      out.toolAliases = { ...out.toolAliases, ...p.toolAliases }\n    if (p.behavior) {\n      // Top-level shallow-merge first; then deep-merge the two tool-name-keyed\n      // sub-records so per-tool entries from earlier presets aren't clobbered.\n      const merged: NonNullable<Preset['behavior']> = { ...out.behavior, ...p.behavior }\n      if (out.behavior?.dedupTools || p.behavior.dedupTools) {\n        merged.dedupTools = { ...out.behavior?.dedupTools, ...p.behavior.dedupTools }\n      }\n      if (out.behavior?.toolBudgets || p.behavior.toolBudgets) {\n        merged.toolBudgets = { ...out.behavior?.toolBudgets, ...p.behavior.toolBudgets }\n      }\n      out.behavior = merged\n    }\n    if (p.mcpServers) {\n      for (const server of p.mcpServers)\n        mcpByName.set(server.name, server)\n    }\n    if (p.hooks) {\n      for (const [event, handler] of Object.entries(p.hooks)) {\n        if (handler === undefined)\n          continue\n        const list = Array.isArray(handler) ? handler : [handler]\n        const key = event as keyof AgentHooks\n        // Safe cast: we read the loose `AgentHookMap` shape (handler-or-array)\n        // and re-emit only as arrays. Each `list` element matches the event's\n        // handler signature by construction (the input was typed `AgentHookMap`).\n        const bucket = (hooksByEvent[key] ??= []) as unknown[]\n        bucket.push(...(list as unknown[]))\n      }\n    }\n  }\n\n  if (mcpByName.size > 0)\n    out.mcpServers = [...mcpByName.values()]\n\n  if (Object.keys(hooksByEvent).length > 0)\n    out.hooks = hooksByEvent\n\n  return out\n}\n\nexport { default as basic, basicTools } from './basic'\n"],"mappings":";;;;;;;;;;;AAaA,MAAa,aAAa;CAAE;CAAO;CAAU;CAAW;CAAW;CAAM;CAAW;AAEpF,IAAA,gBAAe,aAAa;CAC1B,MAAM;CACN,QAAQ;CAOR,OAAO;EAAE,GAAG;EAAY,OAAO,gBAAgB,EAAE,SAAS,MAAM,CAAC;EAAE;CACpE,CAAC;;;;;;ACOF,SAAgB,aAAa,QAAwB;CACnD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BT,SAAgB,eAAe,GAAG,SAA2B;CAC3D,MAAM,MAAc,EAAE;CACtB,MAAM,eAA8D,EAAE;CAItE,MAAM,4BAAY,IAAI,KAAwD;CAE9E,KAAK,MAAM,KAAK,SAAS;EACvB,IAAI,EAAE,SAAS,KAAA,GACb,IAAI,OAAO,EAAE;EACf,IAAI,EAAE,WAAW,KAAA,GACf,IAAI,SAAS,EAAE;EACjB,IAAI,EAAE,UAAU,KAAA,GACd,IAAI,QAAQ,EAAE;EAChB,IAAI,EAAE,WAAW,KAAA,GACf,IAAI,SAAS,EAAE;EACjB,IAAI,EAAE,OACJ,IAAI,QAAQ;GAAE,GAAG,IAAI;GAAO,GAAG,EAAE;GAAO;EAC1C,IAAI,EAAE,aACJ,IAAI,cAAc;GAAE,GAAG,IAAI;GAAa,GAAG,EAAE;GAAa;EAC5D,IAAI,EAAE,UAAU;GAGd,MAAM,SAA0C;IAAE,GAAG,IAAI;IAAU,GAAG,EAAE;IAAU;GAClF,IAAI,IAAI,UAAU,cAAc,EAAE,SAAS,YACzC,OAAO,aAAa;IAAE,GAAG,IAAI,UAAU;IAAY,GAAG,EAAE,SAAS;IAAY;GAE/E,IAAI,IAAI,UAAU,eAAe,EAAE,SAAS,aAC1C,OAAO,cAAc;IAAE,GAAG,IAAI,UAAU;IAAa,GAAG,EAAE,SAAS;IAAa;GAElF,IAAI,WAAW;;EAEjB,IAAI,EAAE,YACJ,KAAK,MAAM,UAAU,EAAE,YACrB,UAAU,IAAI,OAAO,MAAM,OAAO;EAEtC,IAAI,EAAE,OACJ,KAAK,MAAM,CAAC,OAAO,YAAY,OAAO,QAAQ,EAAE,MAAM,EAAE;GACtD,IAAI,YAAY,KAAA,GACd;GACF,MAAM,OAAO,MAAM,QAAQ,QAAQ,GAAG,UAAU,CAAC,QAAQ;GACzD,MAAM,MAAM;GAKZ,CADgB,aAAa,SAAS,EAAE,EACjC,KAAK,GAAI,KAAmB;;;CAKzC,IAAI,UAAU,OAAO,GACnB,IAAI,aAAa,CAAC,GAAG,UAAU,QAAQ,CAAC;CAE1C,IAAI,OAAO,KAAK,aAAa,CAAC,SAAS,GACrC,IAAI,QAAQ;CAEd,OAAO"}

package/dist/presets.d.ts

@@ -1,3 +1,3 @@
-import { n as AgentHookMap } from "./agent-BXRCCHeq.js";
-import { a as basicTools, i as _default, n as composePresets, r as definePreset, t as Preset } from "./index-BPk8-Slm.js";
+import { n as AgentHookMap } from "./agent-DHQAsdj6.js";
+import { a as basicTools, i as _default, n as composePresets, r as definePreset, t as Preset } from "./index-CrqFoaQA.js";
 export { AgentHookMap, Preset, _default as basic, basicTools, composePresets, definePreset };

package/dist/presets.js

@@ -1,2 +1,2 @@
-import { i as basic_default, n as definePreset, r as basicTools, t as composePresets } from "./presets-0_IRJAYF.js";
+import { i as basic_default, n as definePreset, r as basicTools, t as composePresets } from "./presets-M8f6lDnW.js";
 export { basic_default as basic, basicTools, composePresets, definePreset };

package/dist/providers.d.ts

@@ -1,2 +1,2 @@
-import { At as cerebras, Ct as OpenAICompatParams, Dt as OpenAIParams, Et as openaiCompat, Mt as anthropic, Ot as openai, St as OpenAICompatHttpError, Tt as mapOAIFinishReason, _t as sanitizeToolSchema, bt as openrouter, ct as StreamCallbacks, dt as ToolResult, ft as ToolSpec, gt as SchemaSanitizeResult, ht as SchemaSanitizeProfile, jt as AnthropicParams, kt as CerebrasParams, lt as StreamOptions, mt as SchemaSanitizeOptions, ot as Provider, pt as TurnResult, st as ProviderCapabilities, ut as ToolCall, vt as sanitizeToolSpecs, wt as classifyOpenAICompatError, xt as OpenAICompatAuthHeader, yt as OpenRouterParams } from "./agent-BXRCCHeq.js";
+import { At as cerebras, Ct as OpenAICompatParams, Dt as OpenAIParams, Et as openaiCompat, Mt as anthropic, Ot as openai, St as OpenAICompatHttpError, Tt as mapOAIFinishReason, _t as sanitizeToolSchema, bt as openrouter, ct as StreamCallbacks, dt as ToolResult, ft as ToolSpec, gt as SchemaSanitizeResult, ht as SchemaSanitizeProfile, jt as AnthropicParams, kt as CerebrasParams, lt as StreamOptions, mt as SchemaSanitizeOptions, ot as Provider, pt as TurnResult, st as ProviderCapabilities, ut as ToolCall, vt as sanitizeToolSpecs, wt as classifyOpenAICompatError, xt as OpenAICompatAuthHeader, yt as OpenRouterParams } from "./agent-DHQAsdj6.js";
 export { AnthropicParams, CerebrasParams, OpenAICompatAuthHeader, OpenAICompatHttpError, OpenAICompatParams, OpenAIParams, OpenRouterParams, Provider, ProviderCapabilities, SchemaSanitizeOptions, SchemaSanitizeProfile, SchemaSanitizeResult, StreamCallbacks, StreamOptions, ToolCall, ToolResult, ToolSpec, TurnResult, anthropic, cerebras, classifyOpenAICompatError, mapOAIFinishReason, openai, openaiCompat, openrouter, sanitizeToolSchema, sanitizeToolSpecs };

package/dist/session/sqlite.d.ts

@@ -1,4 +1,4 @@
-import { I as SessionStore } from "../agent-BXRCCHeq.js";
+import { I as SessionStore } from "../agent-DHQAsdj6.js";
 
 //#region src/session/sqlite.d.ts
 interface SqliteStoreOptions {

package/dist/session.d.ts

@@ -1,2 +1,2 @@
-import { $ as fromOpenAI, B as createRemoteStore, F as SessionRun, I as SessionStore, J as autoDetectAndConvert, Kt as SessionContentBlock, L as createSession, M as CreateSessionOptions, N as Session, P as SessionData, Q as fromAnthropic, R as loadSession, Xt as SessionTurn, Yt as SessionMessage, at as createFileMapStore, et as toAnthropic, it as FileMapStoreOptions, nt as createMemoryStore, rt as FileMapAdapter, tt as toOpenAI, z as RemoteStoreOptions } from "./agent-BXRCCHeq.js";
+import { $ as fromOpenAI, B as createRemoteStore, F as SessionRun, I as SessionStore, J as autoDetectAndConvert, Kt as SessionContentBlock, L as createSession, M as CreateSessionOptions, N as Session, P as SessionData, Q as fromAnthropic, R as loadSession, Xt as SessionTurn, Yt as SessionMessage, at as createFileMapStore, et as toAnthropic, it as FileMapStoreOptions, nt as createMemoryStore, rt as FileMapAdapter, tt as toOpenAI, z as RemoteStoreOptions } from "./agent-DHQAsdj6.js";
 export { CreateSessionOptions, FileMapAdapter, FileMapStoreOptions, RemoteStoreOptions, Session, SessionContentBlock, SessionData, SessionMessage, SessionRun, SessionStore, SessionTurn, autoDetectAndConvert, createFileMapStore, createMemoryStore, createRemoteStore, createSession, fromAnthropic, fromOpenAI, loadSession, toAnthropic, toOpenAI };

package/dist/skills.d.ts

@@ -1,3 +1,3 @@
-import { A as SkillSource, D as SkillConfig, O as SkillDiagnostic, c as DeactivationReason, d as createSkillActivationState, j as SkillsConfig, k as SkillResource, l as SkillActivationState, o as ActivationVia, s as ActiveSkill, u as SkillActivationStateOptions } from "./agent-BXRCCHeq.js";
-import { S as installAllowedToolsGate, _ as inferSource, a as SkillValidationResult, b as buildCatalog, c as parseAllowedToolPattern, d as validateSkillName, f as resolveSkills, g as getDefaultScanPaths, h as discoverSkills, i as SkillValidationIssue, l as validateResourcePath, m as SourcedScanPath, n as writeSkillToDisk, o as isToolAllowedByUnion, p as interpolateShellCommands, r as writeSkillsToDisk, s as matchesAllowedTool, t as defineSkill, u as validateSkillForWrite, v as parseFrontmatter, x as IMPLICITLY_ALLOWED_SKILL_TOOLS, y as parseSkillFile } from "./index-CT5_p-3P.js";
+import { A as SkillSource, D as SkillConfig, O as SkillDiagnostic, c as DeactivationReason, d as createSkillActivationState, j as SkillsConfig, k as SkillResource, l as SkillActivationState, o as ActivationVia, s as ActiveSkill, u as SkillActivationStateOptions } from "./agent-DHQAsdj6.js";
+import { S as installAllowedToolsGate, _ as inferSource, a as SkillValidationResult, b as buildCatalog, c as parseAllowedToolPattern, d as validateSkillName, f as resolveSkills, g as getDefaultScanPaths, h as discoverSkills, i as SkillValidationIssue, l as validateResourcePath, m as SourcedScanPath, n as writeSkillToDisk, o as isToolAllowedByUnion, p as interpolateShellCommands, r as writeSkillsToDisk, s as matchesAllowedTool, t as defineSkill, u as validateSkillForWrite, v as parseFrontmatter, x as IMPLICITLY_ALLOWED_SKILL_TOOLS, y as parseSkillFile } from "./index-CHSaLab5.js";
 export { ActivationVia, ActiveSkill, DeactivationReason, IMPLICITLY_ALLOWED_SKILL_TOOLS, SkillActivationState, SkillActivationStateOptions, SkillConfig, SkillDiagnostic, SkillResource, SkillSource, SkillValidationIssue, SkillValidationResult, SkillsConfig, SourcedScanPath, buildCatalog, createSkillActivationState, defineSkill, discoverSkills, getDefaultScanPaths, inferSource, installAllowedToolsGate, interpolateShellCommands, isToolAllowedByUnion, matchesAllowedTool, parseAllowedToolPattern, parseFrontmatter, parseSkillFile, resolveSkills, validateResourcePath, validateSkillForWrite, validateSkillName, writeSkillToDisk, writeSkillsToDisk };

package/dist/{tools-CCsL5SCO.js → tools-DKdyPoUf.js}

@@ -805,20 +805,13 @@ const IMAGE_OMITTED_MARKER = "[image omitted — model does not support vision]"
 const INTERRUPT_MESSAGE_FOR_TOOL_USE = "[Request interrupted by user for tool use]";
 /**
 * Canonical tool_result text emitted when a tool call is skipped because a
-* sibling sequential call errored or a steering message arrived between
-* iterations of {@link executeToolsSequential}. Distinguished from
-* {@link INTERRUPT_MESSAGE_FOR_TOOL_USE} so consumers can distinguish "user
+* steering message arrived between dispatches inside
+* {@link executeToolBatch}. Distinguished from
+* {@link INTERRUPT_MESSAGE_FOR_TOOL_USE} so consumers can split "user
 * cancelled" from "framework superseded".
 */
 const TOOL_USE_SKIPPED_MESSAGE = "[Tool use skipped — superseded by user message]";
 /**
-* Canonical tool_result text emitted when the loop catches a sequential
-* sibling that threw and synthesizes follow-up results for the remaining
-* queued calls. Distinct from {@link TOOL_USE_SKIPPED_MESSAGE} so telemetry
-* can split "skipped by user steering" from "skipped after error".
-*/
-const TOOL_USE_AFTER_ERROR_MESSAGE = "[Tool use skipped — previous tool call in batch threw]";
-/**
 * Compute the effective thinking budget for a given run-relative turn, given
 * the configured decay schedule. Pure helper — exported for tests and so
 * downstream tooling can preview decay curves without spinning up the loop.
@@ -1518,7 +1511,7 @@ async function executeTurn(ctx, turn) {
 			usage: result.usage
 		};
 	}
-	const toolResults = ctx.toolExecution === "parallel" ? await executeToolsParallel(ctx, canonicalToolCalls, turnId) : await executeToolsSequential(ctx, canonicalToolCalls, turnId);
+	const toolResults = await executeToolBatch(ctx, canonicalToolCalls, turnId);
 	const toolResultMsg = ctx.provider.toolResultsMessage(toolResults);
 	const toolResultsTurn = {
 		id: await ctx.generateTurnId(),
@@ -1859,57 +1852,170 @@ async function emitToolResult(ctx, params) {
 		isError
 	};
 }
-async function executeToolsSequential(ctx, toolCalls, turnId) {
-	const results = [];
-	for (let i = 0; i < toolCalls.length; i++) {
-		const call = toolCalls[i];
-		if (ctx.signal.aborted) {
-			for (let j = i; j < toolCalls.length; j++) results.push({
-				id: toolCalls[j].id,
-				content: INTERRUPT_MESSAGE_FOR_TOOL_USE,
-				isError: true
-			});
-			return results;
-		}
-		if (ctx.steeringQueue.length > 0) {
-			for (let j = i; j < toolCalls.length; j++) results.push({
-				id: toolCalls[j].id,
-				content: TOOL_USE_SKIPPED_MESSAGE,
-				isError: true
-			});
-			return results;
-		}
-		try {
-			const { result } = await executeSingleTool(ctx, call, turnId);
-			results.push(result);
-		} catch (err) {
-			results.push({
-				id: call.id,
-				content: `Error: ${errorMessage(err)}`,
-				isError: true
-			});
-			for (let j = i + 1; j < toolCalls.length; j++) results.push({
-				id: toolCalls[j].id,
-				content: TOOL_USE_AFTER_ERROR_MESSAGE,
-				isError: true
-			});
-			return results;
-		}
+/** Default cap on in-flight tools per turn. Mirrors Claude Code's `CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY`. */
+const DEFAULT_MAX_CONCURRENT_TOOLS = 10;
+/** Canonical name of the shell tool — referenced for cascade-cancel semantics. */
+const SHELL_TOOL_NAME = "shell";
+/** Reason surfaced on `siblingAbort.signal` when a shell error cancels its fleet. */
+const SHELL_CASCADE_REASON = "sibling-shell-error";
+/**
+* Canonical `tool_result.content` text emitted to siblings that were
+* cancelled by a `shell` error in the same batch. Distinct from
+* {@link INTERRUPT_MESSAGE_FOR_TOOL_USE} (user-issued abort) and
+* {@link TOOL_USE_SKIPPED_MESSAGE} (steered) so consumers can split
+* the three causes by string-match.
+*/
+const SHELL_CASCADE_CANCEL_MESSAGE = "Cancelled: a sibling `shell` call in the same batch errored; re-run independently if still needed.";
+/**
+* Resolve a tool's concurrency-safety verdict for a specific call.
+*
+* - Missing toolDef (unknown tool) → `false`. `executeSingleTool` handles
+*   the unknown-tool path itself; barriering it keeps the unknown-tool
+*   error from racing with siblings.
+* - Static `true` / `false` → use as-is.
+* - Function → invoke; any throw is treated as `false` (fail-closed) so a
+*   buggy predicate can't accidentally widen the safety window.
+*
+* Pure / sync — pre-computed once per call before dispatch begins, so the
+* scheduler's hot path stays branch-light.
+*/
+function resolveConcurrencySafe(def, input) {
+	if (!def) return false;
+	const flag = def.isConcurrencySafe;
+	if (flag === void 0) return false;
+	if (typeof flag === "boolean") return flag;
+	try {
+		return flag(input) === true;
+	} catch {
+		return false;
 	}
-	return results;
 }
-async function executeToolsParallel(ctx, toolCalls, turnId) {
-	const executions = toolCalls.map((call) => executeSingleTool(ctx, call, turnId));
-	return (await Promise.allSettled(executions)).map((s, i) => {
-		if (s.status === "fulfilled") return s.value.result;
-		const reason = s.reason;
-		const isAbort = ctx.signal.aborted || reason instanceof Error && reason.name === "AbortError";
-		return {
-			id: toolCalls[i].id,
-			content: isAbort ? INTERRUPT_MESSAGE_FOR_TOOL_USE : `Error: ${reason instanceof Error ? reason.message : String(reason)}`,
+/**
+* Unified per-turn tool dispatcher.
+*
+* Walks `toolCalls` in submission order. For each call:
+*
+* - **Concurrency-safe + fleet is all safe + room under the cap** → fires
+*   asynchronously and the loop advances to the next call. The fleet runs
+*   in parallel up to `behavior.maxConcurrentTools` (default {@link
+*   DEFAULT_MAX_CONCURRENT_TOOLS}).
+* - **Unsafe** (or the in-flight fleet contains anything unsafe) → acts
+*   as a barrier: waits for the fleet to drain, then runs alone, then
+*   unblocks the queue.
+*
+* Results are written into a fixed `results[index]` array on completion
+* and yielded back in submission order, so the model sees deterministic
+* adjacency regardless of which call finished first.
+*
+* **Failure modes:**
+*
+* - **Hook throws / tool body throws** — captured per-call into a
+*   `tool_result` so the assistant turn's `tool_use` IDs always have
+*   matching `tool_result` IDs (providers reject orphan IDs).
+* - **Parent abort** mid-batch — drains the in-flight fleet (their
+*   `AbortError` becomes `INTERRUPT_MESSAGE_FOR_TOOL_USE`), then synthesizes
+*   interrupt results for any unstarted calls so the turn closes cleanly.
+* - **Steering queue populated** between dispatches — same drain + a
+*   `TOOL_USE_SKIPPED_MESSAGE` result for unstarted calls. The outer loop
+*   picks up the steer at the next checkpoint.
+* - **Shell error in a fleet** — `siblingAbort.abort('sibling-shell-error')`
+*   tears down concurrently-running siblings. Mirrors the convention that
+*   shell commands often chain (`mkdir foo && cd foo`); one failing
+*   sibling commonly invalidates the rest. Non-shell errors are isolated.
+*
+* A child `AbortController` (`siblingAbort`) forwards the parent abort
+* AND carries the shell-cascade signal — siblings see one signal source.
+*/
+async function executeToolBatch(ctx, toolCalls, turnId) {
+	if (toolCalls.length === 0) return [];
+	const N = toolCalls.length;
+	const maxConcurrent = Math.max(1, ctx.maxConcurrentTools ?? DEFAULT_MAX_CONCURRENT_TOOLS);
+	const results = Array.from({ length: N });
+	const safe = Array.from({ length: N });
+	for (let i = 0; i < N; i++) safe[i] = resolveConcurrencySafe(ctx.tools[toolCalls[i].name], toolCalls[i].input);
+	const siblingAbort = new AbortController();
+	let parentAbortListener;
+	if (ctx.signal.aborted) siblingAbort.abort(ctx.signal.reason ?? "parent-aborted");
+	else {
+		parentAbortListener = () => siblingAbort.abort(ctx.signal.reason ?? "parent-aborted");
+		ctx.signal.addEventListener("abort", parentAbortListener, { once: true });
+	}
+	const childCtx = {
+		...ctx,
+		signal: siblingAbort.signal
+	};
+	/** Indices currently in flight. Tracked for fleet-safety + cap checks. */
+	const inFlight = /* @__PURE__ */ new Map();
+	/**
+	* Distinguish a shell-cascade kill from a user-issued abort so the
+	* model sees actionable text. When BOTH the parent signal and the
+	* sibling signal are aborted, the parent wins — user-issued aborts
+	* take precedence (the model is being interrupted by the human, not
+	* by a sibling's failure).
+	*/
+	const cancelMessage = () => {
+		if (ctx.signal.aborted) return INTERRUPT_MESSAGE_FOR_TOOL_USE;
+		if (siblingAbort.signal.reason === SHELL_CASCADE_REASON) return SHELL_CASCADE_CANCEL_MESSAGE;
+		return INTERRUPT_MESSAGE_FOR_TOOL_USE;
+	};
+	const dispatch = (index) => {
+		const call = toolCalls[index];
+		return executeSingleTool(childCtx, call, turnId).then(({ result }) => {
+			results[index] = result;
+			if (result.isError && call.name === SHELL_TOOL_NAME && !siblingAbort.signal.aborted) siblingAbort.abort(SHELL_CASCADE_REASON);
+		}, (err) => {
+			const isAbort = siblingAbort.signal.aborted || ctx.signal.aborted || err instanceof Error && err.name === "AbortError";
+			results[index] = {
+				id: call.id,
+				content: isAbort ? cancelMessage() : `Error: ${errorMessage(err)}`,
+				isError: true
+			};
+		}).finally(() => {
+			inFlight.delete(index);
+		});
+	};
+	const drain = async () => {
+		if (inFlight.size > 0) await Promise.all([...inFlight.values()]);
+	};
+	/** Whether every in-flight call is concurrency-safe. */
+	const fleetAllSafe = () => {
+		for (const idx of inFlight.keys()) if (!safe[idx]) return false;
+		return true;
+	};
+	/**
+	* Fill all unstarted slots (`results[j]` still undefined) with the
+	* canonical text + `isError: true`. Used at every short-circuit
+	* branch (abort / steer) so the assistant turn's `tool_use` IDs
+	* always have matching `tool_result` IDs — providers reject orphan
+	* IDs loudly.
+	*/
+	const fillUnstarted = (from, content) => {
+		for (let j = from; j < N; j++) if (!results[j]) results[j] = {
+			id: toolCalls[j].id,
+			content,
 			isError: true
 		};
-	});
+	};
+	try {
+		for (let i = 0; i < N; i++) {
+			if (!safe[i] || !fleetAllSafe() || inFlight.size >= maxConcurrent) await drain();
+			if (ctx.signal.aborted) {
+				await drain();
+				fillUnstarted(i, INTERRUPT_MESSAGE_FOR_TOOL_USE);
+				return results;
+			}
+			if (ctx.steeringQueue.length > 0) {
+				await drain();
+				fillUnstarted(i, TOOL_USE_SKIPPED_MESSAGE);
+				return results;
+			}
+			inFlight.set(i, dispatch(i));
+		}
+		await drain();
+		return results;
+	} finally {
+		if (parentAbortListener) ctx.signal.removeEventListener("abort", parentAbortListener);
+	}
 }
 //#endregion
 //#region src/prompt.ts
@@ -2129,6 +2235,7 @@ function looksBinary(text, sniffBytes = SNIFF_BYTES) {
 function createSkillsReadTool(options) {
 	const byName = new Map(options.catalog.map((s) => [s.name, s]));
 	return {
+		isConcurrencySafe: true,
 		spec: {
 			name: "skills_read",
 			description: "Read a bundled resource file from an active skill. The skill must have been activated via skills_use first. Path is relative to the skill's directory (e.g. \"references/REFERENCE.md\", \"assets/template.txt\").",
@@ -2392,6 +2499,7 @@ function createToolSearchTool(options) {
 	}
 	const maxLimit = Math.max(options.catalog.length, 1);
 	return {
+		isConcurrencySafe: true,
 		spec: {
 			name: "tool_search",
 			description: "Discover and load schemas for additional tools listed in <searchable_tools>. Tools listed there are advertised by name + description only — their input schemas are not loaded into context until you surface them through this tool. Pass `query` for a substring search, `names` to load specific tools, or `server` to load every tool from one MCP server. Returned tools become callable for the rest of this run.",
@@ -2607,7 +2715,7 @@ async function synthesizeMissingToolResults(turns, syntheticTurnId, runId, provi
 }
 function resolveBehavior(agentBehavior, runBehavior) {
 	return {
-		toolExecution: runBehavior?.toolExecution ?? agentBehavior?.toolExecution ?? "parallel",
+		maxConcurrentTools: runBehavior?.maxConcurrentTools ?? agentBehavior?.maxConcurrentTools,
 		maxTurns: runBehavior?.maxTurns ?? agentBehavior?.maxTurns,
 		maxTokens: runBehavior?.maxTokens ?? agentBehavior?.maxTokens,
 		thinkingBudget: runBehavior?.thinkingBudget ?? agentBehavior?.thinkingBudget,
@@ -2917,7 +3025,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			const thinking = options.thinking ?? "off";
 			const model = options.model ?? provider.meta.defaultModel;
 			const resolvedBehavior = resolveBehavior(agentBehavior, options.behavior);
-			const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, elideStaleReads, toolDisclosure, toolSearch, persistThreshold, persistExcludeTools, persistDir, strictToolPairing } = resolvedBehavior;
+			const { maxConcurrentTools, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, elideStaleReads, toolDisclosure, toolSearch, persistThreshold, persistExcludeTools, persistDir, strictToolPairing } = resolvedBehavior;
 			let system = options.system || agentSystem || "You are a helpful assistant.";
 			if (skillsCatalog) system = `${system}\n\n${skillsCatalog}`;
 			const runBaseTools = options.tools !== void 0 ? options.tools : mcpConnection ? {
@@ -3080,7 +3188,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					model,
 					system,
 					thinking,
-					toolExecution,
+					...maxConcurrentTools !== void 0 ? { maxConcurrentTools } : {},
 					signal: abortController.signal,
 					execution: executionContext,
 					handle: executionHandle,
@@ -3760,6 +3868,7 @@ async function globViaShell(pattern, ctx, limit) {
 	return result.stdout.split("\n").filter((line) => line.length > 0);
 }
 const glob = {
+	isConcurrencySafe: true,
 	spec: {
 		name: "glob",
 		description: "Match files by glob pattern (supports **, *, ?). Relative to the execution context cwd. By default each row is `<path>\\t<size-bytes>\\t<mtime-iso>`; set `metadata: false` for a plain newline-separated list of paths. Always sorted.",
@@ -3825,6 +3934,7 @@ const glob = {
 const DEFAULT_HEAD_LIMIT = 250;
 const DEFAULT_OUTPUT_MODE = "files_with_matches";
 const grep = {
+	isConcurrencySafe: true,
 	spec: {
 		name: "grep",
 		description: "Search file contents by regex. Returns matching paths (default), match content, or per-file counts. Backed by ripgrep when available with a Bun.Glob fallback for in-process runs.",
@@ -4060,6 +4170,7 @@ function createInteractionTool(options) {
 //#endregion
 //#region src/tools/list-files.ts
 const listFiles = {
+	isConcurrencySafe: true,
 	spec: {
 		name: "list_files",
 		description: "List files and directories at the given path (relative to project root).",
@@ -4244,6 +4355,7 @@ const DEFAULT_BYTE_CAP = 262144;
 */
 const DEFAULT_IMAGE_BYTE_CAP = 5 * 1024 * 1024;
 const readFile$1 = {
+	isConcurrencySafe: true,
 	spec: {
 		name: "read_file",
 		description: "Read a file by path. Returns lines [offset..offset+limit). Default offset=1, limit=2000. Each line is prefixed with its 1-indexed line number followed by a tab (e.g. `42\\tconst foo = bar`); the prefix is metadata, not part of the file. Mirrors Claude Code's `cat -n`-style compact output for token efficiency. A trailing footer explains how to read the rest when truncated. Binary files return a short marker rather than mojibake.",
@@ -4438,7 +4550,110 @@ function extractTrailingCommand(command) {
 * context's own default (30 s for in-process).
 */
 const DEFAULT_MAX_OUTPUT_BYTES = 32768;
+/**
+* Best-effort read-only allow-list for the leading command token. Members
+* are commands whose stock behavior cannot mutate the workspace under any
+* argument combination — `ls`, `cat`, `pwd`, etc. Commands that *can*
+* mutate depending on flags (`find -delete`, `git tag <name>`, `tar -x`)
+* are intentionally excluded; the input-aware {@link isReadOnlyShellCommand}
+* predicate falls back to the conservative "not safe" answer for them, so
+* the scheduler barriers them.
+*/
+const SHELL_READ_ONLY_COMMANDS = new Set([
+	"ls",
+	"cat",
+	"head",
+	"tail",
+	"wc",
+	"pwd",
+	"whoami",
+	"id",
+	"date",
+	"uname",
+	"hostname",
+	"tty",
+	"echo",
+	"printf",
+	"env",
+	"printenv",
+	"which",
+	"type",
+	"command",
+	"file",
+	"stat",
+	"grep",
+	"rg",
+	"ag",
+	"true",
+	"false",
+	"test"
+]);
+/**
+* `git` subcommands that are pure reads regardless of arguments. Excludes
+* `branch`/`tag`/`remote` (which can mutate when given a name) and
+* `config` (which writes when given a value).
+*/
+const GIT_READ_ONLY_SUBCOMMANDS = new Set([
+	"status",
+	"log",
+	"diff",
+	"show",
+	"blame",
+	"rev-parse",
+	"ls-files",
+	"ls-tree",
+	"cat-file",
+	"reflog",
+	"shortlog",
+	"describe",
+	"rev-list",
+	"name-rev",
+	"whatchanged",
+	"merge-base",
+	"symbolic-ref"
+]);
+/**
+* Conservative read-only verdict for a shell command — used to opt a
+* `shell` invocation into the scheduler's concurrent fleet. Returns
+* `false` (fail-closed) on anything ambiguous so the scheduler barriers
+* it. Specifically:
+*
+* - Rejects compound commands (`;`, `&&`, `||`, `|`) and redirects (`>`,
+*   `>>`, `<`) — even a pipe to a read-only sink is treated as too
+*   complex to analyze.
+* - Rejects subshell / process substitution (`$(...)`, `` `...` ``,
+*   `<(...)`, `>(...)`).
+* - Skips leading `VAR=value` env assignments to find the real
+*   command token.
+* - Strips a possible absolute path on the command (`/usr/bin/ls` → `ls`).
+* - Allows the command iff its base name is in
+*   {@link SHELL_READ_ONLY_COMMANDS} OR it's `git <subcmd>` where
+*   `<subcmd>` is in {@link GIT_READ_ONLY_SUBCOMMANDS}.
+*
+* Cheap (no spawned process; regex + token scan). Safe to call from the
+* hot scheduler path.
+*/
+function isReadOnlyShellCommand(command) {
+	if (typeof command !== "string") return false;
+	const trimmed = command.trim();
+	if (trimmed === "") return false;
+	if (/[<>;&|`\n]/.test(trimmed)) return false;
+	if (trimmed.includes("$(") || trimmed.includes("<(") || trimmed.includes(">(")) return false;
+	const tokens = trimmed.split(/\s+/);
+	let i = 0;
+	while (i < tokens.length && /^[A-Z_]\w*=/i.test(tokens[i])) i++;
+	const head = tokens[i];
+	if (!head) return false;
+	const base = head.split("/").pop() ?? head;
+	if (SHELL_READ_ONLY_COMMANDS.has(base)) return true;
+	if (base === "git") {
+		const sub = tokens[i + 1];
+		return typeof sub === "string" && GIT_READ_ONLY_SUBCOMMANDS.has(sub);
+	}
+	return false;
+}
 const shell = {
+	isConcurrencySafe: (input) => isReadOnlyShellCommand(input.command),
 	spec: {
 		name: "shell",
 		description: "Execute a shell command in the project root and return its combined stdout/stderr. Output is tail-priority truncated at 32 KiB by default; errors and exit-code summaries live in the tail. By default each call appends a `(exit N, Nms)` footer and surfaces non-empty stderr in a separate section even on success — set `metadata: false` to return only stdout. Set maxOutputBytes=0 to disable truncation.",
@@ -4715,6 +4930,7 @@ function createSpawnTool(options = {}) {
 		get totalChildStats() {
 			return { ...localStats };
 		},
+		isConcurrencySafe: true,
 		spec: {
 			name: "spawn",
 			description: "Spawn a sub-agent for a self-contained task that benefits from isolation (separate context window, separate retries) — for example, a deep research dive or a long codegen pass on a specific file. The sub-agent runs independently with its own tool access and returns its final response. Do NOT spawn for sequential steps you could do yourself.",
@@ -4947,6 +5163,6 @@ const writeFile$1 = {
 	}
 };
 //#endregion
-export { readStateKey as A, PERSISTENCE_PREVIEW_BYTES as C, resolvePersistDir as D, maybePersistToolResult as E, getReadState as O, PERSISTED_STUB_PREFIX as S, cleanupPersistedSession as T, createSkillsReadTool as _, multiEdit as a, TOOL_USE_SKIPPED_MESSAGE as b, grep as c, resolveOldString as d, styleReplacementForVia as f, createSkillsRunScriptTool as g, createSkillsUseTool as h, readFile$1 as i, resolveReadStateMap as j, hashContent as k, glob as l, createToolSearchTool as m, createSpawnTool as n, listFiles as o, createAgent as p, shell as r, createInteractionTool as s, writeFile$1 as t, edit as u, INTERRUPT_MESSAGE_FOR_TOOL_USE as v, buildPersistedStub as w, validateToolArgs as x, TOOL_USE_AFTER_ERROR_MESSAGE as y };
+export { readStateKey as A, PERSISTENCE_PREVIEW_BYTES as C, resolvePersistDir as D, maybePersistToolResult as E, getReadState as O, PERSISTED_STUB_PREFIX as S, cleanupPersistedSession as T, createSkillsReadTool as _, multiEdit as a, TOOL_USE_SKIPPED_MESSAGE as b, grep as c, resolveOldString as d, styleReplacementForVia as f, createSkillsRunScriptTool as g, createSkillsUseTool as h, readFile$1 as i, resolveReadStateMap as j, hashContent as k, glob as l, createToolSearchTool as m, createSpawnTool as n, listFiles as o, createAgent as p, shell as r, createInteractionTool as s, writeFile$1 as t, edit as u, INTERRUPT_MESSAGE_FOR_TOOL_USE as v, buildPersistedStub as w, validateToolArgs as x, SHELL_CASCADE_CANCEL_MESSAGE as y };
 
-//# sourceMappingURL=tools-CCsL5SCO.js.map
+//# sourceMappingURL=tools-DKdyPoUf.js.map