@wrongstack/tools 0.296.4 → 0.298.0

package/dist/tool-use.d.ts

@@ -1,4 +1,4 @@
-import type { Tool } from '@wrongstack/core/types';
+import { type Tool } from '@wrongstack/core/types';
 interface ToolUseInput {
     tool: string;
     input: Record<string, unknown>;

package/dist/tool-use.js

@@ -1,10 +1,17 @@
 // src/tool-use.ts
+import {
+  GOVERNED_TOOL_EXECUTOR_META_KEY
+} from "@wrongstack/core/types";
 var toolUseTool = {
   name: "tool_use",
   category: "Meta",
   description: "Directly execute any registered tool by its exact name, bypassing normal discovery. This is a powerful meta-tool intended for cases where the agent has a clear plan and knows precisely which tool to invoke.",
   usageHint: "ADVANCED META TOOL \u2014 USE WITH CARE:\n\n- Only use when you are certain of the exact tool name and its expected input shape.\n- Prefer using the normal tool calling mechanism when possible.\n- Very useful in batch-tool-use or when orchestrating complex workflows programmatically.\n- The call still goes through full permission checks and capability validation.",
   permission: "confirm",
+  // WS-046: gives permission decisions something to key on.
+  // The tool being invoked through this indirection — the whole point of a
+  // permission decision here is WHICH tool is being reached.
+  subjectKey: "tool",
   mutating: true,
   timeoutMs: 6e4,
   capabilities: ["tool.mutate.any"],
@@ -23,7 +30,7 @@ var toolUseTool = {
     },
     required: ["tool"]
   },
-  async execute(input, ctx, opts) {
+  async execute(input, ctx) {
     const start = Date.now();
     if (!input?.tool) {
       return {
@@ -42,6 +49,14 @@ var toolUseTool = {
         executionMs: Date.now() - start
       };
     }
+    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
+      };
+    }
     if (tool.permission === "deny") {
       return {
         tool: input.tool,
@@ -50,12 +65,21 @@ var toolUseTool = {
         executionMs: Date.now() - start
       };
     }
+    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
+      };
+    }
     try {
-      const result = await tool.execute(input.input, ctx, opts);
+      const result = await governedExecute(input.tool, input.input ?? {});
       return {
         tool: input.tool,
-        success: true,
-        result,
+        success: result.success,
+        ...result.success ? { result: result.result } : { error: result.error ?? "nested tool failed" },
         executionMs: Date.now() - start
       };
     } catch (e) {

package/dist/tree.d.ts

@@ -7,6 +7,7 @@ interface TreeInput {
     show_files?: boolean | undefined;
     show_dirs?: boolean | undefined;
     show_hidden?: boolean | undefined;
+    max_entries?: number | undefined;
 }
 interface TreeOutput {
     tree: string;

package/dist/tree.js

@@ -1,7 +1,7 @@
 // src/tree.ts
-import { DEFAULT_WALK_IGNORE_DIRS, expectDefined } from "@wrongstack/core/utils";
 import * as fs from "node:fs/promises";
 import * as path2 from "node:path";
+import { DEFAULT_WALK_IGNORE_DIRS, expectDefined } from "@wrongstack/core/utils";
 
 // src/_util.ts
 import * as path from "node:path";
@@ -30,6 +30,8 @@ function safeResolve(input, ctx) {
 
 // src/tree.ts
 var DEFAULT_IGNORE = [...DEFAULT_WALK_IGNORE_DIRS, ".wrongstack", ".ssh", ".gnupg", ".aws"];
+var DEFAULT_MAX_ENTRIES = 5e3;
+var MAX_TREE_OUTPUT_BYTES = 256 * 1024;
 var treeTool = {
   name: "tree",
   category: "Filesystem",
@@ -73,6 +75,12 @@ var treeTool = {
       show_hidden: {
         type: "boolean",
         description: "Show hidden files starting with . (default: false)"
+      },
+      max_entries: {
+        type: "integer",
+        description: `Maximum entries retained in the rendered tree (default ${DEFAULT_MAX_ENTRIES}).`,
+        minimum: 1,
+        maximum: 5e4
       }
     }
   },
@@ -86,7 +94,7 @@ var treeTool = {
     if (!final) throw new Error("tree: stream ended without final event");
     return final;
   },
-  async *executeStream(input, ctx) {
+  async *executeStream(input, ctx, opts) {
     const basePath = input.path ? safeResolve(input.path, ctx) : ctx.cwd;
     const maxDepth = input.depth ?? 3;
     const showFiles = input.show_files ?? true;
@@ -94,8 +102,17 @@ var treeTool = {
     const showHidden = input.show_hidden ?? false;
     const exclude = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...input.exclude ?? []]);
     const filterGlob = input.glob;
+    const maxEntries = input.max_entries ?? DEFAULT_MAX_ENTRIES;
+    const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
     const lines = [basePath];
     const totals = { totalFiles: { value: 0 }, totalDirs: { value: 0 } };
+    const retention = {
+      entries: 0,
+      outputBytes: Buffer.byteLength(basePath, "utf8"),
+      maxEntries,
+      maxOutputBytes: MAX_TREE_OUTPUT_BYTES,
+      truncated: false
+    };
     const queue = [];
     const FLUSH_EVERY = 200;
     let lastEmittedTotal = 0;
@@ -122,12 +139,19 @@ var treeTool = {
       isLast: true,
       totalFiles: totals.totalFiles,
       totalDirs: totals.totalDirs,
-      onProgress: tickProgress
+      onProgress: tickProgress,
+      retention,
+      signal
     });
     let walkDone = false;
-    walkPromise.finally(() => {
-      walkDone = true;
-    });
+    void walkPromise.then(
+      () => {
+        walkDone = true;
+      },
+      () => {
+        walkDone = true;
+      }
+    );
     while (!walkDone || queue.length > 0) {
       if (queue.length > 0) {
         yield expectDefined(queue.shift());
@@ -150,13 +174,15 @@ var treeTool = {
         tree: lines.join("\n"),
         total_files: totals.totalFiles.value,
         total_dirs: totals.totalDirs.value,
-        truncated: false,
+        truncated: retention.truncated,
         path: basePath
       }
     };
   }
 };
 async function walkDir(dir, depth, opts) {
+  opts.signal.throwIfAborted();
+  if (opts.retention.truncated) return;
   const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
   const filtered = entries.filter((e) => {
     if (!opts.showHidden && e.name.startsWith(".")) return false;
@@ -176,6 +202,8 @@ async function walkDir(dir, depth, opts) {
     return a.name.localeCompare(b.name);
   });
   for (let i = 0; i < items.length; i++) {
+    opts.signal.throwIfAborted();
+    if (opts.retention.truncated) return;
     const entry = items[i];
     if (!entry) continue;
     const isLast = i === items.length - 1;
@@ -184,7 +212,15 @@ async function walkDir(dir, depth, opts) {
     const displayName = entry.name + (entry.isDirectory() ? "/" : "");
     if (!opts.showDirs && entry.isDirectory()) continue;
     if (!opts.showFiles && entry.isFile()) continue;
-    opts.lines.push(opts.prefix + branch + displayName);
+    const line = opts.prefix + branch + displayName;
+    const lineBytes = Buffer.byteLength(line, "utf8") + 1;
+    if (opts.retention.entries >= opts.retention.maxEntries || opts.retention.outputBytes + lineBytes > opts.retention.maxOutputBytes) {
+      opts.retention.truncated = true;
+      return;
+    }
+    opts.lines.push(line);
+    opts.retention.entries++;
+    opts.retention.outputBytes += lineBytes;
     if (entry.isDirectory() && (opts.maxDepth === 0 || depth < opts.maxDepth)) {
       const childPrefix = opts.prefix + connector;
       await walkDir(path2.join(dir, entry.name), depth + 1, {

package/dist/typecheck.js

@@ -81,11 +81,12 @@ function createOutputSpool(opts) {
   return {
     write(text) {
       if (finalized || !text) return;
-      totalBytes += Buffer.byteLength(text, "utf8");
+      const textBytes = Buffer.byteLength(text, "utf8");
+      totalBytes += textBytes;
       if (!stream && !failed) {
-        if (headBytes + text.length <= threshold) {
+        if (headBytes + textBytes <= threshold) {
           head += text;
-          headBytes += text.length;
+          headBytes += textBytes;
           return;
         }
         head += text;
@@ -95,7 +96,7 @@ function createOutputSpool(opts) {
       }
       if (stream) {
         if (stream.writableLength > SPOOL_WRITE_HWM_BYTES) {
-          droppedBytes += Buffer.byteLength(text, "utf8");
+          droppedBytes += textBytes;
           return;
         }
         stream.write(text);
@@ -117,6 +118,52 @@ function createOutputSpool(opts) {
   };
 }
 
+// src/_win32-resolve.ts
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+function resolveWin32Command(cmd) {
+  if (process.platform !== "win32") return cmd;
+  if (cmd.includes("/") || cmd.includes("\\") || path2.extname(cmd.replace(/\//g, "\\"))) {
+    return cmd;
+  }
+  const pathext = (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD;.VBS;.JS;.WS;.MSC").toLowerCase().split(";");
+  const pathDirs = (process.env["PATH"] ?? "").split(path2.delimiter);
+  for (const dir of pathDirs) {
+    const base = path2.join(dir, cmd);
+    for (const ext of pathext) {
+      const full = `${base}${ext}`;
+      try {
+        fs.accessSync(full, fs.constants.X_OK);
+        return full;
+      } catch {
+      }
+    }
+  }
+  return cmd;
+}
+var WIN32_SHELL_META = /[&|<>"\r\n\0]/;
+function assertSafeWin32ShellArgs(args) {
+  for (const arg of args) {
+    if (typeof arg === "string" && WIN32_SHELL_META.test(arg)) {
+      throw new Error(
+        'win32 cmd shim spawn: argument contains a shell metacharacter (one of & | < > ", or a newline) that could enable command injection through the .cmd/.bat wrapper - refusing to run. Offending argument: ' + JSON.stringify(arg)
+      );
+    }
+  }
+}
+function buildWin32CmdShimInvocation(command, args = []) {
+  assertSafeWin32ShellArgs([command, ...args]);
+  const line = ["call", quoteWin32CmdArg(command), ...args.map(quoteWin32CmdArg)].join(" ");
+  return {
+    command: process.env["COMSPEC"] ?? "cmd.exe",
+    args: ["/d", "/c", line],
+    windowsVerbatimArguments: true
+  };
+}
+function quoteWin32CmdArg(arg) {
+  return `"${arg}"`;
+}
+
 // src/process-registry.ts
 import { spawn } from "node:child_process";
 import * as os from "node:os";
@@ -448,6 +495,7 @@ var ProcessRegistryImpl = class {
   }
   /** Get all tracked processes. */
   list() {
+    this._pruneAllStale();
     return Array.from(this.processes.values());
   }
   /** Get processes filtered by name (e.g. 'bash', 'exec'). */
@@ -478,6 +526,7 @@ var ProcessRegistryImpl = class {
    * Combined stats for observability — used by /ps and the TUI status bar.
    */
   stats() {
+    this._pruneAllStale();
     return {
       activeCount: this.activeCount,
       backgroundCount: this.activeBackgroundCount,
@@ -717,6 +766,19 @@ var ProcessRegistryImpl = class {
       this.processes.delete(pid);
     }
   }
+  /**
+   * Remove every stale entry, not just one PID. `list()`/`stats()` — the
+   * surfaces the TUI status bar and `/ps` poll — must prune too: a child
+   * whose 'close' event never fires (e.g. Windows grandchildren holding stdio
+   * open) would otherwise linger in the registry until someone looks up its
+   * exact PID, and PID reuse meanwhile makes `get()`/`kill()` target the
+   * wrong process. RAM-leak audit 2026-07-31, MEDIUM.
+   */
+  _pruneAllStale() {
+    for (const [pid, entry] of this.processes) {
+      if (this._isStaleEntry(entry)) this.processes.delete(pid);
+    }
+  }
 };
 var _registry;
 function getProcessRegistry() {
@@ -726,60 +788,17 @@ function getProcessRegistry() {
   return _registry;
 }
 
-// src/_win32-resolve.ts
-import * as fs from "node:fs";
-import * as path2 from "node:path";
-function resolveWin32Command(cmd) {
-  if (process.platform !== "win32") return cmd;
-  if (cmd.includes("/") || cmd.includes("\\") || path2.extname(cmd.replace(/\//g, "\\"))) {
-    return cmd;
-  }
-  const pathext = (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD;.VBS;.JS;.WS;.MSC").toLowerCase().split(";");
-  const pathDirs = (process.env["PATH"] ?? "").split(path2.delimiter);
-  for (const dir of pathDirs) {
-    const base = path2.join(dir, cmd);
-    for (const ext of pathext) {
-      const full = `${base}${ext}`;
-      try {
-        fs.accessSync(full, fs.constants.X_OK);
-        return full;
-      } catch {
-      }
-    }
-  }
-  return cmd;
-}
-var WIN32_SHELL_META = /[&|<>"\r\n\0]/;
-function assertSafeWin32ShellArgs(args) {
-  for (const arg of args) {
-    if (typeof arg === "string" && WIN32_SHELL_META.test(arg)) {
-      throw new Error(
-        'win32 cmd shim spawn: argument contains a shell metacharacter (one of & | < > ", or a newline) that could enable command injection through the .cmd/.bat wrapper - refusing to run. Offending argument: ' + JSON.stringify(arg)
-      );
-    }
-  }
-}
-function buildWin32CmdShimInvocation(command, args = []) {
-  assertSafeWin32ShellArgs([command, ...args]);
-  const line = ["call", quoteWin32CmdArg(command), ...args.map(quoteWin32CmdArg)].join(" ");
-  return {
-    command: process.env["COMSPEC"] ?? "cmd.exe",
-    args: ["/d", "/c", line],
-    windowsVerbatimArguments: true
-  };
-}
-function quoteWin32CmdArg(arg) {
-  return `"${arg}"`;
-}
-
 // src/_spawn-stream.ts
 var isWin = process.platform === "win32";
 async function* spawnStream(opts) {
   const max = opts.maxBytes ?? 2e5;
   const flushAt = opts.flushBytes ?? 4 * 1024;
   const maxQueue = opts.maxQueueSize ?? 500;
+  const maxQueueBytes = opts.maxQueueBytes ?? 1024 * 1024;
   let stdout = "";
   let stderr = "";
+  let stdoutRetainedBytes = 0;
+  let stderrRetainedBytes = 0;
   let pending = "";
   let error;
   const spool = createOutputSpool({ tool: opts.cmd, thresholdBytes: max });
@@ -821,6 +840,7 @@ async function* spawnStream(opts) {
     });
   }
   const queue = [];
+  let queuedBytes = 0;
   let waiter;
   let paused = false;
   const wake = () => {
@@ -831,7 +851,7 @@ async function* spawnStream(opts) {
     }
   };
   const resume = () => {
-    if (paused && queue.length < maxQueue) {
+    if (paused && queue.length <= Math.floor(maxQueue / 2) && queuedBytes <= Math.floor(maxQueueBytes / 2)) {
       paused = false;
       child.stdout?.resume();
       child.stderr?.resume();
@@ -841,11 +861,16 @@ async function* spawnStream(opts) {
     const s = c.toString();
     stdoutBytes += c.byteLength;
     emitProcessOutput({ pid, stream: "stdout", chunk: c });
-    if (stdout.length < max) stdout += s;
+    if (stdoutRetainedBytes < max) {
+      const retained = utf8Prefix(s, max - stdoutRetainedBytes);
+      stdout += retained;
+      stdoutRetainedBytes += Buffer.byteLength(retained, "utf8");
+    }
     spool.write(s);
-    queue.push({ kind: "out", data: s });
+    queue.push({ kind: "out", data: s, bytes: c.byteLength });
+    queuedBytes += c.byteLength;
     wake();
-    if (!paused && queue.length >= maxQueue) {
+    if (!paused && (queue.length >= maxQueue || queuedBytes >= maxQueueBytes)) {
       paused = true;
       child.stdout?.pause();
       child.stderr?.pause();
@@ -855,11 +880,16 @@ async function* spawnStream(opts) {
     const s = c.toString();
     stderrBytes += c.byteLength;
     emitProcessOutput({ pid, stream: "stderr", chunk: c });
-    if (stderr.length < max) stderr += s;
+    if (stderrRetainedBytes < max) {
+      const retained = utf8Prefix(s, max - stderrRetainedBytes);
+      stderr += retained;
+      stderrRetainedBytes += Buffer.byteLength(retained, "utf8");
+    }
     spool.write(s);
-    queue.push({ kind: "err", data: s });
+    queue.push({ kind: "err", data: s, bytes: c.byteLength });
+    queuedBytes += c.byteLength;
     wake();
-    if (!paused && queue.length >= maxQueue) {
+    if (!paused && (queue.length >= maxQueue || queuedBytes >= maxQueueBytes)) {
       paused = true;
       child.stdout?.pause();
       child.stderr?.pause();
@@ -869,7 +899,9 @@ async function* spawnStream(opts) {
   child.stderr?.on("data", onErr);
   child.on("error", (e) => {
     error = e.message;
-    queue.push({ kind: "error", data: e.message });
+    const bytes = Buffer.byteLength(e.message, "utf8");
+    queue.push({ kind: "error", data: e.message, bytes });
+    queuedBytes += bytes;
     wake();
   });
   const completeTelemetry = (code, signal, timedOut = false) => {
@@ -890,7 +922,13 @@ async function* spawnStream(opts) {
     if (typeof pid === "number") registry.unregister(pid);
     const exitCode2 = code ?? (signal ? 1 : 0);
     completeTelemetry(exitCode2, signal ?? void 0);
-    queue.push({ kind: "close", data: "", code: exitCode2, ...signal ? { signal } : {} });
+    queue.push({
+      kind: "close",
+      data: "",
+      bytes: 0,
+      code: exitCode2,
+      ...signal ? { signal } : {}
+    });
     wake();
   });
   const onAbort = () => {
@@ -902,7 +940,7 @@ async function* spawnStream(opts) {
       } catch {
       }
     }
-    queue.push({ kind: "close", data: "", code: 124 });
+    queue.push({ kind: "close", data: "", bytes: 0, code: 124 });
     completeTelemetry(124, "SIGKILL", true);
     wake();
   };
@@ -920,6 +958,7 @@ async function* spawnStream(opts) {
         });
       }
       const chunk = queue.shift();
+      queuedBytes -= chunk.bytes;
       resume();
       if (chunk.kind === "close") {
         if (!spawnFailed) exitCode = chunk.code ?? 0;
@@ -946,7 +985,7 @@ async function* spawnStream(opts) {
       stdout: spooled ? stdout + spoolNote(spooled) : stdout,
       stderr,
       exitCode,
-      truncated: stdout.length >= max || stderr.length >= max,
+      truncated: stdoutBytes > stdoutRetainedBytes || stderrBytes > stderrRetainedBytes,
       error,
       spoolPath: spooled?.path,
       spoolBytes: spooled?.bytes
@@ -970,6 +1009,20 @@ async function* spawnStream(opts) {
     }
   }
 }
+function utf8Prefix(text, maxBytes) {
+  if (maxBytes <= 0) return "";
+  if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(text.slice(0, mid), "utf8") <= maxBytes) low = mid;
+    else high = mid - 1;
+  }
+  let end = low;
+  if (end > 0 && /[\uD800-\uDBFF]/.test(text[end - 1])) end--;
+  return text.slice(0, end);
+}
 
 // src/_util.ts
 import * as path3 from "node:path";
@@ -2537,8 +2590,8 @@ async function scanDirectory(directory, depth, profiles, limits, state, extraIgn
     collectFileEvidence(directory, fullPath, entry.name, profiles, state);
   }
 }
-function collectFileEvidence(directory, fullPath, basename4, profiles, state) {
-  const lower = basename4.toLowerCase();
+function collectFileEvidence(directory, fullPath, basename5, profiles, state) {
+  const lower = basename5.toLowerCase();
   const extension = path4.extname(lower);
   for (const profile of profiles) {
     const detector = profile.detectors.find(
@@ -2549,7 +2602,7 @@ function collectFileEvidence(directory, fullPath, basename4, profiles, state) {
       candidate.evidence.push({
         kind: detector.kind,
         path: fullPath,
-        value: basename4,
+        value: basename5,
         weight: detector.weight
       });
       if (detector.kind === "manifest" || detector.kind === "config") {
@@ -2969,10 +3022,11 @@ var MAX_ARGUMENTS = 128;
 var MAX_ARGUMENT_LENGTH = 4096;
 var PACKAGE_NAME_RE = /^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+(?:@[a-z0-9*+._~^<>=|-]+)?$/i;
 var COMPOSER_PACKAGE_RE = /^[a-z0-9_.-]+\/[a-z0-9_.-]+(?::[a-z0-9*+._~^<>=|-]+)?$/i;
-var GO_MODULE_RE = /^(?:[a-z0-9.-]+\.)+[a-z0-9.-]+\/[a-z0-9._~+/@-]+$/i;
+var GO_MODULE_RE = /^(?:[a-z0-9-]+\.)+[a-z0-9-]+\/[a-z0-9._~+/@-]+$/i;
 var PYTHON_PACKAGE_RE = /^[a-z0-9._-]+(?:\[[a-z0-9._,-]+\])?==[a-z0-9*+._!~-]+$/i;
 async function planLanguageOperation(options) {
   validateOperationOptions(options.operation, options.operationOptions?.packages);
+  validateFilterOption(options.operationOptions?.filter);
   const detection = await detectLanguageWorkspaces(options);
   const candidates = detection.workspaces.filter(
     (workspace) => workspace.capabilities.includes(options.operation)
@@ -3145,6 +3199,15 @@ function workspaceDepth(workspaceRoot, projectRoot) {
   const relative5 = path6.relative(path6.resolve(projectRoot), path6.resolve(workspaceRoot));
   return relative5 === "" ? 0 : relative5.split(path6.sep).length;
 }
+function validateFilterOption(filter) {
+  if (filter === void 0) return;
+  if (filter.startsWith("-") || filter.includes(" --")) {
+    throw new Error(`Invalid test filter (parsed as a runner option): "${filter}"`);
+  }
+  if (filter.length > MAX_ARGUMENT_LENGTH || /[\r\n\0]/.test(filter)) {
+    throw new Error("Invalid test filter (oversized or contains a control character)");
+  }
+}
 function validateOperationOptions(operation, packages) {
   if (!operation.startsWith("package-") || !packages) return;
   for (const value of packages) {

package/dist/write.js

@@ -117,12 +117,13 @@ function ensureInsideRoot(absPath, ctx) {
 function safeResolve(input, ctx) {
   return ensureInsideRoot(resolvePath(input, ctx), ctx);
 }
-async function assertRealInsideRoot(absPath, ctx) {
-  if (ctx.allowOutsideProjectRoot) return;
+async function resolveRealInsideRoot(absPath, ctx) {
+  if (ctx.allowOutsideProjectRoot) return absPath;
   const realRoots = await Promise.all(
     allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path2.resolve(r)))
   );
   let probe = absPath;
+  const pendingTail = [];
   for (; ; ) {
     let real;
     try {
@@ -130,13 +131,16 @@ async function assertRealInsideRoot(absPath, ctx) {
     } catch (err) {
       if (err.code === "ENOENT") {
         const parent = path2.dirname(probe);
-        if (parent === probe) return;
+        if (parent === probe) return absPath;
+        pendingTail.unshift(path2.basename(probe));
         probe = parent;
         continue;
       }
       throw err;
     }
-    if (isInsideAny(real, realRoots)) return;
+    if (isInsideAny(real, realRoots)) {
+      return pendingTail.length > 0 ? path2.join(real, ...pendingTail) : real;
+    }
     throw new Error(
       `Path "${absPath}" resolves through a symlink outside project root "${realRoots[0]}"`
     );
@@ -144,8 +148,7 @@ async function assertRealInsideRoot(absPath, ctx) {
 }
 async function safeResolveReal(input, ctx) {
   const abs = safeResolve(input, ctx);
-  await assertRealInsideRoot(abs, ctx);
-  return abs;
+  return await resolveRealInsideRoot(abs, ctx);
 }
 
 // src/write.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/tools",
-  "version": "0.296.4",
+  "version": "0.298.0",
   "license": "MIT",
   "description": "WrongStack built-in tools: read/write/edit, bash/exec, grep/glob, git, fetch, test, lint, and more.",
   "repository": {
@@ -242,15 +242,16 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "!dist/**/*.map"
   ],
   "dependencies": {
     "@playwright/test": "^1.62.0",
     "@typescript/typescript6": "^6.0.2",
     "turndown": "^7.2.4",
     "undici": "^8.9.0",
-    "@wrongstack/core": "0.296.4",
-    "@wrongstack/kanban": "0.296.4"
+    "@wrongstack/core": "0.298.0",
+    "@wrongstack/kanban": "0.298.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",

package/dist/_concurrency.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_concurrency.d.ts","sourceRoot":"","sources":["../src/_concurrency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAC3C,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC,CAAC,EAAE,CAAC,CAgBd"}

package/dist/_danger-detect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_danger-detect.d.ts","sourceRoot":"","sources":["../src/_danger-detect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,SAAS,GAAG,aAAa,CAAC;AAE7D,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AA2TD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,MAAM,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAC3B,gBAAgB,CAqBlB"}

package/dist/_edit-match.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_edit-match.d.ts","sourceRoot":"","sources":["../src/_edit-match.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,qBAAqB,GAAG,uBAAuB,GAAG,OAAO,CAAC;AAE5F,MAAM,WAAW,WAAW;IAC1B,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,4EAA4E;IAC5E,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACjC;AAED,uEAAuE;AACvE,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAMhD,CAAC;AAEF,6DAA6D;AAC7D,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAKlF,CAAC;AAYF;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CA+CzF;AA4HD,qEAAqE;AACrE,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAUvD;AAyBD,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMpD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAkBrC;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CA0B/C"}

package/dist/_env.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_env.d.ts","sourceRoot":"","sources":["../src/_env.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/_fetch-guard.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_fetch-guard.d.ts","sourceRoot":"","sources":["../src/_fetch-guard.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,aAAa,SAAwD,CAAC;AAUnF,KAAK,cAAc,GAAG,CACpB,GAAG,EAAE,MAAM,CAAC,cAAc,GAAG,IAAI,EACjC,OAAO,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,EACzE,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,KACxB,IAAI,CAAC;AAEV;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,EACnE,QAAQ,EAAE,cAAc,GACvB,IAAI,CAsCN;AA6CD;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,WAAW,EACnB,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAG7B,GACA,OAAO,CAAC,QAAQ,CAAC,CAuDnB;AAED,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoDtE"}

package/dist/_output-spool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_output-spool.d.ts","sourceRoot":"","sources":["../src/_output-spool.ts"],"names":[],"mappings":"AAmCA,2EAA2E;AAC3E,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED,8EAA8E;AAC9E,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD;AAwBD,MAAM,WAAW,SAAS;IACxB,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,iDAAiD;IACjD,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;;OAGG;IACH,QAAQ,IAAI,SAAS,GAAG,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,wBAAwB;IACvC,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAIjD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,wBAAwB,GAAG,WAAW,CA+E7E"}

package/dist/_redact-command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_redact-command.d.ts","sourceRoot":"","sources":["../src/_redact-command.ts"],"names":[],"mappings":"AA4BA;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA6BjD"}

package/dist/_regex.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_regex.d.ts","sourceRoot":"","sources":["../src/_regex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAkBH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,IAAI,CAAC;IACT,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,KAAK,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,WAAW,CA2B5F;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAAY,CAAC;AAEzC,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C"}

package/dist/_session-shell.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_session-shell.d.ts","sourceRoot":"","sources":["../src/_session-shell.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGlD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAM/E;AAED,MAAM,WAAW,uBAAuB;IACtC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,SAAS,CAAC;CACpD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,CAAC,QAAQ,EACzB,GAAG,EAAE;IAAE,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;CAAE,EAC7C,IAAI,GAAE,uBAA4B,GACjC,SAAS,GAAG,SAAS,CAYvB;AAED,MAAM,WAAW,yBAAyB;IACxC,qDAAqD;IACrD,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,CAAC;IACpC,iEAAiE;IACjE,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,GAAG,SAAS,CAAC;IACvC,+EAA+E;IAC/E,SAAS,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,SAAS,CAAC;CACpD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,GAAE,yBAA8B,GAAG,SAAS,GAAG,SAAS,CAa9F"}

package/dist/_shell-pick.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_shell-pick.d.ts","sourceRoot":"","sources":["../src/_shell-pick.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,YAAY,GAAG,MAAM,CAAC;AAEtD,wEAAwE;AACxE,eAAO,MAAM,aAAa,EAAE,SAAiB,CAAC;AAE9C,MAAM,WAAW,YAAY;IAC3B,uEAAuE;IACvE,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CACtC;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,MAAM,CAAC,QAAQ,EACzB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,YAAY,GAChB,SAAS,CAgBX;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CA2D5D;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAuCpE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAU5D;AAyCD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,EAAE,CAKpD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAgDrF"}