@wrongstack/tools 0.319.0 → 0.320.1

package/dist/_edit-match.d.ts

@@ -74,9 +74,7 @@ export declare function adjustIndent(newLf: string, fromIndent: string, toIndent
 };
 /**
  * Best-effort locator for the no-match error: find the window whose trimmed
- * lines are most similar to the needle (cheap common-prefix scoring — this
- * runs on the failure path where the needle by definition doesn't match, so
- * precision matters less than never being slow). Returns the 1-based line
+ * lines are most similar to the needle. Returns the 1-based line
  * and a short snippet the model can use to correct itself without re-reading.
  */
 export declare function nearestMatchHint(fileLf: string, oldLf: string): {

package/dist/_util.d.ts

@@ -92,6 +92,13 @@ export declare function truncateDiffPayload(diff: string, maxBytes: number): {
     text: string;
     truncated: boolean;
 };
+/**
+ * Truncate to `max` UTF-8 bytes keeping BOTH ends, appending a marker that
+ * reports the true omitted byte count. Like `truncateHeadTail` and
+ * `truncateDiffPayload`, marker room is reserved from the budget and both
+ * slices are cut byte-accurately (not by UTF-16 code unit), so the result
+ * never exceeds `max` — the contract `fetchTool`'s `maxOutputBytes` relies on.
+ */
 export declare function truncateMiddle(s: string, max: number): string;
 export declare function isBinaryBuffer(buf: Buffer): boolean;
 /** Unified byte cap for all command tool output fed to the model. */

package/dist/audit.js

@@ -1,14 +1,14 @@
 import {
   auditTool
-} from "./chunk-QZDOQRF7.js";
-import "./chunk-ZDUGI5BC.js";
-import "./chunk-UC3RKRIV.js";
-import "./chunk-ZHH3BEWU.js";
-import "./chunk-2VSZC6QM.js";
-import "./chunk-3PVYQFRQ.js";
+} from "./chunk-UZFY3CKD.js";
+import "./chunk-I7FBZOEP.js";
+import "./chunk-NDIT3SBZ.js";
+import "./chunk-OYP27E3I.js";
+import "./chunk-SCMRM6NL.js";
+import "./chunk-ESLPBT5A.js";
 import "./chunk-HFXSNKCV.js";
-import "./chunk-V43EQ6VR.js";
-import "./chunk-QLF74MSV.js";
+import "./chunk-KE7A76VC.js";
+import "./chunk-ZUFHAHTE.js";
 export {
   auditTool
 };

package/dist/bash.js

@@ -1,13 +1,13 @@
 import {
   bashTool
-} from "./chunk-WNUJR3H4.js";
+} from "./chunk-5UFVCIUB.js";
 import "./chunk-BTSFTGIL.js";
-import "./chunk-NKNOBUBU.js";
-import "./chunk-2VSZC6QM.js";
-import "./chunk-3PVYQFRQ.js";
+import "./chunk-QGF2C7TF.js";
+import "./chunk-SCMRM6NL.js";
+import "./chunk-ESLPBT5A.js";
 import "./chunk-HFXSNKCV.js";
-import "./chunk-V43EQ6VR.js";
-import "./chunk-QLF74MSV.js";
+import "./chunk-KE7A76VC.js";
+import "./chunk-ZUFHAHTE.js";
 export {
   bashTool
 };

package/dist/browser/index.js

