@wrongstack/tools 0.300.0 → 0.302.0

package/dist/index.js

@@ -851,7 +851,7 @@ import {
 } from "@wrongstack/core/observability";
 import { buildChildEnv } from "@wrongstack/core/utils";
 async function* spawnStream(opts) {
-  const max = opts.maxBytes ?? 2e5;
+  const max = opts.maxBytes ?? 999999999;
   const flushAt = opts.flushBytes ?? 4 * 1024;
   const maxQueue = opts.maxQueueSize ?? 500;
   const maxQueueBytes = opts.maxQueueBytes ?? 1024 * 1024;
@@ -5927,16 +5927,23 @@ function looksBinary(content) {
   }
   return bad / sample.length > 0.1;
 }
-function lineColAt(content, index) {
-  let line = 1;
-  let lastNl = -1;
-  for (let i = 0; i < index && i < content.length; i++) {
-    if (content.charCodeAt(i) === 10) {
-      line++;
-      lastNl = i;
-    }
+function newlineOffsets2(content) {
+  const offsets = [];
+  for (let i = 0; i < content.length; i++) {
+    if (content.charCodeAt(i) === 10) offsets.push(i);
   }
-  return { line, col: index - lastNl };
+  return offsets;
+}
+function lineColAt(offsets, index) {
+  let low = 0;
+  let high = offsets.length;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    if ((offsets[mid] ?? 0) < index) low = mid + 1;
+    else high = mid;
+  }
+  const lastNl = low > 0 ? offsets[low - 1] : -1;
+  return { line: low + 1, col: index - lastNl };
 }
 function parseGeneric2(opts) {
   const { file, lang } = opts;
@@ -5949,6 +5956,7 @@ function parseGeneric2(opts) {
   const patterns = patternsFor(lang);
   const symbols = [];
   const seen = /* @__PURE__ */ new Set();
+  const nlOffsets = newlineOffsets2(content);
   for (const pattern of patterns) {
     const re = new RegExp(pattern.re.source, pattern.re.flags.includes("g") ? pattern.re.flags : `${pattern.re.flags}g`);
     re.lastIndex = 0;
@@ -5962,7 +5970,7 @@ function parseGeneric2(opts) {
       if (!/^[A-Za-z_#.@/\w][\w.\-:/#!?]*$/.test(name) && lang !== "md" && lang !== "toml") {
         continue;
       }
-      const { line, col } = lineColAt(content, match.index);
+      const { line, col } = lineColAt(nlOffsets, match.index ?? 0);
       const key = `${name}\0${line}\0${pattern.kind}`;
       if (seen.has(key)) continue;
       seen.add(key);
@@ -9115,7 +9123,9 @@ async function executeSingle(call, ctx, governedExecute) {
       executionMs: Date.now() - start
     };
   }
-  const tool = ctx.tools.find((candidate) => candidate.name === call.tool);
+  const tool = (ctx.catalogTools ?? ctx.tools).find(
+    (candidate) => candidate.name === call.tool
+  );
   if (!tool) {
     return {
       tool: call.tool,
@@ -9337,7 +9347,7 @@ function parsePrivateOriginAllowlist(raw) {
   if (!raw?.trim()) return [];
   const origins = /* @__PURE__ */ new Set();
   for (const entry of raw.split(",")) {
-    const candidate = entry.trim();
+    const candidate = entry.trim().replace(/^["']+|["']+$/gu, "");
     if (!candidate) continue;
     const url = parseBrowserUrl(candidate, true);
     if (url.pathname !== "/" || url.search || url.hash) {
@@ -10581,9 +10591,9 @@ import * as path16 from "node:path";
 // src/codebase-index/bm25.ts
 var K1 = 1.5;
 var B = 0.75;
+var TOKENISE_RE = new RegExp("[^\\p{L}\\p{N}$']", "gu");
 function tokenise(text) {
-  const sanitised = text.replace(/[^\p{L}\p{N}$'_]/gu, " ").replace(/_/g, " ");
-  return sanitised.toLowerCase().split(" ").filter(Boolean);
+  return text.replace(TOKENISE_RE, " ").toLowerCase().trim().split(/\s+/).filter(Boolean);
 }
 function splitName(name) {
   return name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([\p{L}])(\d)/gu, "$1 $2").replace(/(\d)([\p{L}])/gu, "$1 $2").replace(/[_-]+/g, " ").trim();
@@ -13069,7 +13079,9 @@ var PROJECT_INDEX_SERVER_METADATA_FILE = "server.json";
 var PROJECT_INDEX_SERVER_SOCKET_DIR = `wsci-v${PROJECT_INDEX_SERVER_PROTOCOL_VERSION}`;
 var buildIdCache;
 function projectIndexServerBuildId(entrypoint) {
-  const file = entrypoint instanceof URL || entrypoint.startsWith("file:") ? fileURLToPath(entrypoint) : path17.resolve(entrypoint);
+  const href = entrypoint instanceof URL ? entrypoint.href : entrypoint;
+  const cleanHref = href.split(/[?#]/, 1)[0] ?? href;
+  const file = cleanHref.startsWith("file:") ? fileURLToPath(cleanHref) : path17.resolve(cleanHref);
   try {
     const stat19 = fs12.statSync(file);
     if (buildIdCache?.file === file && buildIdCache.mtimeMs === stat19.mtimeMs && buildIdCache.size === stat19.size) {
@@ -19888,11 +19900,8 @@ function buildArgs(input) {
         ...input.branch.startsWith("-") || input.branch.includes(" --") ? [] : [input.branch]
       ] : ["branch"];
     case "checkout":
-      return [
-        "checkout",
-        ...input.branch ? ["--", input.branch] : [],
-        ...files.length ? ["--", ...files] : []
-      ];
+      if (files.length) return ["checkout", "--", ...files];
+      return input.branch ? ["checkout", input.branch, "--"] : ["checkout"];
     case "stash":
       return input.message ? ["stash", "push", "-m", input.message] : ["stash", "push"];
     case "push":
@@ -19997,7 +20006,7 @@ async function mapWithConcurrency2(items, limit, fn) {
 
 // src/glob.ts
 init_util();
-var DEFAULT_IGNORE2 = DEFAULT_WALK_IGNORE_DIRS2;
+var DEFAULT_IGNORE2 = new Set(DEFAULT_WALK_IGNORE_DIRS2);
 var WALK_CONCURRENCY = 16;
 var globTool = {
   name: "glob",
@@ -20076,7 +20085,7 @@ var globTool = {
       const matchedFiles = [];
       for (const e of entries) {
         const name = e.name;
-        if (DEFAULT_IGNORE2.includes(name)) continue;
+        if (DEFAULT_IGNORE2.has(name)) continue;
         const rel = relPrefix ? `${relPrefix}/${name}` : name;
         const full = path30.join(dir, name);
         if (e.isDirectory()) {
@@ -20150,6 +20159,81 @@ var DANGEROUS_PATTERNS = [
   // Greedy quantifier inside lookahead/lookbehind — (?!.*a+)
   /[([][^)\]]*[+*][^)\]]*[)\]][^)]*\?\??/
 ];
+function hasAmbiguousQuantifiedAlternation(pattern) {
+  for (let i = 0; i < pattern.length; i++) {
+    if (pattern[i] !== "(") continue;
+    if (i > 0 && pattern[i - 1] === "\\") continue;
+    let depth = 0;
+    let inClass = false;
+    let j = i;
+    for (; j < pattern.length; j++) {
+      const ch = pattern[j];
+      if (ch === "\\") {
+        j++;
+        continue;
+      }
+      if (inClass) {
+        if (ch === "]") inClass = false;
+        continue;
+      }
+      if (ch === "[") {
+        inClass = true;
+        continue;
+      }
+      if (ch === "(") depth++;
+      else if (ch === ")") {
+        depth--;
+        if (depth === 0) break;
+      }
+    }
+    if (j >= pattern.length) return false;
+    const next = pattern[j + 1];
+    if (next !== "+" && next !== "*" && next !== "{") continue;
+    let inner = pattern.slice(i + 1, j);
+    inner = inner.replace(/^\?(?::|<?[=!])/u, "");
+    const branches = [];
+    let current = "";
+    let d = 0;
+    let cls = false;
+    for (let k = 0; k < inner.length; k++) {
+      const ch = inner[k];
+      if (ch === "\\") {
+        current += ch + (inner[k + 1] ?? "");
+        k++;
+        continue;
+      }
+      if (cls) {
+        if (ch === "]") cls = false;
+        current += ch;
+        continue;
+      }
+      if (ch === "[") {
+        cls = true;
+        current += ch;
+        continue;
+      }
+      if (ch === "(") d++;
+      if (ch === ")") d--;
+      if (ch === "|" && d === 0) {
+        branches.push(current);
+        current = "";
+        continue;
+      }
+      current += ch;
+    }
+    branches.push(current);
+    if (branches.length < 2) continue;
+    for (let a = 0; a < branches.length; a++) {
+      for (let b = a + 1; b < branches.length; b++) {
+        const x = branches[a];
+        const y = branches[b];
+        if (x === "" || y === "") return true;
+        if (x === y || x.startsWith(y) || y.startsWith(x)) return true;
+      }
+    }
+  }
+  return false;
+}
 function compileUserRegex(pattern, flags) {
   if (typeof pattern !== "string") {
     return { ok: false, reason: "pattern must be a string" };
@@ -20168,6 +20252,12 @@ function compileUserRegex(pattern, flags) {
       };
     }
   }
+  if (hasAmbiguousQuantifiedAlternation(pattern)) {
+    return {
+      ok: false,
+      reason: "pattern quantifies an alternation with overlapping branches \u2014 rewrite so no two branches can match the same text"
+    };
+  }
   try {
     return { ok: true, regex: new RegExp(pattern, flags) };
   } catch (err) {
@@ -20184,7 +20274,7 @@ function capSubject(line) {
 
 // src/grep.ts
 init_util();
-var DEFAULT_IGNORE3 = DEFAULT_WALK_IGNORE_DIRS3;
+var DEFAULT_IGNORE3 = new Set(DEFAULT_WALK_IGNORE_DIRS3);
 var NATIVE_SCAN_CONCURRENCY = 32;
 var NATIVE_READ_CHUNK_BYTES = 64 * 1024;
 var NATIVE_MAX_FILE_BYTES = 1e6;
@@ -20257,7 +20347,7 @@ var grepTool = {
         field: "pattern"
       });
     }
-    const base = input.path ? safeResolve(input.path, ctx) : ctx.cwd;
+    const base = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;
     const mode = input.output_mode ?? "content";
     const limit = Math.max(1, Math.min(input.limit ?? 200, 2e3));
     const validation = compileUserRegex(input.pattern, input.case_insensitive ? "i" : "");
@@ -20582,7 +20672,7 @@ async function runNative(input, base, mode, limit, signal) {
     const subdirs = [];
     for (const e of entries) {
       if (stopped) return;
-      if (DEFAULT_IGNORE3.includes(e.name)) continue;
+      if (DEFAULT_IGNORE3.has(e.name)) continue;
       if (e.isSymbolicLink()) continue;
       const rel = relPrefix ? `${relPrefix}/${e.name}` : e.name;
       const full = path31.join(dir, e.name);
@@ -24057,12 +24147,12 @@ import { spawn as spawn13 } from "node:child_process";
 import * as fs27 from "node:fs/promises";
 import * as os9 from "node:os";
 import * as path32 from "node:path";
-import { buildChildEnv as buildChildEnv8 } from "@wrongstack/core/utils";
+import { buildChildEnv as buildChildEnv8, toErrorMessage as toErrorMessage4 } from "@wrongstack/core/utils";
 var patchTool = {
   name: "patch",
   category: "Filesystem",
   description: "Apply a unified diff (patch) to the project. This is the correct tool when you have a diff that needs to be applied precisely, including handling of rejects.",
-  usageHint: "Best used when you already have a diff (from generation, external source, or previous step).\n- Use `dry_run: true` to see what would happen without modifying files.\n- On failure it creates .rej and .orig files for manual review.\nOften cleaner than many small `edit` operations for larger changes.",
+  usageHint: "Best used when you already have a diff (from generation, external source, or previous step).\n- Use `dry_run: true` to see what would happen without modifying files.\n- Applied with `--merge`: a conflicting hunk writes git-style conflict\n  markers (<<<<<<< / ======= / >>>>>>>) INTO the file and reports failure.\n  It does NOT create .rej/.orig files. `files` lists what changed on disk\n  even when the patch failed, so read those back before retrying.\nOften cleaner than many small `edit` operations for larger changes.",
   selection: {
     doNotUseWhen: "you do not already have a unified diff or only need one precise replacement.",
     useInstead: ["edit"]
@@ -24088,31 +24178,50 @@ var patchTool = {
   },
   async execute(input, ctx, opts) {
     if (!input?.patch) throw new Error("patch: patch content is required");
-    const dir = input.directory ? safeResolve(input.directory, ctx) : ctx.cwd;
     const strip = Math.max(1, input.strip ?? 1);
     const dryRun = input.dry_run ?? false;
+    const refuse = (message) => ({
+      applied: 0,
+      rejected: 1,
+      files: [],
+      dry_run: dryRun,
+      message
+    });
+    let dir;
+    try {
+      dir = input.directory ? await safeResolveReal(input.directory, ctx) : ctx.cwd;
+    } catch (err) {
+      return refuse(`patch refused: ${toErrorMessage4(err)}`);
+    }
+    const realRoot = await fs27.realpath(ctx.projectRoot).catch(() => path32.resolve(ctx.projectRoot));
     const targets = extractDiffTargets(input.patch);
     const resolvedTargets = [];
     for (const t of targets) {
-      const stripped = stripPathComponents(t, strip);
+      const stripped = stripPathComponents(t.raw, strip);
       if (!stripped) continue;
+      if (path32.isAbsolute(stripped)) {
+        return refuse(`patch refused: target "${t.raw}" strips to absolute path`);
+      }
       const candidate = path32.resolve(dir, stripped);
-      const rel = path32.relative(ctx.projectRoot, candidate);
+      let real;
+      try {
+        real = await resolveRealInsideRoot(candidate, ctx);
+      } catch (err) {
+        return refuse(`patch refused: target "${t.raw}" ${toErrorMessage4(err)}`);
+      }
+      const rel = path32.relative(realRoot, real);
       if (rel.startsWith("..") || path32.isAbsolute(rel)) {
-        return {
-          applied: 0,
-          rejected: 1,
-          files: [],
-          dry_run: dryRun,
-          message: `patch refused: target "${t}" resolves outside project root`
-        };
+        return refuse(`patch refused: target "${t.raw}" resolves outside project root`);
       }
-      resolvedTargets.push(candidate);
+      resolvedTargets.push({ raw: t.raw, deleted: t.deleted, abs: real });
     }
     const beforeContents = /* @__PURE__ */ new Map();
+    const beforeExisted = /* @__PURE__ */ new Set();
     if (!dryRun) {
       for (const target of resolvedTargets) {
-        beforeContents.set(target, await readTextForTracking(target));
+        const existed = (await fs27.stat(target.abs).catch(() => null))?.isFile() ?? false;
+        if (existed) beforeExisted.add(target.abs);
+        beforeContents.set(target.abs, await readTextForTracking(target.abs));
       }
     }
     const tmpDir = await fs27.mkdtemp(path32.join(os9.tmpdir(), ".wstack_patch_"));
@@ -24122,32 +24231,70 @@ var patchTool = {
       const patchFile = path32.join(tmpDir, "in.diff");
       await fs27.writeFile(patchFile, input.patch, { mode: 384 });
       const args = [`-p${strip}`, "--merge", ...dryRun ? ["--dry-run"] : [], "-i", patchFile];
-      const result = await runPatch(args, dir, opts.signal);
-      if (result.exitCode !== 0 && !dryRun) {
-        return {
-          applied: 0,
-          rejected: 1,
-          files: [],
-          dry_run: dryRun,
-          message: `patch failed: ${result.stderr || result.stdout}`
-        };
-      }
-      const patched = extractPatchedFiles(result.stdout);
+      const result = await runPatch(args, dir, opts.signal, {
+        patchFile,
+        strip,
+        dryRun
+      });
+      const touched = [];
       if (!dryRun) {
         for (const target of resolvedTargets) {
-          const before = beforeContents.get(target) ?? null;
-          const after = await readTextForTracking(target);
+          const abs = target.abs;
+          const before = beforeContents.get(abs) ?? null;
+          const stat19 = await fs27.stat(abs).catch(() => null);
+          if (!stat19?.isFile()) {
+            if (beforeExisted.has(abs)) {
+              touched.push(abs);
+              ctx.session?.recordFileChange?.({
+                path: abs,
+                action: "deleted",
+                before,
+                after: null
+              });
+            }
+            continue;
+          }
+          const after = await readTextForTracking(abs);
           if (after === null || after === before) continue;
-          const stat19 = await fs27.stat(target).catch(() => null);
-          if (stat19) ctx.recordRead?.(target, stat19.mtimeMs, "write", sha256hex(after));
+          touched.push(abs);
+          ctx.recordRead?.(abs, stat19.mtimeMs, "write", sha256hex(after));
           ctx.session?.recordFileChange?.({
-            path: target,
+            path: abs,
             action: before === null ? "created" : "modified",
             before,
             after
           });
         }
       }
+      if (result.exitCode !== 0) {
+        if (!dryRun) {
+          const partial = touched.length > 0 ? ` ${touched.length} file(s) were still modified on disk and have been recorded for rewind: ${touched.map((p) => path32.relative(realRoot, p) || p).join(", ")}.` : "";
+          return {
+            applied: touched.length,
+            rejected: 1,
+            // Normalize to relative-to-realRoot for API consistency with the
+            // success path (which returns GNU patch's dir-relative names).
+            // `touched` entries are realpaths from resolveRealInsideRoot, and
+            // realRoot is also a realpath, so path.relative is like-for-like.
+            files: touched.map((p) => path32.relative(realRoot, p) || p),
+            dry_run: dryRun,
+            message: `patch failed: ${result.stderr || result.stdout}${partial}`
+          };
+        }
+        const wouldPatch = extractPatchedFiles(result.stdout);
+        return {
+          applied: wouldPatch.length,
+          rejected: 1,
+          files: wouldPatch,
+          dry_run: dryRun,
+          message: `patch preview: would conflict \u2014 ${result.stderr || result.stdout}`
+        };
+      }
+      const patched = result.engine === "git" ? [
+        ...new Set(
+          resolvedTargets.map((target) => path32.relative(dir, target.abs) || target.abs)
+        )
+      ] : extractPatchedFiles(result.stdout);
       return {
         applied: patched.length,
         rejected: 0,
@@ -24175,27 +24322,86 @@ async function readTextForTracking(absPath) {
 }
 function extractDiffTargets(patch) {
   const out = [];
-  const re = /^\+\+\+\s+([^\t\r\n]+)/gm;
-  for (const m of patch.matchAll(re)) {
-    const raw = m[1];
-    if (!raw) continue;
-    const target = raw.length > 4096 ? raw.slice(0, 4096).trim() : raw.trim();
-    if (!target || target === "/dev/null") continue;
-    out.push(target);
+  const clean = (raw) => {
+    if (!raw) return "";
+    return (raw.length > 4096 ? raw.slice(0, 4096) : raw).trim();
+  };
+  let lastOld;
+  let inHunk = false;
+  let oldLinesLeft = 0;
+  let newLinesLeft = 0;
+  for (const line of patch.split(/\r?\n/)) {
+    const hunkMatch = /^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@/.exec(line);
+    if (hunkMatch) {
+      inHunk = true;
+      oldLinesLeft = hunkMatch[1] ? Number(hunkMatch[1]) : 1;
+      newLinesLeft = hunkMatch[2] ? Number(hunkMatch[2]) : 1;
+      lastOld = void 0;
+      continue;
+    }
+    if (inHunk) {
+      const ch = line[0];
+      if (ch === "-") oldLinesLeft--;
+      else if (ch === "+") newLinesLeft--;
+      else if (ch === " " || ch === void 0) {
+        oldLinesLeft--;
+        newLinesLeft--;
+      }
+      if (oldLinesLeft <= 0 && newLinesLeft <= 0) inHunk = false;
+      continue;
+    }
+    const oldMatch = /^---\s+([^\t\r\n]+)/.exec(line);
+    if (oldMatch) {
+      lastOld = clean(oldMatch[1]);
+      continue;
+    }
+    const newMatch = /^\+\+\+\s+([^\t\r\n]+)/.exec(line);
+    if (!newMatch) continue;
+    const newTarget = clean(newMatch[1]);
+    if (newTarget && newTarget !== "/dev/null") {
+      out.push({ raw: newTarget, deleted: false });
+    } else if (lastOld && lastOld !== "/dev/null") {
+      out.push({ raw: lastOld, deleted: true });
+    }
+    lastOld = void 0;
   }
   return out;
 }
 function stripPathComponents(p, strip) {
-  const parts = p.replace(/\\/g, "/").split("/").filter((s) => s !== "" && s !== ".");
-  if (parts.length <= strip) return void 0;
-  return parts.slice(strip).join("/");
+  const s = p.replace(/\\/g, "/");
+  let idx = 0;
+  for (let i = 0; i < strip; i++) {
+    while (idx < s.length && s[idx] !== "/") idx++;
+    let hadSlash = false;
+    while (idx < s.length && s[idx] === "/") {
+      idx++;
+      hadSlash = true;
+    }
+    if (!hadSlash) return void 0;
+  }
+  return s.slice(idx) || void 0;
+}
+function runPatch(args, cwd, signal, fallback) {
+  return runPatchProcess("patch", args, cwd, signal).then(async (result) => {
+    if (!result.unavailable) return { ...result, engine: "patch" };
+    const gitArgs = [
+      "apply",
+      "--unsafe-paths",
+      `-p${fallback.strip}`,
+      "--verbose",
+      ...fallback.dryRun ? ["--check"] : [],
+      fallback.patchFile
+    ];
+    const gitResult = await runPatchProcess("git", gitArgs, cwd, signal);
+    return { ...gitResult, engine: "git" };
+  });
 }
-function runPatch(args, cwd, signal) {
+function runPatchProcess(command, args, cwd, signal) {
   return new Promise((resolve17) => {
     let stdout = "";
     let stderr = "";
     const env = { ...buildChildEnv8(), LANG: "C", LC_ALL: "C" };
-    const child = spawn13("patch", args, {
+    const child = spawn13(command, args, {
       cwd,
       signal,
       env,
@@ -24208,13 +24414,24 @@ function runPatch(args, cwd, signal) {
     child.stderr?.on("data", (c) => {
       stderr += c.toString();
     });
-    child.on("close", (code) => resolve17({ exitCode: code ?? 1, stdout, stderr }));
-    child.on("error", (e) => resolve17({ exitCode: 1, stdout: "", stderr: e.message }));
+    child.on(
+      "close",
+      (code) => resolve17({ exitCode: code ?? 1, stdout, stderr, unavailable: false })
+    );
+    child.on(
+      "error",
+      (e) => resolve17({
+        exitCode: 1,
+        stdout: "",
+        stderr: e.message,
+        unavailable: e.code === "ENOENT"
+      })
+    );
   });
 }
 function extractPatchedFiles(output) {
   const files = [];
-  const re = /patching file (.+)/gi;
+  const re = /(?:patching|checking) file (.+)/gi;
   for (const m of output.matchAll(re)) {
     if (m[1]) files.push(m[1]);
   }
@@ -24523,7 +24740,7 @@ function mkResult(plan, ok, message, todos) {
 init_util();
 import * as fs28 from "node:fs/promises";
 import { FsError, ToolValidationError as ToolValidationError5 } from "@wrongstack/core/types";
-import { toErrorMessage as toErrorMessage4 } from "@wrongstack/core/utils";
+import { toErrorMessage as toErrorMessage5 } from "@wrongstack/core/utils";
 var ADVANCED_MODE_META_KEY = "tools.read.advancedMode";
 var MAX_BYTES2 = 5 * 1024 * 1024;
 var readTool = {
@@ -24591,7 +24808,7 @@ var readTool = {
         });
       }
       throw new FsError({
-        message: `read: failed to stat "${input.path}": ${toErrorMessage4(err)}`,
+        message: `read: failed to stat "${input.path}": ${toErrorMessage5(err)}`,
         code: "FS_READ_FAILED",
         path: absPath,
         context: { errno: code },
@@ -25250,7 +25467,7 @@ function substituteVars(content, name, vars) {
 // src/search.ts
 import { FetchError as FetchError3, ToolValidationError as ToolValidationError7 } from "@wrongstack/core/types";
 import { expectDefined as expectDefined9 } from "@wrongstack/core/utils";
-import { toErrorMessage as toErrorMessage5 } from "@wrongstack/core/utils";
+import { toErrorMessage as toErrorMessage6 } from "@wrongstack/core/utils";
 var DEFAULT_NUM = 10;
 var MAX_RESULTS = 50;
 var TIMEOUT_MS3 = 15e3;
@@ -25454,7 +25671,7 @@ async function duckduckgoSearch(query, num, signal) {
     return parseDuckDuckGo(html, num);
   } catch (err) {
     console.log(
-      JSON.stringify({ level: "debug", event: "search_failed", query, error: toErrorMessage5(err) })
+      JSON.stringify({ level: "debug", event: "search_failed", query, error: toErrorMessage6(err) })
     );
     return [{ title: "Search unavailable", url: "https://duckduckgo.com/unavailable", snippet: "Could not reach DuckDuckGo", score: 0 }];
   }
@@ -25638,7 +25855,7 @@ function decodeHtmlEntities(text) {
 
 // src/set-working-dir.ts
 import * as fs31 from "node:fs/promises";
-import { toErrorMessage as toErrorMessage6 } from "@wrongstack/core/utils";
+import { toErrorMessage as toErrorMessage7 } from "@wrongstack/core/utils";
 var setWorkingDirTool = {
   name: "set_working_dir",
   category: "Context",
@@ -25672,7 +25889,7 @@ var setWorkingDirTool = {
     } catch (err) {
       return {
         current: ctx.workingDir,
-        error: toErrorMessage6(err)
+        error: toErrorMessage7(err)
       };
     }
     try {
@@ -26407,7 +26624,7 @@ var toolHelpTool = {
     const format = input.format ?? "short";
     const includeExamples = input.include_examples ?? false;
     if (input.tool) {
-      const tool = ctx.tools.find((t) => t.name === input.tool);
+      const tool = (ctx.catalogTools ?? ctx.tools).find((t) => t.name === input.tool);
       if (!tool) {
         return {
           tool: input.tool,
@@ -26432,7 +26649,7 @@ var toolHelpTool = {
         total: 1
       };
     }
-    const allTools = ctx.tools.map((t) => ({
+    const allTools = (ctx.catalogTools ?? ctx.tools).map((t) => ({
       name: t.name,
       description: t.description,
       usageHint: t.usageHint ?? "",
@@ -26540,7 +26757,7 @@ var toolSearchTool = {
   },
   async execute(input, ctx) {
     const limit = Math.min(input.limit ?? 20, 100);
-    const tools = ctx.tools;
+    const tools = ctx.catalogTools ?? ctx.tools;
     const query = input.query?.toLowerCase() ?? "";
     const filtered = tools.filter((t) => {
       if (query && !t.name.toLowerCase().includes(query) && !t.description.toLowerCase().includes(query)) {
@@ -26620,7 +26837,7 @@ var toolUseTool = {
         executionMs: 0
       };
     }
-    const tool = ctx.tools.find((t) => t.name === input.tool);
+    const tool = (ctx.catalogTools ?? ctx.tools).find((t) => t.name === input.tool);
     if (!tool) {
       return {
         tool: input.tool,
@@ -26678,7 +26895,13 @@ init_util();
 import * as fs32 from "node:fs/promises";
 import * as path36 from "node:path";
 import { DEFAULT_WALK_IGNORE_DIRS as DEFAULT_WALK_IGNORE_DIRS4, expectDefined as expectDefined10 } from "@wrongstack/core/utils";
-var DEFAULT_IGNORE5 = [...DEFAULT_WALK_IGNORE_DIRS4, ".wrongstack", ".ssh", ".gnupg", ".aws"];
+var DEFAULT_IGNORE5 = /* @__PURE__ */ new Set([
+  ...DEFAULT_WALK_IGNORE_DIRS4,
+  ".wrongstack",
+  ".ssh",
+  ".gnupg",
+  ".aws"
+]);
 var DEFAULT_MAX_ENTRIES2 = 5e3;
 var MAX_TREE_OUTPUT_BYTES = 256 * 1024;
 var treeTool = {
@@ -26839,8 +27062,12 @@ async function walkDir(dir, depth, opts) {
     return true;
   });
   if (depth > 0) {
-    const dirCount = filtered.filter((e) => e.isDirectory()).length;
-    const fileCount = filtered.filter((e) => e.isFile()).length;
+    let dirCount = 0;
+    let fileCount = 0;
+    for (const e of filtered) {
+      if (e.isDirectory()) dirCount++;
+      else if (e.isFile()) fileCount++;
+    }
     opts.totalDirs.value += dirCount;
     opts.totalFiles.value += fileCount;
     opts.onProgress?.();
@@ -27521,6 +27748,62 @@ ${mode.description}`
   };
 }
 
+// src/next-steps-tool.ts
+import {
+  MAX_PENDING_NEXT_STEPS,
+  writePendingNextSteps
+} from "@wrongstack/core/agent";
+var nextStepsTool = {
+  name: "nextsteps",
+  category: "Session",
+  description: "Record the after-task follow-on suggestions for this turn. Equivalent to ending your final message with a <nextsteps> block \u2014 use whichever you prefer. The list is fully replaced on every call (not appended).",
+  usageHint: 'Call this at most once, on the turn you are finishing the work \u2014 not mid-task.\n- Each `text` is the **exact prompt message** that gets submitted back to you when the user picks it. Write agent-directed work ("Run the parser tests and fix any failures"), never a chore for the user to do by hand.\n- Order by priority; 1-4 items. Do not pad with filler or invent work to fill the list.\n- `auto: true` is honored on the first item only. Set it when that prompt is safe to run unattended \u2014 YOLO+auto executes it verbatim, so it must be complete and self-contained.\n- Omit the call entirely while any todo is still `pending` or `in_progress`; suggestions recorded in that state are discarded.\n- If you also write a <nextsteps> block in your message, that block wins.',
+  permission: "auto",
+  mutating: false,
+  // mutates only turn-scoped conversation state — no confirmation needed
+  timeoutMs: 5e3,
+  capabilities: ["session.nextsteps"],
+  icon: "todo",
+  inputSchema: {
+    type: "object",
+    properties: {
+      steps: {
+        type: "array",
+        minItems: 1,
+        maxItems: MAX_PENDING_NEXT_STEPS,
+        items: {
+          type: "object",
+          properties: {
+            text: {
+              type: "string",
+              description: "The exact natural-language prompt message to submit back to the agent when the user selects this item."
+            },
+            auto: {
+              type: "boolean",
+              description: "Safe to run unattended. Honored on the first item only; ignored elsewhere."
+            }
+          },
+          required: ["text"]
+        },
+        description: `The complete suggestion list (1-${MAX_PENDING_NEXT_STEPS} items), highest priority first. Replaces any previous list for this turn.`
+      }
+    },
+    required: ["steps"]
+  },
+  async execute(input, ctx) {
+    if (!Array.isArray(input?.steps)) {
+      throw new Error("nextsteps: steps must be an array");
+    }
+    const steps = input.steps.filter((s) => typeof s?.text === "string").map((s) => s.auto === true ? { text: s.text, auto: true } : { text: s.text });
+    if (steps.length === 0) {
+      throw new Error("nextsteps: steps must contain at least one item with a non-empty text");
+    }
+    writePendingNextSteps(ctx, steps);
+    const accepted = Math.min(steps.length, MAX_PENDING_NEXT_STEPS);
+    return { accepted, auto: steps[0]?.auto === true };
+  }
+};
+
 // src/pack.ts
 var builtinToolsPack = {
   name: "builtin-tools",
@@ -28121,6 +28404,11 @@ function createGlobalPsSlashCommand() {
 // src/skill.ts
 import * as fs34 from "node:fs/promises";
 import * as path38 from "node:path";
+import {
+  missingRequiredRuntimeTools,
+  missingRuntimeCapabilities,
+  runtimeToolReferencesFromText
+} from "@wrongstack/core/agent-catalog";
 import { SKILL_LIMITS, stripFrontmatter } from "@wrongstack/core/skills";
 import { ToolValidationError as ToolValidationError10 } from "@wrongstack/core/types";
 var MAX_BODY_CHARS = SKILL_LIMITS.MAX_SKILL_BODY_CHARS;
@@ -28164,12 +28452,37 @@ function makeSkillTool(skillLoader) {
           field: "name"
         });
       }
+      const availableToolNames = (ctx?.catalogTools ?? ctx?.tools ?? []).map((tool) => tool.name);
+      const missingCapabilities = missingRuntimeCapabilities(
+        manifest.requiredCapabilities,
+        availableToolNames
+      );
+      const missingTools = missingRequiredRuntimeTools(manifest.requiredTools, availableToolNames);
+      if (missingCapabilities.length > 0 || missingTools.length > 0) {
+        throw new ToolValidationError10({
+          message: `skill "${name}" is unavailable in this runtime; ` + [
+            missingCapabilities.length > 0 ? `missing capabilities: ${missingCapabilities.join(", ")}` : "",
+            missingTools.length > 0 ? `missing tools: ${missingTools.join(", ")}` : ""
+          ].filter(Boolean).join("; "),
+          field: "name"
+        });
+      }
       const dir = path38.dirname(manifest.path);
       let loadedResource;
       if (input.resource?.trim()) {
         loadedResource = await loadResource(dir, input.resource.trim());
       }
       const raw = await skillLoader.readBody(name);
+      const missingBodyTools = missingRequiredRuntimeTools(
+        runtimeToolReferencesFromText(raw),
+        availableToolNames
+      );
+      if (missingBodyTools.length > 0) {
+        throw new ToolValidationError10({
+          message: `skill "${name}" references unregistered tools: ${missingBodyTools.join(", ")}`,
+          field: "name"
+        });
+      }
       const body = stripFrontmatter(raw).trim().slice(0, MAX_BODY_CHARS);
       const resources = loadedResource ? [] : await listResources(dir);
       try {
@@ -28228,9 +28541,26 @@ async function loadResource(skillDir, rel) {
       field: "resource"
     });
   }
+  let realPath;
+  let realRoot;
+  try {
+    realRoot = await fs34.realpath(root);
+    realPath = await fs34.realpath(absPath);
+  } catch {
+    throw new ToolValidationError10({
+      message: `skill: resource "${rel}" not readable`,
+      field: "resource"
+    });
+  }
+  if (realPath !== realRoot && !realPath.startsWith(realRoot + path38.sep)) {
+    throw new ToolValidationError10({
+      message: `skill: resource "${rel}" resolves outside the skill directory`,
+      field: "resource"
+    });
+  }
   let buf;
   try {
-    buf = await fs34.readFile(absPath);
+    buf = await fs34.readFile(realPath);
   } catch {
     throw new ToolValidationError10({
       message: `skill: resource "${rel}" not readable`,
@@ -28241,7 +28571,9 @@ async function loadResource(skillDir, rel) {
   const truncated = raw.length > MAX_RESOURCE_CHARS;
   return {
     rel: norm,
-    absPath,
+    // The canonical path — the one actually opened, and the one a follow-up
+    // `bash` invocation should use.
+    absPath: realPath,
     content: truncated ? raw.slice(0, MAX_RESOURCE_CHARS) : raw,
     bytes: buf.length,
     truncated
@@ -28349,6 +28681,9 @@ var TOOL_ICON_MAP = {
   // Task management
   todo: "todo",
   todos: "todo",
+  // After-task suggestions — same family as the todo board, so it reuses the
+  // icon rather than widening ToolIconId (every UI maps that union by hand).
+  nextsteps: "todo",
   // Planning
   plan: "plan",
   planning: "plan",
@@ -28475,11 +28810,7 @@ function selectBuiltinToolsForTier(tier, allTools) {
     }
     case "aggressive": {
       const tier1Names = toolNameSet(TIER1_TOOLS);
-      const tier2Names = toolNameSet(TIER2_TOOLS);
-      const tier3Names = toolNameSet(TIER3_TOOLS);
-      return allTools.filter(
-        (tool) => tier1Names.has(tool.name) || tier2Names.has(tool.name) && tool.name !== "task" || tier3Names.has(tool.name) && tool.name !== "set_working_dir"
-      );
+      return allTools.filter((tool) => tier1Names.has(tool.name));
     }
   }
 }
@@ -28606,6 +28937,7 @@ export {
   mirrorSessionPlanToKanban,
   mirrorSessionTasksToKanban,
   mirrorSessionTodosToKanban,
+  nextStepsTool,
   normalizeShell,
   onIndexStateChange,
   outdatedTool,