zidane 7.1.4 → 7.1.7

package/dist/acp-cli.js

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 import { m as openaiCompat } from "./openai-compat-Dy56weK8.js";
-import { Ct as basic_default } from "./agent-BlGt76qk.js";
+import { Ct as basic_default } from "./agent-CJbmpTmA.js";
 import { r as createProcessContext } from "./contexts-CRE9pw07.js";
 import { createSandboxContext } from "./contexts/sandbox.js";
 import { p as resolveStorageDirs } from "./plugins-gbI7SBA6.js";
-import { r as anthropic } from "./anthropic-DPPs3wjJ.js";
+import { r as anthropic } from "./anthropic-BQdAnY-w.js";
 import { arcee } from "./providers/arcee.js";
 import { baseten } from "./providers/baseten.js";
 import { cerebras } from "./providers/cerebras.js";
 import { openai } from "./providers/openai.js";
 import { openrouter } from "./providers/openrouter.js";
 import { xai } from "./providers/xai.js";
-import { d as StartUsageError, f as buildStartLocalOptions, h as startProviderNames, i as withAcpDefaultTools, m as startLocalArgOptions, p as parseStartArgValues, t as runAcpStdioServer } from "./acp-DbYGzaVK.js";
-import { T as modelsForDescriptor, h as BUILTIN_PROVIDERS, i as readCredentials, r as credentialsPath, t as detectAuth, v as credKeyOf } from "./auth-CNetxyJH.js";
+import { d as StartUsageError, f as buildStartLocalOptions, h as startProviderNames, i as withAcpDefaultTools, m as startLocalArgOptions, p as parseStartArgValues, t as runAcpStdioServer } from "./acp-BxRfclPQ.js";
+import { T as modelsForDescriptor, h as BUILTIN_PROVIDERS, i as readCredentials, r as credentialsPath, t as detectAuth, v as credKeyOf } from "./auth-DvMdkpGD.js";
 import { createDaytonaProvider } from "./contexts/daytona.js";
 import { createDockerContext } from "./contexts/docker.js";
 import { createE2BProvider } from "./contexts/e2b.js";

package/dist/acp.d.ts

@@ -1,4 +1,4 @@
-import { C_ as TurnUsage, Hg as PromptPart, O_ as ToolDef, Xi as AgentOptions, Zg as SessionContentBlock, jg as McpServerConfig, m_ as ToolResultContent, mg as AgentBehavior, nv as Session, ov as SessionStore, qi as Agent, t as Preset, ym as Provider } from "./index-BIJKozYj.js";
+import { C_ as TurnUsage, Hg as PromptPart, O_ as ToolDef, Xi as AgentOptions, Zg as SessionContentBlock, av as Session, jg as McpServerConfig, lv as SessionStore, m_ as ToolResultContent, mg as AgentBehavior, qi as Agent, t as Preset, ym as Provider } from "./index-DCYh6lOp.js";
 import { m as ExecutionContext } from "./isolation-Kfoof0MM.js";
 import { Readable, Writable } from "node:stream";
 

package/dist/acp.js

@@ -1,3 +1,3 @@
 import { n as JsonRpcRemoteError, r as createJsonRpcConnection } from "./json-rpc-rSWMUh9b.js";
-import { a as wrapToolsForAcpClient, c as sessionBlocksToAcp, i as withAcpDefaultTools, l as stopReasonFromRun, n as AcpProtocolError, o as acpMcpServersToZidane, r as createAcpServer, s as acpPromptToPromptParts, t as runAcpStdioServer, u as toolResultToAcpContent } from "./acp-DbYGzaVK.js";
+import { a as wrapToolsForAcpClient, c as sessionBlocksToAcp, i as withAcpDefaultTools, l as stopReasonFromRun, n as AcpProtocolError, o as acpMcpServersToZidane, r as createAcpServer, s as acpPromptToPromptParts, t as runAcpStdioServer, u as toolResultToAcpContent } from "./acp-BxRfclPQ.js";
 export { AcpProtocolError, JsonRpcRemoteError, acpMcpServersToZidane, acpPromptToPromptParts, createAcpServer, createJsonRpcConnection, runAcpStdioServer, sessionBlocksToAcp, stopReasonFromRun, toolResultToAcpContent, withAcpDefaultTools, wrapToolsForAcpClient };

package/dist/{agent-BlGt76qk.js → agent-CJbmpTmA.js}

@@ -14,6 +14,7 @@ import { n as writeFileAtomicAsync, t as writeFileAtomic } from "./atomic-write-
 import { p as resolveStorageDirs, r as loadAgentPlugin } from "./plugins-gbI7SBA6.js";
 import { r as createLogger, t as consoleSink } from "./logger--C1VQjwJ.js";
 import { t as escapeXml } from "./xml-D5HBhJle.js";
