@cydm/pie 2.7.6 → 2.7.8

package/dist/chunks/{chunk-GAUIKMBA.js → chunk-E6F4BTNN.js}

@@ -6,10 +6,10 @@ import {
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-YWWLRZSG.js";
+} from "./chunk-P22SYVGO.js";
 import {
   getLogger
-} from "./chunk-ZF5FHTES.js";
+} from "./chunk-2FEDB5GR.js";
 import {
   Type
 } from "./chunk-XXGYUYXI.js";
@@ -188,7 +188,7 @@ function createTraceTransportSink(noteRuntimeEvent) {
 }
 
 // src/capabilities/bash/index.ts
-import { spawn } from "child_process";
+import { spawn, spawnSync } from "child_process";
 import { closeSync, createWriteStream, existsSync as existsSync2, openSync, statSync, unlinkSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
 import { join as join2, resolve as resolve2 } from "path";
@@ -316,6 +316,30 @@ function truncateStringToBytesFromEnd(str, maxBytes) {
   return buf.slice(start).toString("utf-8");
 }
 
+// src/capabilities/bash/contract.ts
+var WINDOWS_DIALECT_BLOCK = `On this host shell:auto runs Windows PowerShell 5.1 (powershell.exe). Write PowerShell syntax: separate statements with ';' (PS 5.1 has no && or || \u2014 chain with "if ($?) { ... }" or check $LASTEXITCODE after native commands). Nested quotes in inline "node -e" or "-Command" strings are fragile; write a temp script file with write_file and execute it instead. Heredocs do not exist; multi-line commands work, but long scripts run more reliably from a file. Judge outcomes by the exit code; stderr may carry PowerShell-generated records such as CLIXML. shell:"bash" runs the first real bash on PATH (Git Bash when installed) and fails with an actionable error when only the WSL stub exists; shell:"cmd" runs cmd.exe.`;
+var POSIX_DIALECT_BLOCK = 'On this host shell:auto runs bash (bash -c). POSIX syntax applies: && and || chaining, heredocs, and standard quoting rules are available. shell:"powershell" uses pwsh when installed; shell:"cmd" is Windows-only.';
+function buildShellToolContract(platform = process.platform) {
+  if (platform === "win32") {
+    return {
+      dialect: "powershell51",
+      defaultShell: "powershell",
+      name: "shell",
+      label: "powershell",
+      dialectBlock: WINDOWS_DIALECT_BLOCK,
+      commandParamDescription: "The PowerShell command to execute by default (Windows PowerShell 5.1). If shell is overridden, use that shell's syntax."
+    };
+  }
+  return {
+    dialect: "bash",
+    defaultShell: "bash",
+    name: "shell",
+    label: "bash",
+    dialectBlock: POSIX_DIALECT_BLOCK,
+    commandParamDescription: "The bash command to execute by default. If shell is overridden, use that shell's syntax."
+  };
+}
+
 // src/capabilities/bash/artifact-sink.ts
 function createArtifactSinkGate(sink, isActive) {
   const sources = /* @__PURE__ */ new Set();
@@ -353,40 +377,198 @@ function createArtifactSinkGate(sink, isActive) {
   };
 }
 
+// src/capabilities/bash/powershell-display.ts
+import { StringDecoder } from "node:string_decoder";
+var MARKER = "#< CLIXML";
+var MAX_CLIXML_CHARS = 64 * 1024;
+function xmlText(text) {
+  if (/[<>]|\]\]>/.test(text)) return void 0;
+  let valid = true;
+  const decoded = text.replace(/&([^;]{0,10});|&/g, (whole, entity) => {
+    const named = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+    if (entity && Object.hasOwn(named, entity)) return named[entity];
+    const n = entity && /^#(?:[0-9]+|x[0-9a-fA-F]+)$/.test(entity) ? Number.parseInt(entity.slice(entity[1] === "x" ? 2 : 1), entity[1] === "x" ? 16 : 10) : NaN;
+    if (!Number.isInteger(n) || !(n === 9 || n === 10 || n === 13 || n >= 32 && n <= 55295 || n >= 57344 && n <= 65533 || n >= 65536 && n <= 1114111)) {
+      valid = false;
+      return whole;
+    }
+    return String.fromCodePoint(n);
+  });
+  if (!valid || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\ufffe\uffff]/.test(decoded)) return void 0;
+  return decoded.replace(/_x([0-9a-fA-F]{4})_/g, (whole, hex) => {
+    const n = Number.parseInt(hex, 16);
+    return n === 9 || n === 10 || n === 13 || n >= 32 && n < 127 || n >= 160 && n < 55296 || n >= 57344 && n < 65534 ? String.fromCharCode(n) : whole;
+  });
+}
+function unpack(xml) {
+  let pos = 0;
+  const take = (pattern) => {
+    pattern.lastIndex = pos;
+    const match = pattern.exec(xml);
+    if (match) pos = pattern.lastIndex;
+    return match;
+  };
+  if (!take(/\s*<Objs/y)) return void 0;
+  const attrs = /* @__PURE__ */ new Set();
+  while (true) {
+    const attr = take(/\s+(Version|xmlns)=(?:"([^"<>]*)"|'([^'<>]*)')/y);
+    if (!attr) break;
+    if (attrs.has(attr[1])) return void 0;
+    attrs.add(attr[1]);
+    const value = attr[2] ?? attr[3];
+    if (attr[1] === "Version" ? value !== "1.1.0.1" : value !== "http://schemas.microsoft.com/powershell/2004/04") return void 0;
+  }
+  if (!take(/\s*>/y)) return void 0;
+  const records = [];
+  while (true) {
+    if (take(/\s*<\/Objs>/y)) return pos === xml.length && records.length > 0 ? records.join("") : void 0;
+    const record = take(/\s*<S\s+S=(?:"(Error|Warning|Verbose|Debug|Information|Output|Progress)"|'(Error|Warning|Verbose|Debug|Information|Output|Progress)')\s*>([^<]*)<\/S>/y);
+    if (!record) return void 0;
+    const text = xmlText(record[3]);
+    if (text === void 0) return void 0;
+    records.push(text);
+  }
+}
+var PowerShellStderrNormalizer = class {
+  constructor(emit) {
+    this.emit = emit;
+  }
+  emit;
+  decoder = new StringDecoder("utf8");
+  pending = "";
+  block = false;
+  endTagTail = "";
+  lineStart = true;
+  disabled = false;
+  normalizedBlocks = 0;
+  write(data) {
+    this.accept(this.decoder.write(data));
+  }
+  end() {
+    this.accept(this.decoder.end());
+    this.emit(this.pending);
+    this.pending = "";
+  }
+  accept(text) {
+    let plain = "";
+    const flush = () => {
+      if (plain) this.emit(plain);
+      plain = "";
+    };
+    for (const char of text) {
+      if (this.disabled) {
+        plain += char;
+        continue;
+      }
+      if (this.block) {
+        this.pending += char;
+        this.endTagTail = (this.endTagTail + char).slice(-7);
+        if (this.pending.length > MAX_CLIXML_CHARS) {
+          plain += this.pending;
+          this.pending = "";
+          this.block = false;
+          this.disabled = true;
+        } else if (this.endTagTail === "</Objs>") {
+          const newline = this.pending.indexOf("\n");
+          const decoded = unpack(this.pending.slice(newline + 1));
+          flush();
+          if (decoded !== void 0) {
+            this.normalizedBlocks++;
+            this.emit(decoded);
+          } else this.emit(this.pending);
+          this.pending = "";
+          this.block = false;
+          this.endTagTail = "";
+          this.lineStart = false;
+        }
+        continue;
+      }
+      if (this.lineStart) {
+        this.pending += char;
+        if (this.pending === MARKER + "\n" || this.pending === MARKER + "\r\n") {
+          flush();
+          this.block = true;
+          this.endTagTail = "";
+          continue;
+        }
+        if ((MARKER + "\n").startsWith(this.pending) || (MARKER + "\r\n").startsWith(this.pending)) continue;
+        plain += this.pending;
+        this.pending = "";
+        this.lineStart = char === "\n";
+      } else {
+        plain += char;
+        this.lineStart = char === "\n";
+      }
+    }
+    flush();
+  }
+};
+var PowerShellDisplay = class {
+  head = "";
+  tail = "";
+  total = 0;
+  totalBytes = 0;
+  newlines = 0;
+  stdout = new StringDecoder("utf8");
+  stderr = new PowerShellStderrNormalizer((text) => this.append(text));
+  append(text) {
+    const cap = DEFAULT_MAX_BYTES;
+    this.total += text.length;
+    this.totalBytes += Buffer.byteLength(text, "utf8");
+    for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) this.newlines++;
+    if (this.head.length < cap) this.head += text.slice(0, cap - this.head.length);
+    this.tail = (this.tail + text).slice(-cap);
+  }
+  writeStdout(data) {
+    this.append(this.stdout.write(data));
+  }
+  end() {
+    this.append(this.stdout.end());
+    this.stderr.end();
+  }
+  preview() {
+    const result = truncateHeadTail(this.total <= this.head.length ? this.head : this.total <= this.head.length + this.tail.length ? this.head + this.tail.slice(this.head.length + this.tail.length - this.total) : this.head + "\n... [stream middle omitted] ...\n" + this.tail);
+    if (this.totalBytes > result.totalBytes) {
+      result.truncated = true;
+      result.totalBytes = this.totalBytes;
+      result.totalLines = this.newlines + 1;
+      result.truncatedBy = result.totalLines > DEFAULT_MAX_LINES ? "lines" : "bytes";
+    }
+    return result;
+  }
+};
+
 // src/capabilities/bash/index.ts