@@ -27,7 +27,7 @@ import {
   resolvePinnedBrowserTarget,
   safeBrowserUrl,
   shutdownBrowserTools
-} from "../chunk-45JPRMC2.js";
+} from "../chunk-QWKSKFKZ.js";
 export {
   BrowserArtifactStore,
   BrowserNetworkGuardProxy,

package/dist/builtin.d.ts

@@ -1,4 +1,13 @@
 import type { Tool } from '@wrongstack/core/types';
+/**
+ * Provider-facing descriptions for every built-in tool.
+ *
+ * Keep these decision-oriented: state the primary job, the appropriate time
+ * to use the tool, and any important boundary. This is deliberately kept next
+ * to the canonical catalog so tools discovered lazily receive the same useful
+ * guidance as directly exposed tools.
+ */
+export declare const BUILTIN_TOOL_DESCRIPTIONS: Readonly<Record<string, string>>;
 /**
  * Non-essential tools that can be omitted in token-saving mode to reduce
  * per-request token consumption. Each tool definition adds ~50-200 tokens
@@ -55,5 +64,6 @@ export declare const TIER2_TOOLS: Tool[];
  * tokens while keeping all core capabilities available.
  */
 export declare const TIER3_TOOLS: Tool[];
+/** The executable catalog always exposes the reviewed description above. */
 export declare const builtinTools: Tool[];
 //# sourceMappingURL=builtin.d.ts.map

package/dist/builtin.js

@@ -1,74 +1,76 @@
 import {
+  BUILTIN_TOOL_DESCRIPTIONS,
   OFF_ONLY_TOOLS,
   OPTIONAL_TOOLS,
   TIER1_TOOLS,
   TIER2_TOOLS,
   TIER3_TOOLS,
   builtinTools
-} from "./chunk-VALQFAY2.js";
-import "./chunk-DPKTXJQS.js";
-import "./chunk-RK47IWO3.js";
-import "./chunk-OCUXN6Y3.js";
-import "./chunk-H6AWAZ2Y.js";
-import "./chunk-X5K3U6GI.js";
-import "./chunk-RJZQWEMS.js";
+} from "./chunk-4BABEJC2.js";
+import "./chunk-VPALDFYM.js";
+import "./chunk-LRDIRJJL.js";
+import "./chunk-XRNN44QY.js";
+import "./chunk-B4HTSV6Z.js";
+import "./chunk-3M7LLN7W.js";
+import "./chunk-T77XOX7E.js";
 import "./chunk-FRN7TIAA.js";
 import "./chunk-WXJY3BKV.js";
 import "./chunk-QBV725YG.js";
-import "./chunk-6RNIFLG4.js";
-import "./chunk-Y7QXSE7N.js";
-import "./chunk-4Q7LFU4T.js";
-import "./chunk-QZDOQRF7.js";
-import "./chunk-Z4VBTVUM.js";
-import "./chunk-YZHK4TLF.js";
-import "./chunk-HBM4QNXU.js";
-import "./chunk-2472NT76.js";
-import "./chunk-UMXVT7ST.js";
-import "./chunk-COUNXG4X.js";
-import "./chunk-D4CXUZIF.js";
-import "./chunk-7WV3D4S3.js";
-import "./chunk-HWDB2G7J.js";
-import "./chunk-ZKSBHXVB.js";
-import "./chunk-ODFVG54U.js";
-import "./chunk-VFF3Q5Z3.js";
-import "./chunk-ZDUGI5BC.js";
-import "./chunk-UC3RKRIV.js";
-import "./chunk-ZHH3BEWU.js";
-import "./chunk-OYVPBPCL.js";
-import "./chunk-OJ4FIBAN.js";
-import "./chunk-N5O3FK5Q.js";
+import "./chunk-ELRRTWNP.js";
+import "./chunk-YTKSNTT4.js";
+import "./chunk-WAQASTXB.js";
+import "./chunk-UZFY3CKD.js";
+import "./chunk-DFQDJT22.js";
+import "./chunk-FQNXYA6W.js";
+import "./chunk-IU4DV2PA.js";
+import "./chunk-2OXHS3KZ.js";
+import "./chunk-6AAOT4PW.js";
+import "./chunk-JLYA4X7K.js";
+import "./chunk-VD2LV5WO.js";
+import "./chunk-34VLZ35Z.js";
+import "./chunk-W232EFEM.js";
+import "./chunk-KWXIKGE3.js";
+import "./chunk-J74TMK4M.js";
+import "./chunk-QSNVDHOZ.js";
+import "./chunk-I7FBZOEP.js";
+import "./chunk-NDIT3SBZ.js";
+import "./chunk-OYP27E3I.js";
+import "./chunk-HR67OWEP.js";
+import "./chunk-ZMW6WJFT.js";
+import "./chunk-XSSFBS5I.js";
 import "./chunk-Q5JPPCZC.js";