+import { toolPrompts } from "./tools/prompts.js";
 import { n as reconcileImageMediaType } from "./media-sniff-UKijEaiQ.js";
 import { f as wrapDiscoveredMcpTools, i as deriveMcpToolMeta, n as connectMcpServers, s as nonOwningMcpView } from "./mcp-CgNd-f3F.js";
 import { appendStaticSection, renderSystemForWire } from "./prompt.js";
@@ -3505,13 +3506,7 @@ const recordArtifact = {
 	isConcurrencySafe: true,
 	spec: {
 		name: RECORD_ARTIFACT_TOOL,
-		description: [
-			"Record a deliverable this session produced so the user can find it later in the artifacts panel. An artifact is an OUTPUT the user would want a link to — not a step of the work.",
-			"Worth recording: a pull request or merge request URL, a deployment / preview URL, an issue or ticket you filed, a release or tag, a generated report / export / dataset the user asked for, a build output they will pick up.",
-			"Not worth recording: source files you edited or created as part of implementing a change, scratch files, logs, intermediate results, anything already implied by the diff.",
-			"Pull requests from `gh pr create`, `git commit` commits and newly created branches are detected automatically — record those only when the automatic path could not see them (e.g. a PR opened from a background shell task).",
-			"Idempotent per (kind, uri): recording the same artifact again refreshes its label/meta."
-		].join("\n"),
+		description: toolPrompts.record_artifact,
 		inputSchema: {
 			type: "object",
 			properties: {
@@ -3988,7 +3983,7 @@ async function wholeReadRefusal(execution, handle, path, what) {
 const edit = {
 	spec: {
 		name: "edit",
-		description: "Replace exact `old_string` with `new_string` in a file. Fails if `old_string` is not unique unless `replace_all: true`. Prefer over `write_file` for surgical changes: preserves the rest of the file. Tolerates `read_file` line-number prefixes (`<N>\\t…`, `<N>|…`, or `<N>→…`) in `old_string` / `new_string`; they are stripped before matching/writing, so you can paste a numbered chunk verbatim.",
+		description: toolPrompts.edit,
 		inputSchema: {
 			type: "object",
 			properties: {
@@ -4190,7 +4185,7 @@ const glob = {
 	isConcurrencySafe: true,
 	spec: {
 		name: "glob",
-		description: "Match files by glob pattern (supports **, *, ?). Relative to the execution context cwd; patterns may reach outside the workspace (e.g. \"../shared/**/*.ts\"). 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.",
+		description: toolPrompts.glob,
 		inputSchema: {
 			type: "object",
 			properties: {
@@ -4311,7 +4306,7 @@ 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 portable shell-listing + regex fallback when `rg` is absent.",
+		description: toolPrompts.grep,
 		inputSchema: {
 			type: "object",
 			properties: {
@@ -4612,7 +4607,7 @@ function createInteractionTool(options) {
 	return {
 		spec: {
 			name: options.name ?? "interaction",
-			description: options.description ?? "Request structured input from the user or external system.",
+			description: options.description ?? toolPrompts.interaction,
 			inputSchema: options.schema
 		},
 		async execute(input, ctx) {
@@ -4646,7 +4641,7 @@ const listFiles = {
 	isConcurrencySafe: true,
 	spec: {
 		name: "list_files",
-		description: "List the immediate entries (files and subdirectories) at literal directory `path`. Returns a newline-separated list; subdirectories carry a trailing `/`; or `(empty directory)` when the directory exists but is empty. Non-recursive: use `glob` for pattern matching across nested directories.",
+		description: toolPrompts.list_files,
 		inputSchema: {
 			type: "object",
 			properties: { path: {
@@ -4714,11 +4709,7 @@ function createModelSearchTool(models) {
 	return {
 		spec: {
 			name: "model_search",
-			description: [
-				"List the models available for spawned subagents, with per-Mtok pricing and context windows.",
-				"Use it to cost-tier delegation: find a cheap, fast model for mechanical or high-volume work before calling `spawn` with its id in the `model` field.",
-				"Pass `query` to filter by substring across model id, name, and provider; omit it to list everything."
-			].join("\n"),
+			description: toolPrompts.model_search,
 			inputSchema: {
 				type: "object",
 				properties: { query: {
@@ -4764,7 +4755,7 @@ function annotationFor(outcomes) {
 const multiEdit = {
 	spec: {
 		name: "multi_edit",
-		description: "Apply a sequential list of edits to a file. Each edit operates on the result of the previous APPLIED edit. Prefer this over multiple `edit` calls when several non-overlapping changes are needed in the same file. Edits run best-effort: a per-step failure (`old_string` not found, ambiguous match without `replace_all`, identical strings) is reported in the result but does NOT block the remaining steps. The file is written iff at least one step applied. The result lists per-hunk outcomes (`applied` / `failed`) so the model can re-issue just the failures without resending the whole batch. Each step tolerates `read_file` line-number prefixes (`<N>\\t…`, `<N>|…`, or `<N>→…`) in `old_string` / `new_string`.",
+		description: toolPrompts.multi_edit,
 		inputSchema: {
 			type: "object",
 			properties: {
@@ -5235,7 +5226,7 @@ const readFile$1 = {
 	isConcurrencySafe: true,
 	spec: {
 		name: "read_file",
-		description: "Read a file by path. Text files return 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. Images (png/jpg/gif/webp) and PDFs return structured attachments for capable models; other binary files return a short marker rather than mojibake.",
+		description: toolPrompts.read_file,
 		inputSchema: {
 			type: "object",
 			properties: {
@@ -5639,74 +5630,31 @@ function isReadOnlyShellCommand(command) {
 	return false;
 }
 /**
-* Canonical sibling tools that, when registered alongside `shell`, are worth
-* nudging the model toward — re-running `ls`/`cat` to "verify" a path the
-* model already inspected through a dedicated tool is a measurable Kimi/Sonnet
-* failure mode. Each entry maps the canonical tool name to the line rendered
-* in the description; the rendered tool name itself is alias-resolved at
-* render time so deployments that wire-rename (e.g. `read_file` → `Read`)
-* still point at a name the model recognizes from the tool spec.
-*/
-const SHELL_SWAP_HINTS = [
-	{
-		canonical: "read_file",
-		label: "Read files",
-		instead: "cat/head/tail"
-	},
-	{
-		canonical: "glob",
-		label: "File search",
-		instead: "find/ls"
-	},
-	{
-		canonical: "grep",
-		label: "Content search",
-		instead: "grep/rg"
-	},
-	{
-		canonical: "list_files",
-		label: "Directory listings",
-		instead: "ls"
-	},
-	{
-		canonical: "edit",
-		label: "Edit files",
-		instead: "sed/awk"
-	},
-	{
-		canonical: "write_file",
-		label: "Write files",
-		instead: "echo>/heredoc"
-	}
-];
-/**
-* Build the `shell` tool's description text.
+* Build the `shell` tool's description text from `toolPrompts.shell`.
 *
 * - The background-mode paragraphs are appended only when `allowBackground`
 *   is true so the model isn't pointed at a feature the agent has disabled.
 * - The "prefer the dedicated tool" swap block is appended only for siblings
-*   actually present in `registeredCanonicals`. Hosts that ship `shell`
-*   without `read_file`/`glob`/etc. don't see misleading nudges. Aliased
-*   names are rendered via `toolAliases` so the printed name matches what
-*   the model sees in the tool spec.
+*   actually present in `registeredCanonicals` — re-running `ls`/`cat` to
+*   "verify" a path the model already inspected through a dedicated tool is
+*   a measurable Kimi/Sonnet failure mode. Hosts that ship `shell` without
+*   `read_file`/`glob`/etc. don't see misleading nudges. Aliased names are
+*   rendered via `toolAliases` so the printed name matches what the model
+*   sees in the tool spec.
 */
 function buildShellDescription({ allowBackground, registeredCanonicals, toolAliases }) {
-	const lines = [
-		"Execute a shell command from the workspace root (the `Cwd` in your environment) and return its combined stdout/stderr. Every call starts there; `cd` never persists between calls. Use relative paths (`cd src/app && bun test`, `ls docs`), not absolute ones.",
-		"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.",
-		"Pass a short `description` (5-10 words) explaining the intent of the command; it surfaces in the user-facing transcript so the human can follow your reasoning at a glance. Skip it only for trivial reads where the command speaks for itself."
-	];
+	const prompt = toolPrompts.shell;
+	const lines = [prompt.core];
 	if (registeredCanonicals && registeredCanonicals.size > 0) {
 		const swaps = [];
-		for (const { canonical, label, instead } of SHELL_SWAP_HINTS) {
+		for (const { canonical, label, instead } of prompt.swapHints) {
 			if (!registeredCanonicals.has(canonical)) continue;
 			const wireName = toolAliases?.[canonical] ?? canonical;
 			swaps.push(`- ${label}: use \`${wireName}\` (not ${instead})`);
 		}
-		if (swaps.length > 0) lines.push("", "When a dedicated tool fits, prefer it over shell:", ...swaps, "", "Re-running `ls`/`cat` on the same path is not useful: the prior result is still current unless you wrote to that path since.");
+		if (swaps.length > 0) lines.push("", prompt.preferDedicated, ...swaps, "", prompt.reminder);
 	}
-	if (allowBackground) lines.push("", "Long-running commands (`npm run dev`, `python train.py`, anything that would otherwise block your turn for minutes) → `run_in_background: true`. The call returns immediately with `{ task_id, output_path, pid }`; stdout + stderr stream to the log file at `output_path`.", "", "After spawning a background task: end your current turn (do NOT keep iterating). A `<task-notification>` arrives on the agent's NEXT user-turn with the final status. Polling the log file in a loop wastes tokens and blocks your turn: the notification IS the wake-up. If you NEED to check progress immediately (rare), call `read_file({ path: output_path, ... })` exactly once and decide. To terminate, use `shell_kill({ task_id })`. If, and only if, your very next step depends on the task's outcome, block on it with `wait_task({ task_id })` instead of polling.", "", "When called from inside a `spawn`'d subagent: you have NO next user-turn; your `agent.run` ends as soon as you finish responding. Start the background task, return a brief summary including the `task_id`, and end your turn. Ownership of the task is transferred to the parent agent when your run finishes; the parent will see the notification on ITS next user-turn.");
+	if (allowBackground) lines.push("", prompt.background);
 	return lines.join("\n");
 }
 /**
@@ -5933,12 +5881,7 @@ const shellKill = {
 	isConcurrencySafe: true,
 	spec: {
 		name: "shell_kill",
-		description: [
-			"Terminate a running background task started by `shell({ run_in_background: true })`.",
-			"Sends SIGTERM to the whole process group so the shell wrapper AND its child commands die together.",
-			"Returns the final exit info (status, exit code, output path) or a \"no such task\" message when the id is unknown / already cleaned up.",
-			"Idempotent: calling on a task that has already terminated returns the cached exit info without re-killing."
-		].join("\n"),
+		description: toolPrompts.shell_kill,
 		inputSchema: {
 			type: "object",
 			properties: { task_id: {
@@ -5969,7 +5912,7 @@ function createSkillsReadTool(options) {
 		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\").",
+			description: toolPrompts.skills_read,
 			inputSchema: {
 				type: "object",
 				properties: {
@@ -6021,7 +5964,7 @@ function createSkillsRunScriptTool(options) {
 	return {
 		spec: {
 			name: "skills_run_script",
-			description: "Execute a script bundled with an active skill (from its scripts/ directory). The skill must have been activated via skills_use first. Returns stdout, stderr, and the exit code. Honors the script's shebang.",
+			description: toolPrompts.skills_run_script,
 			inputSchema: {
 				type: "object",
 				properties: {
@@ -6114,7 +6057,7 @@ function createSkillsUseTool(options) {
 	return {
 		spec: {
 			name: "skills_use",
-			description: "Activate or deactivate a specialized skill. Call with `mode: \"activate\"` (default) to load a skill's full instructions when a task matches its catalog description. Call with `mode: \"deactivate\"` to release a skill whose allowed-tools restrictions are now in the way, e.g. when the skill's work is done or the active skill is blocking unrelated tool calls. After activating, follow the returned instructions; use skills_read to load referenced files and skills_run_script to execute bundled scripts.",
+			description: toolPrompts.skills_use,
 			inputSchema: {
 				type: "object",
 				properties: {
@@ -6630,7 +6573,7 @@ function buildSpawnTool(options, state) {
 		runsNestedAgent: 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 inherits your tool set (including \`spawn\` itself, depth-capped) and your system prompt unless overridden, runs independently, and returns its final response. Do NOT spawn for sequential steps you could do yourself.${modelCatalog ? " Children can run on a DIFFERENT model via the `model` field: cost-tier your delegation: mechanical, parallelizable, or high-volume search work belongs on cheaper/faster models, while synthesis and judgment stay on your own model." : ""}${options.persist ? " A stopped or failed sub-agent can be CONTINUED instead of restarted: pass `resume` with its child label (e.g. \"child-2\") and put the continuation instruction in `task`; the child picks up with its prior conversation intact." : ""}`,
+			description: toolPrompts.spawn.core + (modelCatalog ? toolPrompts.spawn.modelTiering : "") + (options.persist ? toolPrompts.spawn.resume : ""),
 			inputSchema: {
 				type: "object",
 				properties: {
@@ -6764,6 +6707,7 @@ function buildSpawnTool(options, state) {
 					...ctx.system !== void 0 ? { system: ctx.system } : {},
 					tools: filteredTools,
 					...ctx.toolAliases !== void 0 ? { toolAliases: ctx.toolAliases } : {},
+					...ctx.toolDescriptions !== void 0 ? { toolDescriptions: ctx.toolDescriptions } : {},
 					...inheritedMcp.mcpServers !== void 0 ? { mcpServers: inheritedMcp.mcpServers } : {},
 					...ctx.skills !== void 0 ? { skills: ctx.skills } : {},
 					...ctx.behavior !== void 0 ? { behavior: ctx.behavior } : {}
@@ -7105,14 +7049,7 @@ function createToolSearchTool(options) {
 		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.",
-				dispatcher ? `Returned tools become callable through \`${dispatcher}\` (name + arguments) for the rest of this run.` : "Returned tools become callable for the rest of this run."
-			].join(" "),
+			description: [toolPrompts.tool_search.core, dispatcher ? toolPrompts.tool_search.callableVia(dispatcher) : toolPrompts.tool_search.callable].join(" "),
 			inputSchema: {
 				type: "object",
 				properties: {
@@ -7176,11 +7113,7 @@ const MAX_TIMEOUT_MS = 30 * 6e4;
 const waitTask = {
 	spec: {
 		name: "wait_task",
-		description: [
-			"Wait for a background task started by `shell({ run_in_background: true })` to exit, then return its final status.",
-			"Returns immediately when the task has already terminated. On timeout the task keeps running and you can wait again, keep working, or `shell_kill` it.",
-			"Prefer ending your turn and receiving the `<task-notification>` when you have other useful work or nothing depends on the result; use wait_task only when the next step genuinely needs the task's outcome."
-		].join("\n"),
+		description: toolPrompts.wait_task,
 		inputSchema: {
 			type: "object",
 			properties: {
@@ -7237,7 +7170,7 @@ const waitTask = {
 const writeFile$1 = {
 	spec: {
 		name: "write_file",
-		description: "Write `content` to `path`, creating any missing parent directories. Overwrites existing files in full; prefer `edit` / `multi_edit` for surgical changes when you only want to alter part of a file. Returns one of: `Created <path> (N bytes)` (file did not exist), `Updated <path> (N bytes)` (content differed), or `No change needed: <path> already at target state (N bytes)`, so the model can detect no-ops without a separate `read_file`.",
+		description: toolPrompts.write_file,
 		inputSchema: {
 			type: "object",
 			properties: {
@@ -7329,7 +7262,7 @@ function definePreset(config) {
 * stacking presets does the obvious thing without the spread-collision footgun:
 *
 * - `name`, `system`, `eager`, `skills`              → last-defined wins
-* - `tools`, `toolAliases`, `behavior`               → shallow-merge (later keys override)
+* - `tools`, `toolAliases`, `toolDescriptions`, `behavior` → shallow-merge (later keys override)
 * - `behavior.dedupTools`, `behavior.toolBudgets`    → **deep-merge** (per-tool-name; later wins on collision)
 * - `mcpServers`                                     → concat with last-wins on `name` collision
 * - `hooks`                                          → per-event concat; every handler fires
@@ -7366,6 +7299,10 @@ function composePresets(...presets) {
 			...out.toolAliases,
 			...p.toolAliases
 		};
+		if (p.toolDescriptions) out.toolDescriptions = {
+			...out.toolDescriptions,
+			...p.toolDescriptions
+		};
 		if (p.behavior) {
 			const merged = {
 				...out.behavior,
@@ -11706,7 +11643,7 @@ function createCallToolTool(options = {}) {
 		isConcurrencySafe: false,
 		spec: {
 			name: CALL_TOOL_NAME,
-			description: `Invoke a tool listed in <searchable_tools>. Load its schema with \`${discovery}\` first (the result shows the exact \`name\` and input schema), then call it here with \`name\` set to that tool name and \`arguments\` set to an object matching its schema. Arguments are validated against the tool's own schema; a validation error names the offending field.`,
+			description: toolPrompts.call_tool(discovery),
 			inputSchema: {
 				type: "object",
 				properties: {
@@ -14623,6 +14560,7 @@ async function runSingleToolDispatch(ctx, call, turnId, fixed) {
 			...ctx.inheritance.name !== void 0 ? { name: ctx.inheritance.name } : {},
 			...ctx.inheritance.system !== void 0 ? { system: ctx.inheritance.system } : {},
 			...ctx.inheritance.toolAliases !== void 0 ? { toolAliases: ctx.inheritance.toolAliases } : {},
+			...ctx.inheritance.toolDescriptions !== void 0 ? { toolDescriptions: ctx.inheritance.toolDescriptions } : {},
 			...ctx.inheritance.mcpServers !== void 0 ? { mcpServers: ctx.inheritance.mcpServers } : {},
 			...mcpConnectionFor(ctx),
 			...ctx.inheritance.skills !== void 0 ? { skills: ctx.inheritance.skills } : {},
@@ -15306,6 +15244,7 @@ async function startDurableToolExecution(ctx, call, turnId, index) {
 		...ctx.inheritance.name !== void 0 ? { name: ctx.inheritance.name } : {},
 		...ctx.inheritance.system !== void 0 ? { system: ctx.inheritance.system } : {},
 		...ctx.inheritance.toolAliases !== void 0 ? { toolAliases: ctx.inheritance.toolAliases } : {},
+		...ctx.inheritance.toolDescriptions !== void 0 ? { toolDescriptions: ctx.inheritance.toolDescriptions } : {},
 		...ctx.inheritance.mcpServers !== void 0 ? { mcpServers: ctx.inheritance.mcpServers } : {},
 		...mcpConnectionFor(ctx),
 		...ctx.inheritance.skills !== void 0 ? { skills: ctx.inheritance.skills } : {},
@@ -16373,6 +16312,44 @@ function applyToolCatalogTransforms(tools, transforms, phase, mcpToolNames) {
 	for (const tool of Object.values(next)) if (tool?.spec?.name) out[tool.spec.name] = tool;
 	return out;
 }
+/**
+* Apply `AgentOptions.toolDescriptions` to a spec-name-indexed registry.
+* Returns a new record; matched tools are shallow-copied with a rewritten
+* `spec.description` so the host's original `ToolDef` (and the framework's
+* `builtinShell` identity) is never mutated. Unmatched keys are ignored.
+*
+* Callers run this LAST in their pipeline — after catalog transforms and the
+* built-in `shell` rewrite — so a function-form override sees the text the
+* model would otherwise have received.
+*/
+function applyToolDescriptionOverrides(tools, overrides, mcpToolNames, mcpServers) {
+	if (!overrides || Object.keys(overrides).length === 0) return tools;
+	const out = { ...tools };
+	for (const [name, override] of Object.entries(overrides)) {
+		const tool = out[name];
+		if (!tool) continue;
+		const current = tool.spec.description || "";
+		let description;
+		if (typeof override === "string") description = override;
+		else if (typeof override === "function") {
+			const mcpServer = mcpToolNames.has(name) ? resolveMcpToolParts(name, mcpServers)?.server : void 0;
+			description = override(current, {
+				name,
+				spec: tool.spec,
+				...mcpServer ? { mcpServer } : {}
+			});
+		} else continue;
+		if (typeof description !== "string" || description === current) continue;
+		out[name] = {
+			...tool,
+			spec: {
+				...tool.spec,
+				description
+			}
+		};
+	}
+	return out;
+}
 async function applySkillPolicies(input) {
 	if (!input.policies?.length || input.skills.length === 0) return;
 	const byName = new Map(input.skills.map((skill) => [skill.name, skill]));
@@ -16525,7 +16502,7 @@ function resolveToolSearchMode(toolSearch, providerName) {
 * dispatch-map lookup.
 */
 function buildRunDisclosureState(input) {
-	const { tools: baseTools, mcpToolNames, mcpServers, toolDisclosure, toolSearch, toolAliases, hasRunToolOverride, providerName } = input;
+	const { tools: baseTools, mcpToolNames, mcpServers, toolDisclosure, toolSearch, toolAliases, toolDescriptions, hasRunToolOverride, providerName } = input;
 	const toolSearchMode = resolveToolSearchMode(toolSearch, providerName);
 	const disclosure = partitionToolDisclosure(baseTools, mcpToolNames, mcpServers, toolDisclosure, toolAliases);
 	const unlocked = new Set(disclosure.eagerCanonicalNames);
@@ -16570,6 +16547,12 @@ function buildRunDisclosureState(input) {
 			unlocked.add(CALL_TOOL_NAME);
 			initialUnlocked.add(CALL_TOOL_NAME);
 		}
+		const injected = {};
+		for (const name of Object.keys(tools)) if (!baseTools[name]) injected[name] = tools[name];
+		tools = {
+			...tools,
+			...applyToolDescriptionOverrides(injected, toolDescriptions, mcpToolNames, mcpServers)
+		};
 	}
 	return {
 		disclosure,
@@ -16726,7 +16709,7 @@ async function drainTaskNotifications(input) {
 * run's capabilities.
 */
 function buildRunToolRegistry(input) {
-	const { runOverrideTools, sourceTools, mcpConnection, mcpServers, mcpToolNameSeparator, toolAliases, resolvedSkills, skillsConfig, skillActivationState, hooks, toolCatalogTransforms, executionContext, behavior } = input;
+	const { runOverrideTools, sourceTools, mcpConnection, mcpServers, mcpToolNameSeparator, toolAliases, resolvedSkills, skillsConfig, skillActivationState, hooks, toolCatalogTransforms, toolDescriptions, executionContext, behavior } = input;
 	const runBaseTools = runOverrideTools !== void 0 ? runOverrideTools : mcpConnection ? {
 		...sourceTools,
 		...mcpConnection.tools
@@ -16773,7 +16756,7 @@ function buildRunToolRegistry(input) {
 		});
 	}
 	return {
-		tools,
+		tools: applyToolDescriptionOverrides(tools, toolDescriptions, mcpToolNames, mcpServers),
 		mcpToolNames,
 		toolAliases: effectiveToolAliases
 	};
@@ -17140,6 +17123,7 @@ function foldExtensionRegistry(options) {
 	const composed = composeExtensionPreset(reg, {
 		...options.tools !== void 0 ? { tools: options.tools } : {},
 		...options.toolAliases !== void 0 ? { toolAliases: options.toolAliases } : {},
+		...options.toolDescriptions !== void 0 ? { toolDescriptions: options.toolDescriptions } : {},
 		...options.behavior !== void 0 ? { behavior: options.behavior } : {},
 		...options.mcpServers !== void 0 ? { mcpServers: options.mcpServers } : {},
 		...options.skills !== void 0 ? { skills: options.skills } : {},
@@ -17161,6 +17145,7 @@ function foldExtensionRegistry(options) {
 		...options,
 		...composed.tools !== void 0 ? { tools: composed.tools } : {},
 		...composed.toolAliases !== void 0 ? { toolAliases: composed.toolAliases } : {},
+		...composed.toolDescriptions !== void 0 ? { toolDescriptions: composed.toolDescriptions } : {},
 		...composed.behavior !== void 0 ? { behavior: composed.behavior } : {},
 		...composed.mcpServers !== void 0 ? { mcpServers: composed.mcpServers } : {},
 		...composed.skills !== void 0 ? { skills: composed.skills } : {},
@@ -17201,7 +17186,7 @@ function warnContextContributorFailureOnce(contributor, err) {
 	process.stderr.write(`[zidane/agent] context breakdown contributor failed${owner}: ${errorMessage(err)}\n`);
 }
 function createAgent(rawOptions) {
-	const { provider: providerOption, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, handle: injectedHandle, mcpServers, session, readState: agentReadState, toolState: toolStateStore, skills: agentSkills, mcpConnector, mcpToolWrap, eager, hooks: initialHooks, clock: agentClock, toolKill, contextBreakdownSections, runTransforms, behaviorTransforms, toolCatalogTransforms, mcpConfigTransforms, skillPolicies, toolResultMetadata, artifacts: artifactsOption } = foldExtensionRegistry(rawOptions);
+	const { provider: providerOption, name: agentName, system: agentSystem, tools: agentTools, toolAliases, toolDescriptions, behavior: agentBehavior, execution, handle: injectedHandle, mcpServers, session, readState: agentReadState, toolState: toolStateStore, skills: agentSkills, mcpConnector, mcpToolWrap, eager, hooks: initialHooks, clock: agentClock, toolKill, contextBreakdownSections, runTransforms, behaviorTransforms, toolCatalogTransforms, mcpConfigTransforms, skillPolicies, toolResultMetadata, artifacts: artifactsOption } = foldExtensionRegistry(rawOptions);
 	const providers = normalizeProviders(providerOption);
 	const provider = providers[0];
 	const hooks = createHooks();
@@ -17479,6 +17464,7 @@ function createAgent(rawOptions) {
 				skillActivationState,
 				hooks,
 				toolCatalogTransforms,
+				toolDescriptions,
 				executionContext,
 				behavior: resolvedBehavior
 			});
@@ -17489,6 +17475,7 @@ function createAgent(rawOptions) {
 				toolDisclosure,
 				toolSearch,
 				toolAliases: effectiveToolAliases,
+				toolDescriptions,
 				hasRunToolOverride: options.tools !== void 0,
 				providerName: runProvider.name
 			});
@@ -17856,6 +17843,7 @@ function createAgent(rawOptions) {
 						...agentSystem !== void 0 ? { system: agentSystem } : {},
 						tools: sourceTools,
 						...effectiveToolAliases !== void 0 ? { toolAliases: effectiveToolAliases } : {},
+						...toolDescriptions !== void 0 ? { toolDescriptions } : {},
 						...allMcpServers.length > 0 ? { mcpServers: allMcpServers } : {},
 						mcpConnection: () => mcpConnection,
 						...agentSkills !== void 0 ? { skills: agentSkills } : {}
@@ -18229,7 +18217,7 @@ function createAgent(rawOptions) {
 			...mcpConnection.tools
 		} : sourceTools;
 		const mcpNames = new Set(mcpConnection ? Object.keys(mcpConnection.tools) : []);
-		const preRunTools = applyToolCatalogTransforms(baseTools, toolCatalogTransforms, "pre-run", mcpNames);
+		const preRunTools = applyToolDescriptionOverrides(applyToolCatalogTransforms(baseTools, toolCatalogTransforms, "pre-run", mcpNames), toolDescriptions, mcpNames, mcpServers);
 		const preRunSeparatorAliases = buildMcpToolNameSeparatorAliases(mcpNames, mcpServers, agentBehavior?.mcpToolNameSeparator ?? "_");
 		const preRunBaseAliases = preRunSeparatorAliases ? {
 			...preRunSeparatorAliases,
@@ -18423,4 +18411,4 @@ function createAgent(rawOptions) {
 //#endregion
 export { ExtensionInstallError as $, defaultRepeatGuardTracked as $n, DEFAULT_KEYBINDINGS as $t, buildPostCompactAttachments as A, resolveExtensionConfigValue as An, reserveChildLabel as At, buildFullCompactPrompt as B, fileKind as Bn, multiEdit as Bt, rehomePersistedStubs as C, setDebugLogSink as Cn, basic_default as Ct, resolvePersistDir as D, isValidExtensionConfigItem as Dn, createToolSearchTool as Dt, resolveMcpWarningsDir as E, coerceExtensionConfigInput as En, waitTask as Et, BASE_INSTRUCTIONS as F, serializedPayloadBytes as Fn, createShellTool as Ft, sliceForCompaction as G, renderArtifactRow as Gn, createInteractionTool as Gt, buildUpToCompactPrompt as H, parseShortstat as Hn, formatModelLine as Ht, NO_TOOLS_PREAMBLE as I, BUILTIN_ARTIFACT_KINDS as In, shell as It, truncateHeadForPtlRetry as J, AUTO_COMPACT_MIN_GROWTH_FRACTION as Jn, edit as Jt, stripImagesFromTurns as K, resolveArtifactKind as Kn, grep as Kt, TRAILER as L, artifactKindLabel as Ln, tailTruncate as Lt, selectFilesFromSession as M, toWireConfigSchema as Mn, createSkillsRunScriptTool as Mt, selectRecentFiles as N, EXTENSION_BUS_MAX_PAYLOAD_BYTES as Nn, createSkillsReadTool as Nt, resolveSessionDir as O, isValidExtensionConfigValue as On, createSpawnTool as Ot, compactConversation as P, createExtensionBus as Pn, shellKill as Pt, createExtensionPromptBridge as Q, defaultRepeatGuardNormalize as Qn, recordArtifact as Qt, buildCompactPrompt as R, branchKind as Rn, readFile$1 as Rt, migrateSessionArtifactDirs as S, createDebugLog as Sn, basicTools as St, resolveLegacySessionDir as T, clampExtensionConfigNumber as Tn, WAIT_TASK_TIMED_OUT_PREFIX as Tt, ANCHOR_PREVIEW_MAX_CHARS as U, pullRequestKind as Un, matchModelEntries as Ut, buildTailCompactPrompt as V, githubTokenSource as Vn, createModelSearchTool as Vt, anchorPreviewFor as W, refreshArtifact as Wn, listFiles as Wt, CompactPromptTooLongError as X, effectiveContextWindow as Xn, artifacts_default as Xt, CompactInvalidInputError as Y, OUTPUT_RESERVE_TOKENS as Yn, validateToolArgs as Yt, EMPTY_EXTENSION_REGISTRY as Z, shouldAutoCompact as Zn, RECORD_ARTIFACT_TOOL as Zt, PERSISTED_STUB_PREFIX as _, discoverExtensions as _n, createArtifactsSurface as _t, stagedToolState as a, groupBindings as an, hydrateReadStateFromSessionAsync as ar, removeInstalledExtension as at, cleanupPersistedSession as b, parseExtensionScanPathEnv as bn, composePresets as bt, INTERRUPT_MESSAGE_FOR_TOOL_USE as c, mergeKeybindings as cn, discoverAndBuildExtensionRegistry as ct, TOOL_USE_SKIPPED_MESSAGE as d, readKeybindingsRaw as dn, composeExtensionPreset as dt, KEYBINDING_DEFS as en, normalizeShellCommand as er, fetchExtensionSource as et, applyCompactSummaryCutoff as f, resolveExtensionKeybindings as fn, disposeExtensionRegistry as ft, unwrapCallTool as g, defaultExtensionScanPaths as gn, partitionExtensionCatalog as gt, CALL_TOOL_NAME as h, ENTRY_CANDIDATES as hn, mergeContributions as ht, isToolStateOps as i, formatBindingForDisplay as in, hydrateReadStateFromSession as ir, readExtensionInstallProvenance as it, selectFilesFromReadState as j, sanitizeExtensionConfigActionPatch as jn, createSkillsUseTool as jt, resolveTasksDir as k, resolveExtensionConfig as kn, isSpawnTool as kt, SHELL_CASCADE_CANCEL_MESSAGE as l, parseBindingSpec as ln, buildExtensionPreset as lt, renderStaleReadNotice as m, registerExtensionHostModules as mn, filterRegistryPlugins as mt, DEFAULT_MAX_VALUE_BYTES as n, KEYBINDING_KEY_COL_WIDTH as nn, getReadState as nr, listExtensionCandidates as nt, normalizeProviders as o, keybindingsPath as on, readStateKey as or, updateInstalledExtension as ot, collectNewlyStaleReadPaths as p, stripJsonComments as pn, filterExtensionRegistry as pt, summaryToTurn as q, createArtifactDetectHook as qn, glob as qt, createToolStateController as r, ensureKeybindingsFile as rn, hashContent as rr, parseExtensionInstallSource as rt, resolveModelTargets as s, matchesBinding as sn, resolveReadStateMap as sr, createExtensionHud as st, createAgent as t, KEYBINDING_DEF_BY_ACTION as tn, stableStringify as tr, installExtensionFromSpec as tt, TOOL_USE_CANCELLED_MESSAGE as u, readKeybindings as un, buildExtensionRegistry as ut, PERSISTENCE_PREVIEW_BYTES as v, inlineLoadedExtension as vn, createExtensionHostRuntimeBridge as vt, resolveLegacyPersistDir as w, defineExtension as wn, writeFile$1 as wt, maybePersistToolResult as x, scanExtensionDirectories as xn, definePreset as xt, buildPersistedStub as y, isExtensionDefinition as yn, createWorkspaceSurface as yt, buildFromCompactPrompt as z, commitKind as zn, looksBinary as zt };
 
-//# sourceMappingURL=agent-BlGt76qk.js.map
+//# sourceMappingURL=agent-CJbmpTmA.js.map