-var bashSchema = Type.Object({
-  command: Type.String({ description: "The bash command to execute" }),
-  timeout: Type.Optional(
-    Type.Number({
-      description: "Timeout in seconds. Default: 120s (2 minutes). Longer timeouts are honored for installs, builds, and tests; generic custom scripts and polling commands are capped to protect the turn budget."
-    })
-  ),
-  cwd: Type.Optional(Type.String({ description: "Working directory for the command" })),
-  shell: Type.Optional(Type.Union([
-    Type.Literal("auto"),
-    Type.Literal("bash"),
-    Type.Literal("powershell"),
-    Type.Literal("cmd")
-  ], { description: "Shell to use. Defaults to bash on macOS/Linux and PowerShell on Windows. Use this only for platform-specific commands." }))
-});
+function buildBashSchema(commandDescription) {
+  return Type.Object({
+    command: Type.String({ description: commandDescription }),
+    timeout: Type.Optional(
+      Type.Number({
+        exclusiveMinimum: 0,
+        maximum: 2147483,
+        description: "Timeout in seconds. Default: 120s (2 minutes). The requested value is honored as-is for every command; set it to what the task needs (installs, builds, and tests often need more)."
+      })
+    ),
+    cwd: Type.Optional(Type.String({ description: "Working directory for the command" })),
+    shell: Type.Optional(Type.Union([
+      Type.Literal("auto"),
+      Type.Literal("bash"),
+      Type.Literal("powershell"),
+      Type.Literal("cmd")
+    ], { description: "Shell to use. Defaults to bash on macOS/Linux and PowerShell on Windows. Use this only for platform-specific commands." }))
+  });
+}
 var DEFAULT_TIMEOUT_SECONDS = 120;