-import "./chunk-NWZ6XGBJ.js";
-import "./chunk-WNUJR3H4.js";
-import "./chunk-PMHVSHMU.js";
+import "./chunk-ZBMANLYH.js";
+import "./chunk-5UFVCIUB.js";
+import "./chunk-OTPTQBYE.js";
 import "./chunk-BTSFTGIL.js";
-import "./chunk-NKNOBUBU.js";
-import "./chunk-2VSZC6QM.js";
-import "./chunk-3PVYQFRQ.js";
+import "./chunk-QGF2C7TF.js";
+import "./chunk-SCMRM6NL.js";
+import "./chunk-ESLPBT5A.js";
 import "./chunk-HFXSNKCV.js";
-import "./chunk-KD5EHYA2.js";
-import "./chunk-PQTONQ4P.js";
+import "./chunk-C2DQKVLO.js";
+import "./chunk-QPNYDH5B.js";
 import "./chunk-NBDZMMG2.js";
-import "./chunk-5ZYEGP2P.js";
-import "./chunk-FJEQZHZN.js";
-import "./chunk-CWALNI6K.js";
-import "./chunk-45JPRMC2.js";
-import "./chunk-C3W3V54D.js";
-import "./chunk-MYRMD6PZ.js";
-import "./chunk-PRXZOIEW.js";
-import "./chunk-FQZOHLG3.js";
-import "./chunk-MRKWZCHZ.js";
-import "./chunk-W4GAAI3M.js";
-import "./chunk-TFMVHYJI.js";
-import "./chunk-TX3R5NVV.js";
-import "./chunk-IIF5HIVF.js";
+import "./chunk-BK732J7I.js";
+import "./chunk-W2CECGTG.js";
+import "./chunk-X6KXNHUO.js";
+import "./chunk-QWKSKFKZ.js";
+import "./chunk-NSPNFOJ7.js";
+import "./chunk-3GIKYHLA.js";
+import "./chunk-Z6IHMJMC.js";
+import "./chunk-JSNSMG5R.js";
+import "./chunk-Z5Q3TXRY.js";
+import "./chunk-PV6HIZQD.js";
+import "./chunk-J43O3BOX.js";
+import "./chunk-NU2IZ72J.js";
+import "./chunk-VVZPQPTY.js";
 import "./chunk-6IEBD27U.js";
 import "./chunk-UCYQTZ7F.js";
 import "./chunk-YOHO4DVT.js";
 import "./chunk-DTQ75VBC.js";
