@wrongstack/tools 1.0.8 → 1.0.10

package/dist/{chunk-5KRKL3WD.js → chunk-FCSUBTUJ.js}

@@ -14,7 +14,7 @@ import {
 } from "./chunk-HDYUBRMF.js";
 import {
   resolvePowerShell
-} from "./chunk-5U5ULQX2.js";
+} from "./chunk-XZLVJD56.js";
 import {
   normalizeCommandOutput
 } from "./chunk-2IAEJRLT.js";
@@ -185,6 +185,34 @@ function isKillRelatedCommand(cmd) {
   if (SCRIPT_KILL_RE_POSIX.test(normalized)) return true;
   return false;
 }
+function parsePosixKillTargets(normalized, command) {
+  const tokens = normalized.split(" ");
+  if (tokens[0]?.toLowerCase() !== "kill") return null;
+  let i = 1;
+  let signal = "TERM";
+  const first = tokens[i];
+  if (first !== void 0 && /^-[sn]$/i.test(first)) {
+    const value = tokens[i + 1];
+    if (!value || !/^[a-zA-Z0-9]+$/.test(value)) return null;
+    signal = value.toUpperCase();
+    i += 2;
+  } else if (first !== void 0 && first !== "--" && /^-[a-zA-Z0-9]+$/.test(first) && tokens.length - i >= 2) {
+    signal = first.slice(1).toUpperCase();
+    i += 1;
+  }
+  if (tokens[i] === "--") i += 1;
+  const targets = tokens.slice(i);
+  if (targets.length === 0 || !targets.every((t) => /^-?\d+$/.test(t))) return null;
+  const pids = targets.map((t) => Number.parseInt(t.replace(/^-/, ""), 10));
+  return {
+    pid: pids[0],
+    ...pids.length > 1 ? { pids } : {},
+    signal,
+    isGroupKill: targets.some((t) => t.startsWith("-")),
+    isAllKill: false,
+    originalCommand: command
+  };
+}
 function parseKillCommand(command) {
   const normalized = command.replace(/\s+/g, " ").trim();
   if (isWin) {
@@ -241,27 +269,8 @@ function parseKillCommand(command) {
         originalCommand: command
       };
     }
-    const killSignalOptionMatch = normalized.match(/^kill\s+-s\s+([a-zA-Z0-9]+)\s+(\d+)$/i);
-    if (killSignalOptionMatch?.[1] && killSignalOptionMatch[2]) {
-      return {
-        pid: parseInt(killSignalOptionMatch[2], 10),
-        signal: killSignalOptionMatch[1].toUpperCase(),
-        isGroupKill: false,
-        isAllKill: false,
-        originalCommand: command
-      };
-    }
-    const killPosixMatch = normalized.match(/^kill\s+(?:(-[a-zA-Z0-9]+)\s+)?(\d+)$/);
-    if (killPosixMatch?.[2]) {
-      const sig = killPosixMatch[1] ? killPosixMatch[1].slice(1).toUpperCase() : "TERM";
-      return {
-        pid: parseInt(killPosixMatch[2], 10),
-        signal: sig,
-        isGroupKill: false,
-        isAllKill: false,
-        originalCommand: command
-      };
-    }
+    const gitBashKill = parsePosixKillTargets(normalized, command);
+    if (gitBashKill) return gitBashKill;
     const stopProcNameMatch = normalized.match(
       /^(?:stop-process|kill)\s+-(?:name|n)\s+(?:['"]([a-zA-Z0-9_.-]+)['"]|([a-zA-Z0-9_.-]+))(?:\s|$)/i
     );
@@ -324,33 +333,8 @@ function parseKillCommand(command) {
     }
     return null;
   }
-  const signalOptionMatch = normalized.match(/^kill\s+-s\s+([a-zA-Z0-9]+)\s+(\d+|-?\d+)$/i);
-  if (signalOptionMatch?.[1] && signalOptionMatch[2]) {
-    const pidOrGroup = signalOptionMatch[2];
-    const isGroupKill = pidOrGroup.startsWith("-");
-    return {
-      pid: parseInt(isGroupKill ? pidOrGroup.slice(1) : pidOrGroup, 10),
-      signal: signalOptionMatch[1].toUpperCase(),
-      isGroupKill,
-      isAllKill: false,
-      originalCommand: command
-    };
-  }
-  const simpleMatch = normalized.match(/^kill\s+(?:(-[a-zA-Z0-9]+)\s+)?(\d+|-?\d+)$/);
-  if (simpleMatch) {
-    const signal = simpleMatch[1] ?? "-TERM";
-    const pidOrGroup = simpleMatch[2];
-    if (!pidOrGroup) return null;
-    const isGroupKill = pidOrGroup.startsWith("-");
-    const pid = isGroupKill ? parseInt(pidOrGroup.slice(1), 10) : parseInt(pidOrGroup, 10);
-    return {
-      pid,
-      signal: signal.slice(1),
-      isGroupKill,
-      isAllKill: false,
-      originalCommand: command
-    };
-  }
+  const posixKill = parsePosixKillTargets(normalized, command);
+  if (posixKill) return posixKill;
   const pkillMatch = normalized.match(/^pkill\s+(?:(-[a-zA-Z]+)\s+)?(.+)$/);
   if (pkillMatch?.[2]) {
     const name = pkillMatch[2];
@@ -429,14 +413,60 @@ async function isKillProtected(kill) {
     const protectedPids = await registry.getAllProtectedPids();
     return protectedPids.length > 0;
   }
-  if (kill.pid !== void 0) {
-    if (await registry.shouldBlockKill(kill.pid)) return true;
-    if (kill.pid === process.pid || kill.pid === process.ppid) return true;
-    return false;
+  const targets = kill.pids ?? (kill.pid !== void 0 ? [kill.pid] : []);
+  for (const pid of targets) {
+    if (await registry.shouldBlockKill(pid)) return true;
+    if (pid === process.pid || pid === process.ppid) return true;
   }
   return false;
 }
 async function checkAndBlockKillCommand(command) {
+  const whole = await checkSingleCommand(command);
+  if (whole.blocked) return whole;
+  const segments = splitShellSequence(command);
+  if (segments.length > 1) {
+    for (const segment of segments) {
+      const result = await checkSingleCommand(segment);
+      if (result.blocked) return result;
+    }
+  }
+  return { blocked: false };
+}
+function splitShellSequence(command) {
+  const segments = [];
+  let current = "";
+  let quote = null;
+  for (let i = 0; i < command.length; i++) {
+    const ch = command[i];
+    const next = command[i + 1];
+    if (quote) {
+      if (ch === quote) quote = null;
+      current += ch;
+      continue;
+    }
+    if (ch === "\\" && next !== void 0) {
+      current += ch + next;
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    const isSeparator = ch === ";" || ch === "\n" || ch === "\r" || ch === "|" && next === "|" || ch === "&" && command[i - 1] !== ">" && next !== ">";
+    if (isSeparator) {
+      if ((ch === "|" || ch === "&") && next === ch) i++;
+      if (current.trim()) segments.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) segments.push(current.trim());
+  return segments;
+}
+async function checkSingleCommand(command) {
   const normalized = command.replace(/\s+/g, " ").trim();
   const killCmd = extractKillCommand(normalized) || (isKillRelatedCommand(normalized) ? normalized : null);
   if (!killCmd) {
@@ -462,6 +492,8 @@ async function checkAndBlockKillCommand(command) {
     let target;
     if (parsed.name) {
       target = `process name "${parsed.name}"`;
+    } else if (parsed.pids && parsed.pids.length > 1) {
+      target = `PIDs ${parsed.pids.join(", ")}`;
     } else if (parsed.pid !== void 0) {
       target = `PID ${parsed.pid}`;
     } else {
@@ -549,31 +581,15 @@ var bashTool = {
     const registry = getProcessRegistry();
     const bypassBreaker = !!input.background;
     if (!registry.beforeCall(bypassBreaker)) {
-      yield {
-        type: "final",
-        output: {
-          output: "",
-          exit_code: 1,
-          timed_out: false,
-          pid: null,
-          error: "bash: circuit breaker open \u2014 too many consecutive failures or slow calls. Use /kill to inspect or /kill reset to recover."
-        }
-      };
-      return;
+      throw new Error(
+        "bash: circuit breaker open \u2014 too many consecutive failures or slow calls. Use /kill to inspect or /kill reset to recover."
+      );
     }
     const killCheck = await checkAndBlockKillCommand(input.command);
     if (killCheck.blocked) {
-      yield {
-        type: "final",
-        output: {
-          output: "",
-          exit_code: 1,
-          timed_out: false,
-          pid: null,
-          error: killCheck.reason || "Kill command blocked: targets a protected WrongStack process."
-        }
-      };
-      return;
+      throw new Error(
+        `bash: ${killCheck.reason || "Kill command blocked: targets a protected WrongStack process."}`
+      );
     }
     const PIPE_TO_SHELL_PATTERN = /\|\s*(?:sudo\s+)?(sh|bash|ksh|zsh|fish|cmd|powershell|pwsh)(?:\.exe)?\b/i;
     const pipeToShellNote = PIPE_TO_SHELL_PATTERN.test(input.command) ? "\n\n[wrongstack] Caution: this command pipes output into a shell interpreter (pipe-to-shell). Piped content executes as arbitrary code \u2014 review the source before trusting the result, and prefer downloading to a file and inspecting it first." : "";
@@ -654,17 +670,9 @@ var bashTool = {
           timedOut: false,
           endedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
-        yield {
-          type: "final",
-          output: {
-            output: "",
-            exit_code: 1,
-            timed_out: false,
-            pid: null,
-            error: `spawn failed: ${err instanceof Error ? err.message : String(err)}`
-          }
-        };
-        return;
+        throw new Error(`bash: spawn failed: ${err instanceof Error ? err.message : String(err)}`, {
+          cause: err
+        });
       }
       const pid2 = child2.pid;
       const stdoutBytes2 = 0;
@@ -723,17 +731,7 @@ var bashTool = {
       });
       if (typeof pid2 !== "number") {
         completeBackground(1);
-        yield {
-          type: "final",
-          output: {
-            output: "",
-            exit_code: 1,
-            timed_out: false,
-            pid: null,
-            error: "Failed to launch background process: invalid PID"
-          }
-        };
-        return;
+        throw new Error("bash: failed to launch background process: invalid PID");
       }
       child2.unref();
       yield {
@@ -785,17 +783,9 @@ var bashTool = {
         timedOut: false,
         endedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-      yield {
-        type: "final",
-        output: {
-          output: "",
-          exit_code: 1,
-          timed_out: false,
-          pid: null,
-          error: `spawn failed: ${err instanceof Error ? err.message : String(err)}`
-        }
-      };
-      return;
+      throw new Error(`bash: spawn failed: ${err instanceof Error ? err.message : String(err)}`, {
+        cause: err
+      });
     }
     const pid = child.pid;
     let stdoutBytes = 0;
@@ -982,16 +972,6 @@ var bashTool = {
             yield { type: "partial_output", text: remainder };
           }
           const spooled = spool.finalize();
-          yield {
-            type: "final",
-            output: {
-              output: normalizeCommandOutput(buf) + (spooled ? spoolNote(spooled) : "") + pipeToShellNote,
-              exit_code: isAbort ? 124 : 1,
-              timed_out: isAbort,
-              pid: pid ?? null,
-              error: isAbort ? "Command aborted by user or signal" : c.err.message
-            }
-          };
           ctx.recordSideEffect?.({
             toolUseId: `bash-${Date.now()}`,
             toolName: "bash",
@@ -1000,6 +980,19 @@ var bashTool = {
             outcome: isAbort ? "aborted" : `error (${c.err.message})`,
             risk: "shell"
           });
+          if (!isAbort) {
+            throw new Error(`bash: process error: ${c.err.message}`, { cause: c.err });
+          }
+          yield {
+            type: "final",
+            output: {
+              output: normalizeCommandOutput(buf) + (spooled ? spoolNote(spooled) : "") + pipeToShellNote,
+              exit_code: 124,
+              timed_out: true,
+              pid: pid ?? null,
+              error: "Command aborted by user or signal"
+            }
+          };
           return;
         }
         if (c.kind === "end") {
@@ -1093,4 +1086,4 @@ export {
   checkAndBlockKillCommand,
   bashTool
 };
-//# sourceMappingURL=chunk-5KRKL3WD.js.map
+//# sourceMappingURL=chunk-FCSUBTUJ.js.map

package/dist/{chunk-YUK3WLHJ.js → chunk-FVSMTEO3.js}

@@ -1,6 +1,6 @@
 import {
   builtinTools
-} from "./chunk-GNLHBDFO.js";
+} from "./chunk-6I6RXQFG.js";
 
 // src/pack.ts
 var builtinToolsPack = {
@@ -12,4 +12,4 @@ var builtinToolsPack = {
 export {
   builtinToolsPack
 };
-//# sourceMappingURL=chunk-YUK3WLHJ.js.map
+//# sourceMappingURL=chunk-FVSMTEO3.js.map

package/dist/{chunk-SEONDNLN.js → chunk-G7CYW5EP.js}

@@ -1,6 +1,6 @@
 import {
   spawnStream
-} from "./chunk-EMA2XENR.js";
+} from "./chunk-UVYRQKPZ.js";
 import {
   normalizeCommandOutput,
   safeResolveReal
@@ -3515,4 +3515,4 @@ export {
   languagePackageTool,
   languageInfoTool
 };
-//# sourceMappingURL=chunk-SEONDNLN.js.map
+//# sourceMappingURL=chunk-G7CYW5EP.js.map

package/dist/{chunk-TU6UVATU.js → chunk-HYHE4VNA.js}

@@ -13,7 +13,7 @@ import {
   projectIndexServerMetadataPath,
   projectIndexServerStderrPath,
   readProjectIndexServerStderrTail
-} from "./chunk-ZOUG3KKS.js";
+} from "./chunk-XPVYZ2S6.js";
 import {
   CircuitOpenError,
   IndexTimeoutError,
@@ -28,7 +28,7 @@ import {
   searchService,
   statsService,
   symbolGraphService
-} from "./chunk-C4DSQBTT.js";
+} from "./chunk-NEYUPZL6.js";
 import {
   recordIpcPending
 } from "./chunk-ZKC5UNGD.js";
@@ -1352,4 +1352,4 @@ export {
   checkCodebaseIndexServerHealth,
   ensureCodebaseIndexServer
 };
-//# sourceMappingURL=chunk-TU6UVATU.js.map
+//# sourceMappingURL=chunk-HYHE4VNA.js.map

package/dist/{chunk-HIRVCXLP.js → chunk-IE4KDAOB.js}

@@ -1,10 +1,10 @@
 import {
   getIndexState,
   searchCodebaseIndex
-} from "./chunk-TU6UVATU.js";
+} from "./chunk-HYHE4VNA.js";
 import {
   codebaseIndexDirOverride
-} from "./chunk-C4DSQBTT.js";
+} from "./chunk-NEYUPZL6.js";
 import {
   isBinaryBuffer,
   safeResolveReal,
@@ -340,4 +340,4 @@ ${interesting.join("\n")}` : "symbols/imports: (none detected)"
 export {
   readTool
 };
-//# sourceMappingURL=chunk-HIRVCXLP.js.map
+//# sourceMappingURL=chunk-IE4KDAOB.js.map

package/dist/{chunk-YA2ZYCJY.js → chunk-JPK2HHBK.js}

@@ -82,4 +82,4 @@ var toolSearchTool = {
 export {
   toolSearchTool
 };
-//# sourceMappingURL=chunk-YA2ZYCJY.js.map
+//# sourceMappingURL=chunk-JPK2HHBK.js.map

package/dist/{chunk-7E55DAFW.js → chunk-KHUCKLOR.js}

@@ -1,6 +1,6 @@
 import {
   resolvePythonBinary
-} from "./chunk-M2W36JT7.js";
+} from "./chunk-4CE3RKEP.js";
 import {
   parseParserBatchOutput,
   recordParserSubprocess,
@@ -8,7 +8,7 @@ import {
 } from "./chunk-ZKC5UNGD.js";
 import {
   resolveWin32Command
-} from "./chunk-5U5ULQX2.js";
+} from "./chunk-XZLVJD56.js";
 
 // src/codebase-index/import-extractor.ts
 var IMPORT_MAX_FILE_CHARS = 512 * 1024;
@@ -140,6 +140,7 @@ import * as fsSync from "node:fs";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
+import { StringDecoder } from "node:string_decoder";
 var MAX_BATCH_FILES = 100;
 var MAX_BATCH_BYTES = 8 * 1024 * 1024;
 function chunkBatchFiles(files) {
@@ -665,15 +666,19 @@ function runToolchainChild(binary, args, stdinPayload, timeoutMs) {
     }, timeoutMs);
     timer.unref?.();
     proc.on("error", () => finish(null));
+    const stdoutDecoder = new StringDecoder("utf8");
     proc.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
+      stdout += stdoutDecoder.write(chunk);
     });
     proc.stderr?.resume();
     proc.stdin?.on("error", () => {
     });
     proc.stdin?.write(stdinPayload);
     proc.stdin?.end();
-    proc.on("close", (code) => finish({ code, stdout }));
+    proc.on("close", (code) => {
+      stdout += stdoutDecoder.end();
+      finish({ code, stdout });
+    });
   });
 }
 async function runGoBatch(files, goBinary) {
@@ -830,11 +835,11 @@ async function dispatch(file, content, lang) {
       return parseSymbols({ file, content, lang });
     }
     case "go": {
-      const { parseSymbols } = await import("./go-parser-VDPRQEGM.js");
+      const { parseSymbols } = await import("./go-parser-Z4H6SR3R.js");
       return parseSymbols({ file, content, lang: "go" });
     }
     case "py": {
-      const { parseSymbols } = await import("./py-parser-MAW6DHFE.js");
+      const { parseSymbols } = await import("./py-parser-4PFZYAJ7.js");
       return parseSymbols({ file, content, lang: "py" });
     }
     case "rs": {
@@ -891,4 +896,4 @@ export {
   parseFileContent,
   parseFilesContent
 };
-//# sourceMappingURL=chunk-7E55DAFW.js.map
+//# sourceMappingURL=chunk-KHUCKLOR.js.map

package/dist/{chunk-R3HIZVFS.js → chunk-KPDCKSN5.js}

@@ -1,15 +1,17 @@
 import {
   tryLegacyCodeOperation
-} from "./chunk-3LQJXJDM.js";
+} from "./chunk-E7A4SLKR.js";
 import {
   spawnStream
-} from "./chunk-EMA2XENR.js";
+} from "./chunk-UVYRQKPZ.js";
 import {
+  ensureInsideRoot,
   normalizeCommandOutput,
   safeResolveReal
 } from "./chunk-2IAEJRLT.js";
 
 // src/lint.ts
+import * as path from "node:path";
 import { ToolValidationError } from "@wrongstack/core/types";
 var lintTool = {
   name: "lint",
@@ -67,6 +69,11 @@ var lintTool = {
       });
       if (bridge?.run) {
         const run = bridge.run;
+        if (run.status === "unavailable" || run.status === "cancelled" || run.status === "timed_out") {
+          throw new Error(
+            `lint: ${bridge.language} lint did not run (${run.status})${run.error ? `: ${run.error}` : ""}`
+          );
+        }
         yield {
           type: "final",
           output: {
@@ -108,6 +115,16 @@ var lintTool = {
         });
       }
     }
+    for (const f of files) {
+      try {
+        ensureInsideRoot(path.resolve(cwd, f), ctx);
+      } catch (err) {
+        throw new ToolValidationError({
+          message: `lint: file "${f}" ${err.message}`,
+          field: "files"
+        });
+      }
+    }
     const args = [];
     if (detected === "eslint") {
       if (input.fix) args.push("--fix");
@@ -119,6 +136,9 @@ var lintTool = {
     }
     const cmd = detected === "biome" ? "biome" : detected;
     const result = yield* spawnStream({ cmd, args, cwd, signal, maxBytes: 1e5 });
+    if (result.error) {
+      throw new Error(`lint: could not run ${cmd}: ${result.error}`);
+    }
     const combined = `${result.stdout}
 ${result.stderr}`;
     let errors = 0;
@@ -189,4 +209,4 @@ async function detectLinter(cwd) {
 export {
   lintTool
 };
-//# sourceMappingURL=chunk-R3HIZVFS.js.map
+//# sourceMappingURL=chunk-KPDCKSN5.js.map

package/dist/{chunk-B3MGJBFI.js → chunk-KS2OEZWV.js}

@@ -1,6 +1,7 @@
 // src/tool-use.ts
 import {
-  GOVERNED_TOOL_EXECUTOR_META_KEY
+  GOVERNED_TOOL_EXECUTOR_META_KEY,
+  ToolValidationError
 } from "@wrongstack/core/types";
 var toolUseTool = {
   name: "tool_use",
@@ -33,67 +34,42 @@ var toolUseTool = {
   async execute(input, ctx) {
     const start = Date.now();
     if (!input?.tool) {
-      return {
-        tool: "unknown",
-        success: false,
-        error: "tool_use: tool name is required",
-        executionMs: 0
-      };
+      throw new ToolValidationError({ message: "tool_use: tool name is required", field: "tool" });
     }
     const tool = (ctx.catalogTools ?? ctx.tools).find((t) => t.name === input.tool);
     if (!tool) {
-      return {
-        tool: input.tool,
-        success: false,
-        error: `tool_use: tool "${input.tool}" not found`,
-        executionMs: Date.now() - start
-      };
+      throw new ToolValidationError({
+        message: `tool_use: tool "${input.tool}" not found`,
+        field: "tool"
+      });
     }
     if (tool.name === toolUseTool.name) {
-      return {
-        tool: input.tool,
-        success: false,
-        error: "tool_use: recursive meta-tool execution is not allowed",
-        executionMs: Date.now() - start
-      };
+      throw new ToolValidationError({
+        message: "tool_use: recursive meta-tool execution is not allowed",
+        field: "tool"
+      });
     }
     if (tool.permission === "deny") {
-      return {
-        tool: input.tool,
-        success: false,
-        error: `tool_use: tool "${input.tool}" is denied by policy`,
-        executionMs: Date.now() - start
-      };
+      throw new Error(`tool_use: tool "${input.tool}" is denied by policy`);
     }
     const governedExecute = ctx.meta?.[GOVERNED_TOOL_EXECUTOR_META_KEY];
     if (typeof governedExecute !== "function") {
-      return {
-        tool: input.tool,
-        success: false,
-        error: "tool_use: governed nested execution is unavailable; call the tool directly",
-        executionMs: Date.now() - start
-      };
+      throw new Error("tool_use: governed nested execution is unavailable; call the tool directly");
     }
-    try {
-      const result = await governedExecute(input.tool, input.input ?? {});
-      return {
-        tool: input.tool,
-        success: result.success,
-        ...result.success ? { result: result.result } : { error: result.error ?? "nested tool failed" },
-        executionMs: Date.now() - start
-      };
-    } catch (e) {
-      return {
-        tool: input.tool,
-        success: false,
-        error: e instanceof Error ? e.message : String(e),
-        executionMs: Date.now() - start
-      };
+    const result = await governedExecute(input.tool, input.input ?? {});
+    if (!result.success) {
+      throw new Error(`tool_use: "${input.tool}" failed: ${result.error ?? "nested tool failed"}`);
     }
+    return {
+      tool: input.tool,
+      success: true,
+      result: result.result,
+      executionMs: Date.now() - start
+    };
   }
 };
 
 export {
   toolUseTool
 };
-//# sourceMappingURL=chunk-B3MGJBFI.js.map
+//# sourceMappingURL=chunk-KS2OEZWV.js.map

package/dist/{chunk-UI3ZJIG3.js → chunk-LKLIQUCW.js}

@@ -1,4 +1,5 @@
 // src/mode.ts
+import { ToolValidationError } from "@wrongstack/core/types";
 function modeFamily(mode) {
   if (mode.tags?.includes("lite")) return "lite";
   if (mode.tags?.includes("deep")) return "deep";
@@ -63,11 +64,17 @@ function createModeTool(modeStore) {
         }
         case "set": {
           if (!input.mode) {
-            return { action: "set", success: false, message: "mode is required for action=set" };
+            throw new ToolValidationError({
+              message: "mode: mode is required for action=set",
+              field: "mode"
+            });
           }
           const mode = await modeStore.getMode(input.mode);
           if (!mode) {
-            return { action: "set", success: false, message: `Mode "${input.mode}" not found` };
+            throw new ToolValidationError({
+              message: `mode: Mode "${input.mode}" not found \u2014 use action=list to see available modes`,
+              field: "mode"
+            });
           }
           await modeStore.setActiveMode(input.mode);
           return {
@@ -88,11 +95,10 @@ ${mode.description}`
           };
         }
         default:
-          return {
-            action: input.action,
-            success: false,
-            message: `Unknown action "${input.action}"`
-          };
+          throw new ToolValidationError({
+            message: `mode: Unknown action "${input?.action}". Allowed: get, list, set, clear`,
+            field: "action"
+          });
       }
     }
   };
@@ -101,4 +107,4 @@ ${mode.description}`
 export {
   createModeTool
 };
-//# sourceMappingURL=chunk-UI3ZJIG3.js.map
+//# sourceMappingURL=chunk-LKLIQUCW.js.map