-var MAX_GENERIC_TIMEOUT_SECONDS = 120;
 var OUTPUT_DRAIN_TIMEOUT_MS = 1e3;
 var MAX_SHELL_EXIT_DRAIN_MS = 1e4;
-function resolveTimeoutPolicy(requestedTimeout, commandClass) {
+function resolveTimeoutPolicy(requestedTimeout) {
   const requestedSeconds = requestedTimeout ?? DEFAULT_TIMEOUT_SECONDS;
-  if (requestedSeconds > MAX_GENERIC_TIMEOUT_SECONDS && commandClass !== "package_manager" && commandClass !== "test_or_build") {
-    return {
-      requestedSeconds,
-      effectiveSeconds: MAX_GENERIC_TIMEOUT_SECONDS,
-      capped: true,
-      reason: `long timeouts are capped at ${MAX_GENERIC_TIMEOUT_SECONDS}s for non-build commands`
-    };
+  if (!Number.isFinite(requestedSeconds) || requestedSeconds <= 0 || requestedSeconds > 2147483) {
+    throw new Error("Invalid shell timeout: use a finite positive number of seconds within the supported timer range (2147483s).");
   }
   return {
     requestedSeconds,
-    effectiveSeconds: requestedSeconds,
-    capped: false
+    effectiveSeconds: requestedSeconds
   };
 }
 function validateBashCommand(command) {
@@ -396,10 +578,10 @@ function validateBashCommand(command) {
     throw new Error("Command cannot be empty. Pass a real shell command in the command argument.");
   }
   if (/^:\s/.test(trimmed) || /^:\s*(?:\d+[\.)]?)?\s*$/.test(trimmed) || /^:\s*\d+[\.)]/.test(trimmed)) {
-    throw new Error(`Invalid bash command "${value}". Do not pass a no-op, numbered plan item, or plan fragment; pass the actual shell command to run.`);
+    throw new Error(`Invalid shell command "${value}". Do not pass a no-op, numbered plan item, or plan fragment; pass the actual shell command to run.`);
   }
   if (trimmed.includes("<|tool")) {
-    throw new Error("Invalid bash command. The command argument must be only a real shell command, not tool-call markup.");
+    throw new Error("Invalid shell command. The command argument must be only a real shell command, not tool-call markup.");
   }
 }
 function buildEffectiveCommand(command, options, shell) {
@@ -413,21 +595,80 @@ function buildEffectiveCommand(command, options, shell) {
   }
   return `${prefix} && ${command}`;
 }