-import "./chunk-V43EQ6VR.js";
-import "./chunk-QLF74MSV.js";
+import "./chunk-KE7A76VC.js";
+import "./chunk-ZUFHAHTE.js";
 export {
+  BUILTIN_TOOL_DESCRIPTIONS,
   OFF_ONLY_TOOLS,
   OPTIONAL_TOOLS,
   TIER1_TOOLS,

package/dist/{chunk-65EMYN5G.js → chunk-23EX5WDO.js}

@@ -1,10 +1,10 @@
 import {
   builtinToolsPack
-} from "./chunk-SYXW3Y5Z.js";
+} from "./chunk-JVRLTEO7.js";
 import {
   TIER1_TOOLS,
   TIER2_TOOLS
-} from "./chunk-VALQFAY2.js";
+} from "./chunk-4BABEJC2.js";
 
 // src/tool-tier.ts
 function toolNameSet(tools) {
@@ -18,6 +18,7 @@ var BUILTIN_TIER_COUNTS = {
   aggressive: TIER1_TOOLS.length
 };
 function selectBuiltinToolsForTier(tier, allTools) {
+  if (!Array.isArray(allTools)) return [];
   switch (tier) {
     case "off":
       return [...allTools];
@@ -35,6 +36,8 @@ function selectBuiltinToolsForTier(tier, allTools) {
       const tier1Names = toolNameSet(TIER1_TOOLS);
       return allTools.filter((tool) => tier1Names.has(tool.name));
     }
+    default:
+      return [...allTools];
   }
 }
 function registerBuiltinToolTier(options) {
@@ -51,4 +54,4 @@ export {
   selectBuiltinToolsForTier,
   registerBuiltinToolTier
 };
-//# sourceMappingURL=chunk-65EMYN5G.js.map
+//# sourceMappingURL=chunk-23EX5WDO.js.map

package/dist/{chunk-2472NT76.js → chunk-2OXHS3KZ.js}

@@ -1,6 +1,6 @@
 import {
   safeResolveReal
-} from "./chunk-QLF74MSV.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/scaffold.ts
 import * as fs from "node:fs/promises";
@@ -132,13 +132,23 @@ var scaffoldTool = {
     },
     required: ["template", "name"]
   },
-  async execute(input, ctx) {
+  async execute(input, ctx, _opts) {
+    const signal = _opts?.signal ?? ctx?.signal;
+    signal?.throwIfAborted();
     const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
     const name = input.name;
     const vars = { name, ...input.vars };
     const builtIn = BUILT_IN_TEMPLATES[input.template];
     if (builtIn) {
-      return await handleBuiltIn(name, builtIn.files, cwd, ctx, input.dry_run ?? false, vars);
+      return await handleBuiltIn(
+        name,
+        builtIn.files,
+        cwd,
+        ctx,
+        input.dry_run ?? false,
+        vars,
+        signal
+      );
     }
     return {
       template: input.template,
@@ -150,10 +160,11 @@ var scaffoldTool = {
     };
   }
 };
-async function handleBuiltIn(name, templateFiles, cwd, ctx, dryRun, vars) {
+async function handleBuiltIn(name, templateFiles, cwd, ctx, dryRun, vars, signal) {
   const files = [];
   let filesCreated = 0;
   for (const [filePath, content] of Object.entries(templateFiles)) {
+    if (signal?.aborted) break;
     const resolvedPath = substituteVars(filePath, name, vars);
     const joinedPath = path.join(cwd, resolvedPath);
     const root = path.resolve(ctx.projectRoot ?? ctx.cwd ?? process.cwd());
@@ -189,6 +200,7 @@ function substituteVars(content, name, vars) {
   result = result.replace(/\{\{name\}\}/g, () => kebab);
   result = result.replace(/\{\{Name\}\}/g, () => pascal);
   for (const [k, v] of Object.entries(vars)) {
+    if (k === "name" || k === "Name") continue;
     result = result.replace(new RegExp(`\\{\\{${escapeRegexLiteral(k)}\\}\\}`, "g"), () => v);
   }
   return result;
@@ -197,4 +209,4 @@ function substituteVars(content, name, vars) {
 export {
   scaffoldTool
 };
-//# sourceMappingURL=chunk-2472NT76.js.map
+//# sourceMappingURL=chunk-2OXHS3KZ.js.map

package/dist/{chunk-7WV3D4S3.js → chunk-34VLZ35Z.js}

@@ -1,6 +1,9 @@
+import {
+  mapWithConcurrency
+} from "./chunk-ZBMANLYH.js";
 import {
   safeResolveReal
-} from "./chunk-QLF74MSV.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/diff.ts
 import { spawn } from "node:child_process";
@@ -59,6 +62,7 @@ var diffTool = {
   },
   async execute(input, ctx, opts) {
     const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
+    signal.throwIfAborted();
     if (input.a !== void 0 || input.b !== void 0) {
       return await gitDiff(input, ctx, signal);
     }
@@ -66,13 +70,25 @@ var diffTool = {
   }
 };
 async function gitDiff(input, ctx, signal) {
-  if (input.a?.startsWith("-")) {
+  if (input.a !== void 0 && (typeof input.a !== "string" || !input.a.trim())) {
+    throw new ToolValidationError({
+      message: "diff: ref 'a' cannot be empty or whitespace-only",
+      field: "a"
+    });
+  }
+  if (input.b !== void 0 && (typeof input.b !== "string" || !input.b.trim())) {
+    throw new ToolValidationError({
+      message: "diff: ref 'b' cannot be empty or whitespace-only",
+      field: "b"
+    });
+  }
+  if (typeof input.a === "string" && input.a.trim().startsWith("-")) {
     throw new ToolValidationError({
       message: `diff: unsafe ref "${input.a}" \u2014 refs may not begin with '-' (flag injection)`,
       field: "a"
     });
   }
-  if (input.b?.startsWith("-")) {
+  if (typeof input.b === "string" && input.b.trim().startsWith("-")) {
     throw new ToolValidationError({
       message: `diff: unsafe ref "${input.b}" \u2014 refs may not begin with '-' (flag injection)`,
       field: "b"
@@ -82,9 +98,16 @@ async function gitDiff(input, ctx, signal) {
   const statMode = requestedMode === "stat";
   const effectiveMode = statMode ? "stat" : "unified";
   const sideBySideNote = requestedMode === "side-by-side" ? "side-by-side output is not supported; a unified diff was produced instead." : void 0;
-  const gitDir = findGitDir(ctx.cwd);
+  const basePath = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;
+  const gitDir = findGitDir(basePath);
   if (!gitDir) {
-    return { diff: "", files: [], truncated: false, mode: effectiveMode };
+    return {
+      diff: "",
+      files: [],
+      truncated: false,
+      mode: effectiveMode,
+      note: "Not a git repository (or any parent up to root)."
+    };
   }
   const args = ["diff", "--no-color"];
   if (statMode) args.push("--stat");
@@ -93,11 +116,14 @@ async function gitDiff(input, ctx, signal) {
     if (Number.isFinite(contextLines)) args.push(`-U${contextLines}`);
   }
   if (input.staged) args.push("--staged");
-  if (input.a) args.push(input.a);
-  if (input.b) args.push(input.b);
+  if (input.a) args.push(input.a.trim());
+  if (input.b) args.push(input.b.trim());
   if (input.files) {
-    const files = Array.isArray(input.files) ? input.files : input.files.split(",");
-    args.push("--", ...files.map((f) => f.trim()));
+    const rawFiles = Array.isArray(input.files) ? input.files : typeof input.files === "string" ? input.files.split(",") : [];
+    const files = rawFiles.filter((f) => typeof f === "string").map((f) => f.trim().replace(/\\/g, "/")).filter(Boolean);
+    if (files.length > 0) {
+      args.push("--", ...files);
+    }
   }
   const result = await runGit(args, gitDir, signal);
   let diff = result.stdout;
@@ -110,12 +136,14 @@ async function gitDiff(input, ctx, signal) {
 \u2026[git diff truncated: ${result.stdout.length - clipped.length} of ${result.stdout.length} characters omitted]`;
     truncated = true;
   }
+  const exitNote = result.exitCode !== 0 ? `git diff exited with code ${result.exitCode}: ${result.stderr.trim() || "command failed"}` : void 0;
+  const combinedNote = [sideBySideNote, exitNote].filter(Boolean).join("\n") || void 0;
   return {
     diff,
     files: [],
     truncated,
     mode: effectiveMode,
-    note: sideBySideNote
+    note: combinedNote
   };
 }
 function findGitDir(cwd) {
@@ -133,7 +161,10 @@ function findGitDir(cwd) {
   return null;
 }
 function runGit(args, cwd, signal) {
-  return new Promise((resolve) => {
+  if (signal.aborted) {
+    return Promise.resolve({ stdout: "", stderr: "Aborted", exitCode: 124 });
+  }
+  return new Promise((resolve2) => {
     let stdout = "";
     let stderr = "";
     const child = spawn("git", args, {
@@ -149,13 +180,15 @@ function runGit(args, cwd, signal) {
     child.stderr?.on("data", (c) => {
       stderr += c.toString();
     });
-    child.on("close", (code) => resolve({ stdout, stderr, exitCode: code ?? 0 }));
-    child.on("error", (e) => resolve({ stdout: "", stderr: e.message, exitCode: 1 }));
+    child.on("close", (code) => resolve2({ stdout, stderr, exitCode: code ?? 0 }));
+    child.on("error", (e) => resolve2({ stdout: "", stderr: e.message, exitCode: 1 }));
   });
 }
-async function fileDiff(input, ctx, _signal) {
+async function fileDiff(input, ctx, signal) {
+  signal.throwIfAborted();
   void input.context;
-  const files = input.files ? (Array.isArray(input.files) ? input.files : input.files.split(",")).map((f) => f.trim()).filter(Boolean) : [];
+  const rawFiles = Array.isArray(input.files) ? input.files : typeof input.files === "string" ? input.files.split(",") : [];
+  const files = rawFiles.filter((f) => typeof f === "string").map((f) => f.trim()).filter(Boolean);
   if (files.length === 0) {
     return {
       diff: "No files specified",
@@ -164,25 +197,26 @@ async function fileDiff(input, ctx, _signal) {
       mode: "dump"
     };
   }
-  const fileEntries = await Promise.all(
-    files.map(async (file) => {
-      const absPath = await safeResolveReal(file, ctx);
-      const stat2 = await fs.stat(absPath).catch(() => null);
-      if (!stat2?.isFile()) return null;
-      if (stat2.size > MAX_FILE_DUMP_BYTES) {
-        return {
-          truncated: true,
-          output: `--- ${file} (skipped: ${stat2.size} bytes exceeds the ${MAX_FILE_DUMP_BYTES} limit; use the read tool with offset/limit) ---`
-        };
-      }
-      const content = await fs.readFile(absPath, "utf8");
-      const lines = content.split(/\r?\n/);
+  const basePath = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;
+  const fileEntries = await mapWithConcurrency(files, 16, async (file) => {
+    signal.throwIfAborted();
+    const fileToResolve = path.isAbsolute(file) ? file : path.resolve(basePath, file);
+    const absPath = await safeResolveReal(fileToResolve, ctx);
+    const stat2 = await fs.stat(absPath).catch(() => null);
+    if (!stat2?.isFile()) return null;
+    if (stat2.size > MAX_FILE_DUMP_BYTES) {
       return {
-        truncated: false,
-        output: formatWithLineNumbers(file, lines)
+        truncated: true,
+        output: `--- ${file} (skipped: ${stat2.size} bytes exceeds the ${MAX_FILE_DUMP_BYTES} limit; use the read tool with offset/limit) ---`
       };
-    })
-  );
+    }
+    const content = await fs.readFile(absPath, "utf8");
+    const lines = content.split(/\r?\n/);
+    return {
+      truncated: false,
+      output: formatWithLineNumbers(file, lines)
+    };
+  });
   const results = [];
   let truncated = false;
   for (const entry of fileEntries) {
@@ -201,13 +235,18 @@ async function fileDiff(input, ctx, _signal) {
   };
 }
 function formatWithLineNumbers(file, lines) {
-  const width = String(lines.length).length;
-  const numbered = lines.map((line, i) => `${String(i + 1).padStart(width)} | ${line}`).join("\n");
+  const count = lines.length;
+  const width = String(count).length;
+  const parts = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const numStr = String(i + 1).padStart(width, " ");
+    parts[i] = `${numStr} | ${lines[i]}`;
+  }
   return `--- ${file} (line-numbered dump, not a unified diff) ---
-${numbered}`;
+${parts.join("\n")}`;
 }
 
 export {
   diffTool
 };
-//# sourceMappingURL=chunk-7WV3D4S3.js.map
+//# sourceMappingURL=chunk-34VLZ35Z.js.map

package/dist/{chunk-MYRMD6PZ.js → chunk-3GIKYHLA.js}

@@ -1,18 +1,18 @@
 import {
   checkSyntax
-} from "./chunk-FQZOHLG3.js";
+} from "./chunk-JSNSMG5R.js";
 import {
   enqueueReindex
-} from "./chunk-MRKWZCHZ.js";
+} from "./chunk-Z5Q3TXRY.js";
 import {
   safeResolveReal,
   sha256hex,
   truncateDiffPayload
-} from "./chunk-QLF74MSV.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/write.ts
 import * as fs from "node:fs/promises";
-import { ToolValidationError } from "@wrongstack/core/types";
+import { FsError, ToolValidationError } from "@wrongstack/core/types";
 import {
   atomicWrite,
   detectNewlineStyle,
@@ -72,6 +72,15 @@ var writeTool = {
     yield { type: "final", output: await finishWrite(input, ctx, prepared, signal) };
   }
 };
+function countLines(text) {
+  if (!text) return 0;
+  const trimmed = text.endsWith("\n") ? text.slice(0, -1) : text;
+  let count = 1;
+  for (let i = 0; i < trimmed.length; i++) {
+    if (trimmed.charCodeAt(i) === 10) count++;
+  }
+  return count;
+}
 async function writeFile(input, ctx, signal) {
   signal?.throwIfAborted();
   return finishWrite(input, ctx, await prepareWrite(input, ctx), signal);
@@ -94,6 +103,14 @@ async function prepareWrite(input, ctx) {
   let prev = "";
   try {
     const stat2 = await fs.stat(absPath);
+    if (stat2.isDirectory()) {
+      throw new FsError({
+        message: `write: "${input.path}" is an existing directory and cannot be overwritten`,
+        code: "FS_WRITE_FAILED",
+        path: absPath,
+        context: { reason: "is-directory" }
+      });
+    }
     existed = stat2.isFile();
     if (existed) {
       prev = await fs.readFile(absPath, "utf8");
@@ -116,11 +133,13 @@ async function finishWrite(input, ctx, prepared, signal) {
     enqueueReindex({ projectRoot: ctx.projectRoot, files: [prepared.absPath] });
   } catch {
   }
-  const rawDiff = prepared.existed ? unifiedDiff(prepared.prev, content, { fromFile: input.path, toFile: input.path }) : `+++ ${input.path}
-+ (new file, ${content.split("\n").length} lines)`;
+  const isIdentical = prepared.existed && prepared.prev === content;
+  const rawDiff = prepared.existed ? isIdentical ? "(no-op: file content is identical to existing content)" : unifiedDiff(prepared.prev, content, { fromFile: input.path, toFile: input.path }) : `+++ ${input.path}
++ (new file, ${countLines(content)} lines)`;
   const { text: diff, truncated: diffTruncated } = truncateDiffPayload(rawDiff, MAX_DIFF_BYTES);
+  const contentHash = sha256hex(content);
   const stat2 = await fs.stat(prepared.absPath);
-  ctx.recordRead(prepared.absPath, stat2.mtimeMs, "write", sha256hex(content));
+  ctx.recordRead(prepared.absPath, stat2.mtimeMs, "write", contentHash);
   ctx.session?.recordFileChange?.({
     path: prepared.absPath,
     action: prepared.existed ? "modified" : "created",
@@ -134,6 +153,11 @@ async function finishWrite(input, ctx, prepared, signal) {
   ).catch(() => void 0);
   const hasSyntaxErrors = syntax !== void 0 && syntax.errors.length > 0;
   const notes = [];
+  if (isIdentical) {
+    notes.push(
+      "Write completed with no content changes (new content is identical to existing content)."
+    );
+  }
   if (diffTruncated) {
     notes.push("Diff truncated to the 256 KiB output budget \u2014 the full write is on disk.");
   }
@@ -155,4 +179,4 @@ async function finishWrite(input, ctx, prepared, signal) {
 export {
   writeTool
 };
-//# sourceMappingURL=chunk-MYRMD6PZ.js.map
+//# sourceMappingURL=chunk-3GIKYHLA.js.map