@wrongstack/plugins 1.0.7 → 1.0.10

package/dist/semantic-search-indexer/index.d.ts

@@ -30,7 +30,7 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core/types';
+import { type Plugin } from '@wrongstack/core/types';
 interface SemanticSearchConfig {
     enabled: boolean;
     includeExtensions: string[];

package/dist/semantic-search-indexer.js

@@ -1,6 +1,7 @@
 // src/semantic-search-indexer/index.ts
 import * as fs from "node:fs/promises";
 import { isAbsolute, relative, resolve } from "node:path";
+import { ToolValidationError } from "@wrongstack/core/types";
 import { DEFAULT_WALK_IGNORE_DIRS } from "@wrongstack/core/utils";
 var API_VERSION = "^0.1.10";
 var escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -510,16 +511,31 @@ var plugin = {
       icon: "search",
       async execute(input) {
         if (!cfg.enabled) {
-          return { ok: false, error: "semantic-search-indexer is disabled" };
+          throw new Error("semantic-search-indexer is disabled");
         }
         const rawPath = input.path ?? input["directory"] ?? input["dir"] ?? input["SearchDirectory"] ?? input["SearchPath"] ?? input["TargetFile"] ?? input["targetFile"] ?? input["filePath"] ?? input["file"];
         const resolved = resolveProjectPath(typeof rawPath === "string" ? rawPath : void 0);
         if (!resolved) {
-          return { ok: false, error: "path outside project root" };
+          throw new ToolValidationError({ message: "path outside project root", field: "path" });
         }
-        await ensureIndex(resolved, cfg);
         const rawQuery = input.query ?? input["q"] ?? input["text"] ?? input["keyword"] ?? input["keywords"] ?? input["search"] ?? "";
         const query = String(rawQuery);
+        if (tokenize(query, cfg.minTokenLength).length === 0) {
+          throw new ToolValidationError({
+            message: `query must contain at least one keyword of ${cfg.minTokenLength}+ characters`,
+            field: "query"
+          });
+        }
+        try {
+          await fs.stat(resolved);
+        } catch (err) {
+          throw new ToolValidationError({
+            message: `path does not exist or cannot be read: ${typeof rawPath === "string" ? rawPath : resolved}`,
+            field: "path",
+            cause: err
+          });
+        }
+        await ensureIndex(resolved, cfg);
         const limit = typeof input.limit === "number" && input.limit >= 1 ? Math.floor(input.limit) : cfg.defaultLimit;
         const results = runQuery(query, limit, cfg);
         const queryTokens = [...new Set(tokenize(query, cfg.minTokenLength))];

package/dist/semver-bump/index.d.ts

@@ -6,7 +6,7 @@
  * - semver_current: Show the current version from package.json
  * - semver_changelog: Generate a changelog between two versions
  */
-import type { Plugin } from '@wrongstack/core/types';
+import { type Plugin } from '@wrongstack/core/types';
 type BumpType = 'major' | 'minor' | 'patch' | 'auto';
 interface ConventionalCommit {
     hash: string;

package/dist/semver-bump.js

@@ -1,10 +1,26 @@
 // src/semver-bump/index.ts
 import { expectDefined } from "@wrongstack/core/utils";
 import { toErrorMessage } from "@wrongstack/core/utils";
+import { ToolValidationError } from "@wrongstack/core/types";
 import { execFile } from "node:child_process";
 import { access, readFile, readdir, writeFile } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve } from "node:path";
 var API_VERSION = "^0.1.10";
+function requireProjectRoot(rawCwd) {
+  const safeCwd = resolveProjectRoot(rawCwd);
+  if (!safeCwd) {
+    throw new ToolValidationError({
+      message: "cwd must stay within the current project directory",
+      field: "cwd"
+    });
+  }
+  return safeCwd;
+}
+function requireGitRef(field, ref) {
+  if (ref !== void 0 && (typeof ref !== "string" || ref.startsWith("-"))) {
+    throw new ToolValidationError({ message: `${field} is not a valid git ref`, field });
+  }
+}
 function resolveProjectRoot(rawCwd, root = process.cwd()) {
   if (typeof rawCwd !== "string" || rawCwd.length === 0) return root;
   const base = resolve(root);
@@ -250,14 +266,10 @@ var plugin = {
       defaultPart = readDefaultPart(next);
     });
     async function performBump(part, dryRun, cwd) {
-      const safeCwd = resolveProjectRoot(cwd);
-      if (!safeCwd) {
-        return { ok: false, error: "cwd must stay within the current project directory" };
-      }
-      cwd = safeCwd;
+      cwd = requireProjectRoot(cwd);
       const pkg = await getPackageJson(cwd);
       if (!pkg) {
-        return { ok: false, error: "No package.json found" };
+        throw new Error("No package.json found");
       }
       const currentVersion = pkg.version;
       let bumpPart = part;
@@ -272,8 +284,7 @@ var plugin = {
         try {
           commits = await getRecentCommits(lastTag, cwd);
         } catch (err) {
-          const msg = toErrorMessage(err);
-          return { ok: false, error: `Git error: ${msg}`, bumpPart: "patch" };
+          throw new Error(`Git error: ${toErrorMessage(err)}`, { cause: err });
         }
         bumpPart = determineBump(commits);
       } else {
@@ -305,8 +316,7 @@ var plugin = {
         try {
           await runCommand(process.execPath, [bumpScript, "set", newVersion], root);
         } catch (err) {
-          const msg = toErrorMessage(err);
-          return { ok: false, error: `bump script failed: ${msg}` };
+          throw new Error(`bump script failed: ${toErrorMessage(err)}`, { cause: err });
         }
         for (const rel of ["package.json", "package-lock.json", "src/lib/utils.ts", "index.html"]) {
           const p = join(root, "website", rel);
@@ -323,16 +333,15 @@ var plugin = {
           try {
             pkgData = JSON.parse(await readFile(manifest, "utf-8"));
           } catch (err) {
-            return {
-              ok: false,
-              error: `cannot bump: ${manifest} is not readable as JSON (${toErrorMessage(err)}). No manifests were modified.`
-            };
+            throw new Error(
+              `cannot bump: ${manifest} is not readable as JSON (${toErrorMessage(err)}). No manifests were modified.`,
+              { cause: err }
+            );
           }
           if (!pkgData || typeof pkgData !== "object") {
-            return {
-              ok: false,
-              error: `cannot bump: ${manifest} does not contain a JSON object. No manifests were modified.`
-            };
+            throw new Error(
+              `cannot bump: ${manifest} does not contain a JSON object. No manifests were modified.`
+            );
           }
           pkgData.version = newVersion;
           pending.push({ path: manifest, contents: `${JSON.stringify(pkgData, null, 2)}
@@ -342,16 +351,20 @@ var plugin = {
           await writeFile(path, contents, "utf-8");
         }
       }
+      let commitError;
       try {
         await runGit(["add", "--", ...changed], cwd);
         await runGit(["commit", "-m", `chore: bump version to ${newVersion}`], cwd);
-      } catch {
+      } catch (err) {
+        commitError = toErrorMessage(err);
       }
+      let tagError;
       if (autoTag) {
         try {
           const msg = tagMessage.replace("{{version}}", newVersion);
           await runGit(["tag", "-a", `${tagPrefix}${newVersion}`, "-m", msg], cwd);
-        } catch {
+        } catch (err) {
+          tagError = toErrorMessage(err);
         }
       }
       api.log.info("semver-bump: bumped", { from: currentVersion, to: newVersion, bump: bumpPart });
@@ -371,13 +384,22 @@ var plugin = {
         commitCount: commits.length,
         breakingCount: commits.filter((c) => c.breaking).length
       };
+      const tagged = autoTag && tagError === void 0;
+      const warnings = [
+        ...commitError ? [`commit failed: ${commitError}`] : [],
+        ...tagError ? [`tag failed: ${tagError}`] : []
+      ];
       return {
         ok: true,
         currentVersion,
         newVersion,
         bump: bumpPart,
-        tag: `${tagPrefix}${newVersion}`,
-        message: `Bumped ${currentVersion} \u2192 ${newVersion} (${bumpPart})`
+        // Only name the tag when it was actually created.
+        tag: tagged ? `${tagPrefix}${newVersion}` : null,
+        committed: commitError === void 0,
+        tagged,
+        ...warnings.length > 0 ? { warnings } : {},
+        message: `Bumped ${currentVersion} \u2192 ${newVersion} (${bumpPart})` + (warnings.length > 0 ? ` \u2014 ${warnings.join("; ")}` : "")
       };
     }
     api.tools.register({
@@ -463,8 +485,12 @@ var plugin = {
         if (!safeCwd) {
           return { message: "cwd must stay within the current project directory" };
         }
-        const result = await performBump(mode, dry, safeCwd);
-        return { message: String(result["message"] ?? result["error"] ?? JSON.stringify(result)) };
+        try {
+          const result = await performBump(mode, dry, safeCwd);
+          return { message: String(result["message"] ?? JSON.stringify(result)) };
+        } catch (err) {
+          return { message: toErrorMessage(err) };
+        }
       }
     });
     api.tools.register({
@@ -481,11 +507,7 @@ var plugin = {
       async execute(input) {
         state.invocationCount += 1;
         state.perTool["semver_current"] = (state.perTool["semver_current"] ?? 0) + 1;
-        const cwdInput = input["cwd"];
-        const safeCwd = resolveProjectRoot(cwdInput);
-        if (!safeCwd) {
-          return { ok: false, error: "cwd must stay within the current project directory" };
-        }
+        const safeCwd = requireProjectRoot(input["cwd"]);
         const pkg = await getPackageJson(safeCwd);
         const currentVersion = pkg?.version ?? "unknown";
         let latestTag = null;
@@ -531,22 +553,20 @@ var plugin = {
         state.perTool["semver_changelog"] = (state.perTool["semver_changelog"] ?? 0) + 1;
         const from = input["from"];
         const to = input["to"] ?? "HEAD";
-        const cwd = input["cwd"];
-        const safeCwd = resolveProjectRoot(cwd);
-        if (!safeCwd) {
-          return { ok: false, error: "cwd must stay within the current project directory" };
-        }
+        requireGitRef("from", from);
+        requireGitRef("to", to);
+        const safeCwd = requireProjectRoot(input["cwd"]);
         const format = input["format"] ?? "markdown";
-        const range = from ? `${from}..${to}` : to;
+        const rangeArgs = from ? [`${from}..${to}`] : ["-30", to];
         let commits;
         try {
           const output = await runGit(
-            ["log", range === to ? "-30" : range, "--format=%H%x1f%s%x1f%b%x1e"],
+            ["log", ...rangeArgs, "--format=%H%x1f%s%x1f%b%x1e"],
             safeCwd
           );
           commits = parseGitLogOutput(output);
         } catch (err) {
-          return { ok: false, error: `Failed to get git log: ${err}` };
+          throw new Error(`Failed to get git log: ${toErrorMessage(err)}`, { cause: err });
         }
         if (format === "json") {
           return {

package/dist/session-recap.js

@@ -238,8 +238,10 @@ var plugin = {
       const offTool = api.onPattern("tool.*", (eventName, payload) => {
         touchActivity();
         const p = payload;
-        const toolName = p?.tool ?? p?.name ?? eventName;
-        if (typeof toolName === "string") bumpToolCount(toolName);
+        const rawTool = p?.tool;
+        const nameOf = (v) => typeof v === "string" ? v : v && typeof v === "object" && typeof v.name === "string" ? v.name : void 0;
+        const toolName = nameOf(rawTool) ?? nameOf(p?.name) ?? eventName;
+        bumpToolCount(toolName);
         if (toolName === "git_autocommit" || toolName.startsWith("git ")) {
         }
       });

package/dist/shell-check/index.d.ts

@@ -8,7 +8,7 @@
  * via the `directory` + `pattern` parameters. Pass `files` for specific
  * files, or `directory` (optionally with `pattern`) for recursive scanning.
  */
-import type { Plugin } from '@wrongstack/core/types';
+import { type Plugin } from '@wrongstack/core/types';
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/shell-check.js

@@ -1,4 +1,5 @@
 // src/shell-check/index.ts
+import { ToolValidationError } from "@wrongstack/core/types";
 import { execFile } from "node:child_process";
 import { readdir } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve } from "node:path";
@@ -72,8 +73,11 @@ async function runShellCheck(files, severity, cwd) {
         }
       );
     });
-  } catch {
-    return [];
+  } catch (err) {
+    throw new Error(
+      `shellcheck failed without output: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
   }
   if (!raw.trim()) return [];
   try {
@@ -86,22 +90,31 @@ async function runShellCheck(files, severity, cwd) {
       code: item.code,
       message: item.message
     }));
-  } catch {
-    return [];
+  } catch (err) {
+    throw new Error(`shellcheck returned unparseable output: ${raw.trim().slice(0, 500)}`, {
+      cause: err
+    });
   }
 }
-async function findShellFiles(dir, pattern) {
+async function findShellFiles(dir, pattern, isRoot = true) {
   const results = [];
   let entries;
   try {
     entries = await readdir(dir, { withFileTypes: true });
-  } catch {
+  } catch (err) {
+    if (isRoot) {
+      throw new ToolValidationError({
+        message: `directory does not exist or cannot be read: ${dir}`,
+        field: "directory",
+        cause: err
+      });
+    }
     return results;
   }
   for (const entry of entries) {
     const full = join(dir, entry.name);
     if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== ".git") {
-      results.push(...await findShellFiles(full, pattern));
+      results.push(...await findShellFiles(full, pattern, false));
     } else if (entry.isFile() && (entry.name.endsWith(".sh") || entry.name.endsWith(".bash") || entry.name.endsWith(".zsh") || entry.name === "Dockerfile" || entry.name === ".bashrc" || entry.name === ".zshrc")) {
       if (!pattern || entry.name.includes(pattern)) {
         results.push(full);
@@ -171,12 +184,8 @@ var plugin = {
             enum: ["error", "warning", "info", "style"],
             default: "warning",
             description: "Minimum severity level to report"
-          },
-          fix: {
-            type: "boolean",
-            default: false,
-            description: "Apply safe automatic fixes where possible"
           }
+          // `fix` was declared ("apply safe automatic fixes") but never implemented.
         }
       },
       permission: "auto",
@@ -202,22 +211,16 @@ var plugin = {
         state.invocationCount += 1;
         const pathIsSafe = (p) => typeof p === "string" && p.length > 0 && p.length <= MAX_PATH_LEN && withinProject(p);
         if (!pathIsSafe(directory)) {
-          return {
-            ok: false,
-            error: `directory path is outside the project root: ${directory}`,
-            issues: [],
-            filesScanned: 0,
-            rejectedOutsideProject: true
-          };
+          throw new ToolValidationError({
+            message: `directory path is outside the project root: ${directory}`,
+            field: "directory"
+          });
         }
         if (files?.some((f) => !pathIsSafe(f))) {
-          return {
-            ok: false,
-            error: "one or more file paths are outside the project root",
-            issues: [],
-            filesScanned: 0,
-            rejectedOutsideProject: true
-          };
+          throw new ToolValidationError({
+            message: "one or more file paths are outside the project root",
+            field: "files"
+          });
         }
         let checkFiles;
         let scannedDirectories = false;
@@ -243,19 +246,7 @@ var plugin = {
             mode: scannedDirectories ? "directory" : "files"
           };
         }
-        let issues;
-        try {
-          issues = await runShellCheck(checkFiles, severity);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          return {
-            ok: false,
-            error: msg,
-            issues: [],
-            filesScanned: 0,
-            mode: scannedDirectories ? "directory" : "files"
-          };
-        }
+        const issues = await runShellCheck(checkFiles, severity);
         const byFile = {};
         for (const issue of issues) {
           if (byFile[issue.file] === void 0) {

package/dist/smart-rename/index.d.ts

@@ -18,7 +18,7 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core/types';
+import { type Plugin } from '@wrongstack/core/types';
 /** True when `name` is something this tool may safely substitute. */
 export declare function isIdentifier(name: string): boolean;
 declare const plugin: Plugin;

package/dist/smart-rename.js

@@ -1,6 +1,7 @@
 // src/smart-rename/index.ts
 import { readFileSync, writeFileSync } from "node:fs";
 import { extname, isAbsolute, relative, resolve } from "node:path";
+import { ToolValidationError } from "@wrongstack/core/types";
 var NEW_API_VERSION = "^0.1.10";
 var state = {
   renameCount: 0,
@@ -106,32 +107,44 @@ var plugin = {
       mutating: true,
       capabilities: ["fs.write"],
       async execute(input) {
-        if (!cfg.enabled) return { ok: false, error: "smart-rename is disabled" };
+        if (!cfg.enabled) throw new Error("smart-rename is disabled");
         const inp = input ?? {};
         const rawPath = inp["path"] ?? inp["filePath"] ?? inp["file_path"] ?? inp["TargetFile"] ?? inp["targetFile"] ?? inp["file"];
         const oldName = inp["oldName"] ?? inp["old_name"] ?? inp["from"];
         const newName = inp["newName"] ?? inp["new_name"] ?? inp["to"];
         if (!rawPath || typeof rawPath !== "string") {
-          return { ok: false, error: "path is required" };
+          throw new ToolValidationError({ message: "path is required", field: "path" });
         }
         if (!oldName || typeof oldName !== "string" || oldName.length === 0) {
-          return { ok: false, error: "oldName is required" };
+          throw new ToolValidationError({ message: "oldName is required", field: "oldName" });
         }
         if (!newName || typeof newName !== "string" || newName.length === 0) {
-          return { ok: false, error: "newName is required" };
+          throw new ToolValidationError({ message: "newName is required", field: "newName" });
         }
         if (!isIdentifier(oldName)) {
-          return { ok: false, error: `oldName "${oldName}" is not a valid identifier` };
+          throw new ToolValidationError({
+            message: `oldName "${oldName}" is not a valid identifier`,
+            field: "oldName"
+          });
         }
         if (!isIdentifier(newName)) {
-          return { ok: false, error: `newName "${newName}" is not a valid identifier` };
+          throw new ToolValidationError({
+            message: `newName "${newName}" is not a valid identifier`,
+            field: "newName"
+          });
         }
         if (!withinProject(rawPath)) {
-          return { ok: false, error: "path is outside the project root" };
+          throw new ToolValidationError({
+            message: "path is outside the project root",
+            field: "path"
+          });
         }
         const ext = extname(rawPath).toLowerCase();
         if (!cfg.extensions.includes(ext)) {
-          return { ok: false, error: `extension ${ext} is not allowed for rename` };
+          throw new ToolValidationError({
+            message: `extension ${ext} is not allowed for rename`,
+            field: "path"
+          });
         }
         const resolved = resolve(process.cwd(), rawPath);
         let content;
@@ -139,7 +152,7 @@ var plugin = {
           content = readFileSync(resolved, "utf-8");
         } catch (err) {
           state.errorCount += 1;
-          return { ok: false, error: String(err) };
+          throw new Error(`Could not read ${rawPath}: ${String(err)}`, { cause: err });
         }
         const { preview, replacements } = renameInContent(content, oldName, newName);
         state.renameCount += 1;
@@ -152,7 +165,7 @@ var plugin = {
             writeFileSync(resolved, preview, "utf-8");
           } catch (err) {
             state.errorCount += 1;
-            return { ok: false, error: String(err) };
+            throw new Error(`Could not write ${rawPath}: ${String(err)}`, { cause: err });
           }
         }
         return {

package/dist/template-engine/index.d.ts

@@ -7,7 +7,7 @@
  * - template_create: Save a named template to the plugin store
  * - template_list: List all saved templates
  */
-import type { Plugin } from '@wrongstack/core/types';
+import { type Plugin } from '@wrongstack/core/types';
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/template-engine.js

@@ -15,6 +15,7 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 // src/template-engine/index.ts
 import { readFile, writeFile } from "node:fs/promises";
 import { isAbsolute } from "node:path";
+import { ToolValidationError } from "@wrongstack/core/types";
 
 // src/runtime/index.ts
 var runtime_exports = {};
@@ -183,24 +184,26 @@ var plugin = {
         const output_path = typeof rawOutputPath === "string" && rawOutputPath.trim().length > 0 ? rawOutputPath.trim() : void 0;
         const raw = input["raw"] ?? false;
         if (!template || typeof template !== "string") {
-          return { ok: false, error: "template is required and must be a string" };
+          throw new ToolValidationError({
+            message: "template is required and must be a string",
+            field: "template"
+          });
         }
         if (!variables || typeof variables !== "object") {
-          return { ok: false, error: "variables is required and must be an object" };
-        }
-        let result;
-        try {
-          result = raw ? renderTemplateRaw(template, variables) : renderTemplate(template, variables, autoEscapeHtml);
-        } catch (err) {
-          return { ok: false, error: String(err) };
+          throw new ToolValidationError({
+            message: "variables is required and must be an object",
+            field: "variables"
+          });
         }
+        const result = raw ? renderTemplateRaw(template, variables) : renderTemplate(template, variables, autoEscapeHtml);
         if (output_path) {
           const pathError = validateWritableTemplateTarget("output_path", output_path);
-          if (pathError) return { ok: false, error: pathError };
+          if (pathError)
+            throw new ToolValidationError({ message: pathError, field: "output_path" });
           try {
             await writeFile(output_path, result, "utf-8");
           } catch (err) {
-            return { ok: false, error: `Could not write ${output_path}: ${String(err)}` };
+            throw new Error(`Could not write ${output_path}: ${String(err)}`, { cause: err });
           }
           return {
             ok: true,
@@ -251,32 +254,36 @@ var plugin = {
         const output_path = typeof rawOutputPath === "string" && rawOutputPath.trim().length > 0 ? rawOutputPath.trim() : void 0;
         const raw = input["raw"] ?? false;
         if (!template_path || typeof template_path !== "string") {
-          return { ok: false, error: "template_path is required and must be a string" };
+          throw new ToolValidationError({
+            message: "template_path is required and must be a string",
+            field: "template_path"
+          });
         }
         const templatePathError = validateRelativeTemplatePath("template_path", template_path);
-        if (templatePathError) return { ok: false, error: templatePathError };
+        if (templatePathError) {
+          throw new ToolValidationError({ message: templatePathError, field: "template_path" });
+        }
         if (!variables || typeof variables !== "object") {
-          return { ok: false, error: "variables is required and must be an object" };
+          throw new ToolValidationError({
+            message: "variables is required and must be an object",
+            field: "variables"
+          });
         }
         let content;
         try {
           content = await readFile(template_path, "utf-8");
         } catch (err) {
-          return { ok: false, error: `Could not read template file: ${err}` };
-        }
-        let result;
-        try {
-          result = raw ? renderTemplateRaw(content, variables) : renderTemplate(content, variables, autoEscapeHtml);
-        } catch (err) {
-          return { ok: false, error: `Template rendering failed: ${err}` };
+          throw new Error(`Could not read template file: ${String(err)}`, { cause: err });
         }
+        const result = raw ? renderTemplateRaw(content, variables) : renderTemplate(content, variables, autoEscapeHtml);
         if (output_path) {
           const pathError = validateWritableTemplateTarget("output_path", output_path);
-          if (pathError) return { ok: false, error: pathError };
+          if (pathError)
+            throw new ToolValidationError({ message: pathError, field: "output_path" });
           try {
             await writeFile(output_path, result, "utf-8");
           } catch (err) {
-            return { ok: false, error: `Could not write ${output_path}: ${String(err)}` };
+            throw new Error(`Could not write ${output_path}: ${String(err)}`, { cause: err });
           }
           return {
             ok: true,
@@ -327,30 +334,39 @@ var plugin = {
         const rawDesc = input["description"] ?? input["desc"] ?? input["summary"];
         const description = typeof rawDesc === "string" ? rawDesc : void 0;
         if (!name || typeof name !== "string" || name.trim() === "") {
-          return { ok: false, error: "name is required and must be a non-empty string" };
+          throw new ToolValidationError({
+            message: "name is required and must be a non-empty string",
+            field: "name"
+          });
         }
         if (!content || typeof content !== "string") {
-          return { ok: false, error: "content is required and must be a string" };
+          throw new ToolValidationError({
+            message: "content is required and must be a string",
+            field: "content"
+          });
         }
         if (name.length > MAX_TEMPLATE_NAME_CHARS) {
-          return { ok: false, error: `name exceeds ${MAX_TEMPLATE_NAME_CHARS} characters` };
+          throw new ToolValidationError({
+            message: `name exceeds ${MAX_TEMPLATE_NAME_CHARS} characters`,
+            field: "name"
+          });
         }
         if (content.length > MAX_TEMPLATE_CONTENT_CHARS) {
-          return {
-            ok: false,
-            error: `content exceeds ${MAX_TEMPLATE_CONTENT_CHARS} characters`
-          };
+          throw new ToolValidationError({
+            message: `content exceeds ${MAX_TEMPLATE_CONTENT_CHARS} characters`,
+            field: "content"
+          });
         }
         if (description && description.length > MAX_TEMPLATE_DESCRIPTION_CHARS) {
-          return {
-            ok: false,
-            error: `description exceeds ${MAX_TEMPLATE_DESCRIPTION_CHARS} characters`
-          };
+          throw new ToolValidationError({
+            message: `description exceeds ${MAX_TEMPLATE_DESCRIPTION_CHARS} characters`,
+            field: "description"
+          });
         }
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const existing = templates.get(name);
         if (!existing && templates.size >= MAX_TEMPLATES) {
-          return { ok: false, error: `template limit reached (${MAX_TEMPLATES})` };
+          throw new Error(`template limit reached (${MAX_TEMPLATES})`);
         }
         const tmpl = {
           name,
@@ -363,10 +379,7 @@ var plugin = {
         for (const stored of templates.values()) retainedChars += templateChars(stored);
         const nextChars = retainedChars - (existing ? templateChars(existing) : 0) + templateChars(tmpl);
         if (nextChars > MAX_TOTAL_TEMPLATE_CHARS) {
-          return {
-            ok: false,
-            error: `template store exceeds ${MAX_TOTAL_TEMPLATE_CHARS} retained characters`
-          };
+          throw new Error(`template store exceeds ${MAX_TOTAL_TEMPLATE_CHARS} retained characters`);
         }
         templates.set(name, tmpl);
         api.metrics.gauge("template_count", templates.size);