-function resolveShell(shell) {
+function resolveShell(shell, contract) {
   if (!shell || shell === "auto") {
-    return process.platform === "win32" ? "powershell" : "bash";
+    return contract.defaultShell;
   }
   return shell;
 }
+function buildBashDescription(contract) {
+  return [
+    "Execute a shell command in the current working directory.",
+    contract.dialectBlock,
+    `Returns stdout and stderr as a bounded head/tail preview of at most ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB. If truncated, the result includes a private full-output artifact path. Default timeout: 120s. The timeout parameter is the budget: pass a larger value when a task legitimately needs it, and keep long waits focused rather than polling loops.`
+  ].join(" ");
+}
 function buildSpawnCommand(shell, command) {
   if (shell === "powershell") {
-    const utf8Command = `[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding; $OutputEncoding = [Console]::OutputEncoding; ${command}`;
-    return { file: process.platform === "win32" ? "powershell.exe" : "pwsh", args: ["-NoProfile", "-NonInteractive", "-Command", utf8Command], shell: false };
+    const childScript = [
+      "$ProgressPreference = 'SilentlyContinue'",
+      "[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding; $OutputEncoding = [Console]::OutputEncoding",
+      command,
+      "if (($null -ne $LASTEXITCODE) -and ($LASTEXITCODE -ne 0)) { exit $LASTEXITCODE }"
+    ].join("\n");
+    const script = [
+      "$ProgressPreference = 'SilentlyContinue'",
+      `powershell.exe -NoProfile -NonInteractive -EncodedCommand ${Buffer.from(childScript, "utf16le").toString("base64")}`,
+      "$__pieCode = $LASTEXITCODE; $__pieOk = $?",
+      "if (-not $__pieOk -and (($null -eq $__pieCode) -or ($__pieCode -eq 0))) { exit 1 }",
+      "if (($null -ne $__pieCode) -and ($__pieCode -ne 0)) { exit $__pieCode }",
+      "exit 0"
+    ].join("\n");
+    const encoded = Buffer.from(script, "utf16le").toString("base64");
+    return { file: process.platform === "win32" ? "powershell.exe" : "pwsh", args: ["-NoProfile", "-NonInteractive", "-EncodedCommand", encoded], shell: false };
   }
   if (shell === "cmd") {
     return { file: "cmd.exe", args: ["/d", "/s", "/c", command], shell: false };
   }
-  return { file: process.platform === "win32" ? "bash.exe" : "bash", args: ["-c", command], shell: false };
+  if (process.platform === "win32") {
+    const bashPath = resolveWindowsBashPath();
+    if (!bashPath) {
+      throw new Error(
+        "No usable bash found on Windows: PATH only offers the WSL store stub (WindowsApps\\bash.exe). Install Git Bash (https://git-scm.com) or WSL, or use shell:auto (PowerShell)."
+      );
+    }
+    return { file: bashPath, args: ["-c", command], shell: false };
+  }
+  return { file: "bash", args: ["-c", command], shell: false };
+}
+var windowsBashPathCache;
+function resolveWindowsBashPath() {
+  if (windowsBashPathCache !== void 0) return windowsBashPathCache;
+  let resolved = null;
+  try {
+    const result = spawnSync("cmd.exe", ["/d", "/c", "where", "bash"], { windowsHide: true, encoding: "utf8", timeout: 5e3 });
+    const lines = (result.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const real = lines.find((line) => !isWindowsAppsPath(line));
+    resolved = real ?? null;
+  } catch {
+    resolved = null;
+  }
+  if (!resolved) {
+    const programFiles = [process.env.PROGRAMFILES, process.env["PROGRAMFILES(X86)"]].filter((value) => Boolean(value));
+    for (const root of programFiles) {
+      const candidate = join2(root, "Git", "bin", "bash.exe");
+      if (existsSync2(candidate)) {
+        resolved = candidate;
+        break;
+      }
+    }
+  }
+  windowsBashPathCache = resolved;
+  return resolved;
+}
+function isWindowsAppsPath(p) {
+  const normalized = p.replace(/\\/g, "/").toLowerCase();
+  return normalized.includes("/windowsapps/");
 }
 async function requestHighRiskConfirmation(request) {
   const response = await requestInteraction({
@@ -633,6 +874,7 @@ function killProcessTree(pid, leaderExited) {
   }
 }
 function createBashTool(defaultCwd, options) {
+  const contract = buildShellToolContract(options?.platform);
   const recentCommands = /* @__PURE__ */ new Map();
   const rememberCommandResult = (key, fingerprint) => {
     const previous = recentCommands.get(key);
@@ -646,13 +888,28 @@ function createBashTool(defaultCwd, options) {
     return { count, sameResult };
   };
   return {
-    name: "bash",
-    label: "bash",
-    description: `Execute a shell command in the current working directory. The public tool name remains bash for compatibility; on Windows shell:auto uses PowerShell, otherwise bash. Returns stdout and stderr as a bounded head/tail preview of at most ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB. If truncated, the result includes a private full-output artifact path. Default timeout: 120s. Long timeouts are reserved for installs, builds, and tests; custom scripts, searches, and polling commands are capped at ${MAX_GENERIC_TIMEOUT_SECONDS}s and should be split into bounded steps with progress output.`,
-    parameters: bashSchema,
+    name: contract.name,
+    label: contract.label,
+    description: buildBashDescription(contract),
+    parameters: buildBashSchema(contract.commandParamDescription),
+    // Policy identity travels with the tool (single source of truth, so a
+    // host may rename it without touching this layer's registries); the
+    // shared BUILTIN_TOOL_CAPABILITY_METADATA["bash"] entry stays as the
+    // name-keyed fallback for legacy sessions and name-only test doubles.
+    capabilityMetadata: {
+      riskClass: "shell",
+      concurrencySafe: false,
+      requiresPermission: true,
+      permissionScope: "shell",
+      executesShell: true,
+      availableInPlanMode: true,
+      allowedForSubagentByDefault: true,
+      highRisk: true,
+      maxOutputChars: 1e5
+    },
     execute: async (_toolCallId, { command, timeout, cwd, shell }, signal, onUpdate) => {
       validateBashCommand(command);
-      const resolvedShell = resolveShell(shell);
+      const resolvedShell = resolveShell(shell, contract);
       const effectiveCommand = buildEffectiveCommand(command, options, resolvedShell);
       const workingDir = normalizeWorkingDirectory(cwd, defaultCwd);
       validateWorkingDirectory(workingDir);
@@ -717,7 +974,7 @@ function createBashTool(defaultCwd, options) {
           }
         });
       }
-      const timeoutPolicy = resolveTimeoutPolicy(timeout, risk.commandClass);
+      const timeoutPolicy = resolveTimeoutPolicy(timeout);
       const timeoutMs = timeoutPolicy.effectiveSeconds * 1e3;
       return new Promise((resolve3, reject) => {
         if (signal?.aborted) {
@@ -729,6 +986,7 @@ function createBashTool(defaultCwd, options) {
         let tempFileSink;
         let settled = false;
         let totalBytes = 0;
+        const display = resolvedShell === "powershell" ? new PowerShellDisplay() : void 0;
         const chunks = [];
         let chunksBytes = 0;
         const maxChunksBytes = DEFAULT_MAX_BYTES * 2;
@@ -854,10 +1112,9 @@ function createBashTool(defaultCwd, options) {
             }
           }
           appendRollingChunk(data);
+          display?.writeStdout(data);
           if (onUpdate) {
-            const fullBuffer = Buffer.concat(chunks);
-            const fullText = fullBuffer.toString("utf-8");
-            const truncation = truncateHeadTail(fullText);
+            const truncation = display?.preview() ?? truncateHeadTail(Buffer.concat(chunks).toString("utf-8"));
             onUpdate({
               content: [{ type: "text", text: truncation.content || "" }],
               details: {
@@ -908,6 +1165,15 @@ function createBashTool(defaultCwd, options) {
             }
           }
           appendRollingChunk(data);
+          display?.stderr.write(data);
+          if (display?.stderr.normalizedBlocks && !tempFilePath) {
+            try {
+              const sink = ensureOutputArtifact();
+              for (const chunk of chunks) sink.write(chunk);
+            } catch (error) {
+              failExecution(error instanceof Error ? error : new Error(String(error)));
+            }
+          }
         });
         const finishExecution = async (code, sig, stdioIncomplete = false) => {
           if (settled) return;
@@ -924,8 +1190,9 @@ function createBashTool(defaultCwd, options) {
 ... [stream middle omitted] ...
 ${fullOutput}`;
             }
-            const truncation = truncateHeadTail(fullOutput);
-            if (totalBytes > truncation.totalBytes) {
+            display?.end();
+            const truncation = display?.preview() ?? truncateHeadTail(fullOutput);
+            if (!display && totalBytes > truncation.totalBytes) {
               truncation.truncated = true;
               truncation.totalBytes = totalBytes;
               truncation.totalLines = totalNewlines + 1;
@@ -938,7 +1205,7 @@ ${fullOutput}`;
               tempFilePath = path3;
               retainedOutputArtifacts.add(path3);
               try {
-                writeFileSync(fd, fullOutput, "utf-8");
+                writeFileSync(fd, fullBuffer);
               } finally {
                 closeSync(fd);
               }
@@ -998,20 +1265,22 @@ ${commandNonzeroHint}`;
 [Showing a bounded head/tail preview of ${truncation.totalLines} lines (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${tempFilePath}]`;
               }
             }
+            if (display?.stderr.normalizedBlocks) {
+              details.outputNormalization = { kind: "powershell-clixml-text", blocks: display.stderr.normalizedBlocks, rawEvidence: true };
+              details.fullOutputPath = tempFilePath;
+              outputText += `
+
+[PowerShell CLIXML text records unpacked for display (limited support: complex/unknown records remain raw). Raw stdout/stderr evidence in observed capture order: ${tempFilePath}]`;
+            }
             if (timedOut) {
               outputText += `
 
 [Command timed out after ${timeoutPolicy.effectiveSeconds} seconds]`;
-              outputText += "\n[Timeout hint: split custom searches or service polls into smaller bounded steps with progress output, inspect partial results/logs, then make a decision. Avoid repeating long waits. Reserve long timeouts for installs, builds, and tests.]";
+              outputText += "\n[Timeout hint: the command ran longer than its requested budget. Inspect partial results/logs, then either raise the timeout to what the task needs or split long waits into smaller focused steps. Avoid repeating identical long waits.]";
             }
             if (stdioIncomplete && !timedOut) {
               outputText += "\n\n[Output capture ended after the command exited because a descendant kept stdio open or the output artifact was still draining (bounded wait). Captured output may be incomplete.]";
             }
-            if (timeoutPolicy.capped) {
-              outputText += `
-
-[Timeout policy: requested ${timeoutPolicy.requestedSeconds} seconds, capped to ${timeoutPolicy.effectiveSeconds} seconds because ${timeoutPolicy.reason}.]`;
-            }
             const recoveryHint = buildBashRecoveryHint(command, outputText);
             if (recoveryHint) {
               outputText += `
@@ -1046,7 +1315,7 @@ ${commandNonzeroHint}`;
           void finishExecution(code, sig);
         });
         child.on("error", (err) => {
-          failExecution(new Error(`Failed to start bash command in ${workingDir}: ${err.message}. Check that the command is executable and cwd exists.`));
+          failExecution(new Error(`Failed to start shell command in ${workingDir}: ${err.message}. Check that the command is executable and cwd exists.`));
         });
       });
     }
@@ -1292,7 +1561,7 @@ function createCliHostCapabilities(cwd, options = {}) {
   });
   const capabilities = [
     {
-      id: "bash",
+      id: "shell",
       description: "Node/TUI host capability for executing shell commands in the local workspace.",
       tools: [bashTool]
     },