@wrongstack/tools 0.291.0 → 0.291.1

package/dist/index.js

@@ -709,8 +709,8 @@ var init_process_registry = __esm({
         if (p.killed) return true;
         if (p.protected) return false;
         const { force = false, graceMs = DEFAULT_GRACE_MS } = opts;
-        const isWin4 = os.platform() === "win32";
-        if (isWin4) {
+        const isWin5 = os.platform() === "win32";
+        if (isWin5) {
           const liveRealChild = p.child.exitCode === null && typeof p.child.pid === "number";
           const directFallback = () => {
             if (p.child.exitCode === null) {
@@ -2608,8 +2608,8 @@ async function scanDirectory(directory, depth, profiles, limits, state, extraIgn
     collectFileEvidence(directory, fullPath, entry.name, profiles, state);
   }
 }
-function collectFileEvidence(directory, fullPath, basename10, profiles, state) {
-  const lower = basename10.toLowerCase();
+function collectFileEvidence(directory, fullPath, basename11, profiles, state) {
+  const lower = basename11.toLowerCase();
   const extension = path4.extname(lower);
   for (const profile of profiles) {
     const detector = profile.detectors.find(
@@ -2620,7 +2620,7 @@ function collectFileEvidence(directory, fullPath, basename10, profiles, state) {
       candidate.evidence.push({
         kind: detector.kind,
         path: fullPath,
-        value: basename10,
+        value: basename11,
         weight: detector.weight
       });
       if (detector.kind === "manifest" || detector.kind === "config") {
@@ -3937,15 +3937,15 @@ async function changedPaths(before, after, beforeSizes, afterSizes) {
   const beforeSet = new Set(before);
   const afterSet = new Set(after);
   const changed = /* @__PURE__ */ new Set();
-  for (const path33 of after) {
-    if (!beforeSet.has(path33)) changed.add(path33);
+  for (const path34 of after) {
+    if (!beforeSet.has(path34)) changed.add(path34);
   }
-  for (const path33 of before) {
-    if (!afterSet.has(path33)) changed.add(path33);
+  for (const path34 of before) {
+    if (!afterSet.has(path34)) changed.add(path34);
   }
   if (beforeSizes && afterSizes) {
-    for (const path33 of after) {
-      if (beforeSizes.get(path33) !== afterSizes.get(path33)) changed.add(path33);
+    for (const path34 of after) {
+      if (beforeSizes.get(path34) !== afterSizes.get(path34)) changed.add(path34);
     }
   }
   return [...changed].sort();
@@ -5103,8 +5103,8 @@ function normalizeShell(value) {
   if (v === "pwsh" || v === "pwsh.exe") return "pwsh";
   return void 0;
 }
-function resolveSessionShell(platform5, env, deps = {}) {
-  if (platform5 !== "win32") return void 0;
+function resolveSessionShell(platform6, env, deps = {}) {
+  if (platform6 !== "win32") return void 0;
   const override = normalizeShell(env.get("WRONGSTACK_SHELL"));
   if (override) return override;
   const hasBinary = deps.hasBinary ?? ((bin) => resolveWin32Command(bin) !== bin);
@@ -5114,11 +5114,11 @@ function resolveSessionShell(platform5, env, deps = {}) {
 }
 function ensureSessionShell(opts = {}) {
   const env = opts.env ?? process.env;
-  const platform5 = opts.platform ?? process.platform;
-  if (platform5 !== "win32") return void 0;
+  const platform6 = opts.platform ?? process.platform;
+  if (platform6 !== "win32") return void 0;
   const existing = normalizeShell(env["WRONGSTACK_SHELL"]);
   if (existing) return existing;
-  const chosen = resolveSessionShell(platform5, { get: (k) => env[k] }, { hasBinary: opts.hasBinary }) ?? "cmd";
+  const chosen = resolveSessionShell(platform6, { get: (k) => env[k] }, { hasBinary: opts.hasBinary }) ?? "cmd";
   env["WRONGSTACK_SHELL"] = chosen;
   return chosen;
 }
@@ -5693,17 +5693,18 @@ function resetPersistentProcessRegistry() {
 
 // src/bash-kill-guard.ts
 var isWin2 = os3.platform() === "win32";
+var SCRIPT_KILL_RE = /^(?:\.\\|\.\/)?(?:kill|terminate|stop)\S*\.(?:ps1|bat|cmd|sh)(?:\s|$)/i;
+var SCRIPT_KILL_RE_POSIX = /^(?:\.\/)?(?:kill|terminate|stop)\S*\.sh(?:\s|$)/i;
+var SCRIPT_KILL_FALLBACK_RE = /^\S*(?:kill|terminate|stop)\S*\.(?:ps1|bat|cmd|sh)\b/i;
 function extractKillCommand(command) {
   const normalized = command.replace(/\s+/g, " ").trim();
-  const shellCMatch = normalized.match(
-    /^(?:\S+(?:\s+\S+)?)?\s+-c\s+['"](.+?)['"]$/
-  );
-  if (shellCMatch?.[1]) {
-    const inner = shellCMatch[1].trim();
+  const shellCMatch = normalized.match(/^.+?\s+-c\s+(['"])([\s\S]+)\1$/);
+  if (shellCMatch?.[2]) {
+    const inner = shellCMatch[2].trim();
     return isKillRelatedCommand(inner) ? inner : null;
   }
   const shellCUnquoted = normalized.match(
-    /^(?:\S+(?:\s+\S+)?)?\s+-c\s+(kill(?:\s+-[a-zA-Z]+)?(?:\s+\d+)+)$/
+    /^.+?\s+-c\s+(kill(?:\s+-s\s+[a-zA-Z0-9]+|\s+-[a-zA-Z0-9]+)?\s+\d+)$/
   );
   if (shellCUnquoted?.[1]) {
     return shellCUnquoted[1];
@@ -5715,22 +5716,47 @@ function isKillRelatedCommand(cmd) {
   if (isWin2) {
     if (/^taskkill\s/i.test(normalized)) return true;
     if (/^tskill\s/i.test(normalized)) return true;
+    if (/^(stop-process|kill|stop)\s/i.test(normalized)) return true;
+    if (/^wmic\s+process\s/i.test(normalized) && /\bdelete\b/i.test(normalized)) return true;
+    if (SCRIPT_KILL_RE.test(normalized)) return true;
     return false;
   }
   if (/^kill(\s|$)/.test(normalized)) return true;
   if (/^(pkill|killall|pgrep|skill)\s/.test(normalized)) return true;
   if (/^\/proc\/\d+\/(?:kill|fd)/.test(normalized)) return true;
+  if (SCRIPT_KILL_RE_POSIX.test(normalized)) return true;
   return false;
 }
 function parseKillCommand(command) {
   const normalized = command.replace(/\s+/g, " ").trim();
   if (isWin2) {
-    const taskkillMatch = normalized.match(/^taskkill\s+(?:\/[a-zA-Z]+\s+)*\/PID\s+(\d+)/i);
-    if (taskkillMatch?.[1]) {
-      const pidStr = taskkillMatch[1];
+    const hasTaskkillForce = /(?:^|\s)\/F(?=\s|$)/i.test(normalized);
+    const isSimpleTaskkill = /^taskkill\s+/i.test(normalized) && !/[|&<>]/.test(normalized);
+    const taskkillPidMatch = isSimpleTaskkill ? normalized.match(/(?:^|\s)\/PID\s+(\d+)(?=\s|$)/i) : null;
+    if (taskkillPidMatch?.[1]) {
+      return {
+        pid: parseInt(taskkillPidMatch[1], 10),
+        signal: hasTaskkillForce ? "FORCE" : "TERM",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const taskkillImMatch = isSimpleTaskkill ? normalized.match(/(?:^|\s)\/IM\s+([^\s/]+)(?=\s|$)/i) : null;
+    if (taskkillImMatch?.[1]) {
+      return {
+        name: taskkillImMatch[1],
+        signal: hasTaskkillForce ? "FORCE" : "TERM",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const taskkillFiMatch = isSimpleTaskkill ? normalized.match(/(?:^|\s)\/FI\s+"IMAGENAME\s+eq\s+([^"]+)"(?=\s|$)/i) : null;
+    if (taskkillFiMatch?.[1]) {
       return {
-        pid: parseInt(pidStr, 10),
-        signal: normalized.includes("/F") ? "FORCE" : "TERM",
+        name: taskkillFiMatch[1],
+        signal: hasTaskkillForce ? "FORCE" : "TERM",
         isGroupKill: false,
         isAllKill: false,
         originalCommand: command
@@ -5738,18 +5764,109 @@ function parseKillCommand(command) {
     }
     const tskillMatch = normalized.match(/^tskill\s+(\d+)/i);
     if (tskillMatch?.[1]) {
-      const pidStr = tskillMatch[1];
       return {
-        pid: parseInt(pidStr, 10),
+        pid: parseInt(tskillMatch[1], 10),
         signal: "TERM",
         isGroupKill: false,
         isAllKill: false,
         originalCommand: command
       };
     }
+    const isStopProcIdCommand = /^(?:stop-process|kill)(?:\s+-(?:id|pid)\s+\d+|\s+-[a-zA-Z]+)+$/i.test(normalized);
+    const stopProcIdMatch = normalized.match(/(?:^|\s)-(?:id|pid)\s+(\d+)(?=\s|$)/i);
+    if (isStopProcIdCommand && stopProcIdMatch?.[1]) {
+      return {
+        pid: parseInt(stopProcIdMatch[1], 10),
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const killSignalOptionMatch = normalized.match(/^kill\s+-s\s+([a-zA-Z0-9]+)\s+(\d+)$/i);
+    if (killSignalOptionMatch?.[1] && killSignalOptionMatch[2]) {
+      return {
+        pid: parseInt(killSignalOptionMatch[2], 10),
+        signal: killSignalOptionMatch[1].toUpperCase(),
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const killPosixMatch = normalized.match(/^kill\s+(?:(-[a-zA-Z0-9]+)\s+)?(\d+)$/);
+    if (killPosixMatch?.[2]) {
+      const sig = killPosixMatch[1] ? killPosixMatch[1].slice(1).toUpperCase() : "TERM";
+      return {
+        pid: parseInt(killPosixMatch[2], 10),
+        signal: sig,
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const stopProcNameMatch = normalized.match(
+      /^(?:stop-process|kill)\s+-(?:name|n)\s+(?:['"]([a-zA-Z0-9_.-]+)['"]|([a-zA-Z0-9_.-]+))(?:\s|$)/i
+    );
+    const stopProcName = stopProcNameMatch?.[1] ?? stopProcNameMatch?.[2];
+    if (stopProcName) {
+      return {
+        name: stopProcName,
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const stopProcStandalone = normalized.match(
+      /^(?:stop-process|kill)\s+['"]?([a-zA-Z][a-zA-Z0-9_.-]+)['"]?$/i
+    );
+    if (stopProcStandalone?.[1]) {
+      return {
+        name: stopProcStandalone[1],
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const wmicMatch = normalized.match(
+      /^wmic\s+process\s+where\s+['"]?(?:name\s*=\s*['"]?)([a-zA-Z0-9_.-]+)/i
+    );
+    if (wmicMatch?.[1]) {
+      return {
+        name: wmicMatch[1],
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const killScriptMatch = normalized.match(SCRIPT_KILL_RE);
+    if (killScriptMatch) {
+      return {
+        name: "kill-script",
+        // sentinel — isKillProtected always blocks "kill-script"
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
     return null;
   }
-  const simpleMatch = normalized.match(/^kill\s+(?:(-[a-zA-Z]+)\s+)?(\d+|-?\d+)$/);
+  const signalOptionMatch = normalized.match(/^kill\s+-s\s+([a-zA-Z0-9]+)\s+(\d+|-?\d+)$/i);
+  if (signalOptionMatch?.[1] && signalOptionMatch[2]) {
+    const pidOrGroup = signalOptionMatch[2];
+    const isGroupKill = pidOrGroup.startsWith("-");
+    return {
+      pid: parseInt(isGroupKill ? pidOrGroup.slice(1) : pidOrGroup, 10),
+      signal: signalOptionMatch[1].toUpperCase(),
+      isGroupKill,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  const simpleMatch = normalized.match(/^kill\s+(?:(-[a-zA-Z0-9]+)\s+)?(\d+|-?\d+)$/);
   if (simpleMatch) {
     const signal = simpleMatch[1] ?? "-TERM";
     const pidOrGroup = simpleMatch[2];
@@ -5809,6 +5926,9 @@ async function getProtectedEntries() {
 }
 async function isKillProtected(kill) {
   const registry = getPersistentProcessRegistry();
+  if (kill.name === "kill-script") {
+    return true;
+  }
   if (kill.name) {
     const entries = await getProtectedEntries();
     const killNameLower = kill.name.toLowerCase();
@@ -5848,6 +5968,12 @@ async function checkAndBlockKillCommand(command) {
         reason: `Blocked: complex kill pipeline detected \u2014 "${killCmd.slice(0, 50)}..."`
       };
     }
+    if (SCRIPT_KILL_FALLBACK_RE.test(killCmd)) {
+      return {
+        blocked: true,
+        reason: `Blocked: script-based kill detected \u2014 "${killCmd.slice(0, 80)}" may target protected WrongStack processes (cannot inspect script body).`
+      };
+    }
     return { blocked: false };
   }
   if (await isKillProtected(parsed)) {
@@ -5871,8 +5997,8 @@ async function checkAndBlockKillCommand(command) {
 
 // src/_shell-pick.ts
 var POSIX_DEFAULT = "cmd";
-function pickShell(platform5, command, env) {
-  if (platform5 !== "win32") return POSIX_DEFAULT;
+function pickShell(platform6, command, env) {
+  if (platform6 !== "win32") return POSIX_DEFAULT;
   const override = env.get("WRONGSTACK_SHELL")?.trim().toLowerCase();
   if (override === "cmd" || override === "cmd.exe") return "cmd";
   if (override === "powershell" || override === "powershell.exe") return "powershell";
@@ -6076,10 +6202,10 @@ var bashTool = {
       }));
     }
     const timeoutMs = Math.max(1, Math.min(input.timeout_ms ?? DEFAULT_TIMEOUT_MS2, 6e5));
-    const isWin4 = os4.platform() === "win32";
+    const isWin5 = os4.platform() === "win32";
     let plan;
     let winShellKind;
-    if (isWin4) {
+    if (isWin5) {
       const shell2 = pickShell("win32", input.command, {
         get: (k) => process.env[k]
       });
@@ -6108,7 +6234,7 @@ var bashTool = {
     const shell = plan.bin;
     const args = plan.useStdin ? [...plan.argv] : [...plan.argv, input.command];
     const env = buildChildEnv2(ctx.session?.id);
-    const detached = !isWin4;
+    const detached = !isWin5;
     const startedAt = Date.now();
     if (input.background) {
       let buf2 = "";
@@ -6126,7 +6252,7 @@ var bashTool = {
         // apply: the child gets a hidden console that grandchildren inherit.
         // Windows children survive parent exit either way. POSIX keeps
         // detached for the process-group kill semantics.
-        detached: !isWin4,
+        detached: !isWin5,
         windowsHide: true
       });
       if (plan.useStdin) {
@@ -6237,7 +6363,7 @@ var bashTool = {
       stdio: [plan.useStdin ? "pipe" : "ignore", "pipe", "pipe"],
       detached,
       windowsHide: true,
-      ...isWin4 ? {} : { signal: opts.signal }
+      ...isWin5 ? {} : { signal: opts.signal }
     });
     if (plan.useStdin) {
       try {
@@ -6290,7 +6416,7 @@ var bashTool = {
     const timers = [];
     const spool = createOutputSpool({ tool: "bash", thresholdBytes: MAX_OUTPUT });
     function killWithTimeout(child2, timeoutMs2) {
-      if (isWin4) {
+      if (isWin5) {
         if (typeof child2.pid === "number" && child2.exitCode === null) {
           const attempted = registry.kill(child2.pid, { force: true, graceMs: timeoutMs2 });
           if (!attempted) {
@@ -6331,7 +6457,7 @@ var bashTool = {
     timers.push(timer);
     timer.unref?.();
     const onAbort = () => killWithTimeout(child, 2e3);
-    if (isWin4) {
+    if (isWin5) {
       if (opts.signal.aborted) onAbort();
       else opts.signal.addEventListener("abort", onAbort, { once: true });
     }
@@ -6445,7 +6571,7 @@ ${hint}` : ""),
     } finally {
       for (const t of timers) clearTimeout(t);
       spool.finalize();
-      if (isWin4) opts.signal.removeEventListener("abort", onAbort);
+      if (isWin5) opts.signal.removeEventListener("abort", onAbort);
       child.stdout?.off("data", onStdoutData);
       child.stderr?.off("data", onStderrData);
       child.stdout?.destroy();
@@ -10323,9 +10449,9 @@ function parseSymbols5(opts) {
 function regexParse2(opts) {
   const { file, content, lang } = opts;
   const symbols = [];
-  const basename10 = path17.basename(file).toLowerCase();
-  const isPackageJson = basename10 === "package.json";
-  const isTsconfig = basename10 === "tsconfig.json" || basename10 === "tsconfig.build.json";
+  const basename11 = path17.basename(file).toLowerCase();
+  const isPackageJson = basename11 === "package.json";
+  const isTsconfig = basename11 === "tsconfig.json" || basename11 === "tsconfig.build.json";
   const isJsonSchema = content.includes("$schema") || content.includes("$id") || content.includes("$ref");
   const isOpenApi = content.includes("openapi") || content.includes("swagger");
   const lines = content.split("\n");
@@ -13289,7 +13415,244 @@ init_output_spool();
 init_util();
 init_process_registry();
 init_win32_resolve();
-var isWin3 = process.platform === "win32";
+
+// src/exec-kill-guard.ts
+import * as os7 from "node:os";
+import * as path24 from "node:path";
+var isWin3 = os7.platform() === "win32";
+async function checkExecKillCommand(cmd, args) {
+  if (!cmd) return { blocked: false };
+  const cmdLower = cmd.toLowerCase().trim();
+  const fullCommand = [cmdLower, ...args].join(" ").replace(/\s+/g, " ").trim();
+  if (isWin3) {
+    if (cmdLower === "taskkill" || cmdLower === "taskkill.exe") {
+      const hasForce = args.some((a) => a.toUpperCase() === "/F" || a.toUpperCase() === "-F");
+      const signal = hasForce ? "FORCE" : "TERM";
+      for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a.toUpperCase() === "/IM" || a.toUpperCase() === "-IM") {
+          const nameArg = args[i + 1];
+          if (nameArg) {
+            const result = await checkKillTarget({ name: nameArg, signal, cmd: fullCommand });
+            if (result.blocked) return result;
+          }
+        }
+      }
+      for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a.toUpperCase() === "/PID" || a.toUpperCase() === "-PID") {
+          const pidArg = args[i + 1];
+          if (pidArg && /^\d+$/.test(pidArg)) {
+            const result = await checkKillTarget({
+              pid: parseInt(pidArg, 10),
+              signal,
+              cmd: fullCommand
+            });
+            if (result.blocked) return result;
+          }
+        }
+      }
+      for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a.toUpperCase() === "/FI" || a.toUpperCase() === "-FI") {
+          const filterArg = args[i + 1];
+          if (filterArg) {
+            const nameMatch = filterArg.match(/IMAGENAME\s+eq\s+"?([^"\s]+)/i);
+            if (nameMatch?.[1]) {
+              const result = await checkKillTarget({ name: nameMatch[1], signal, cmd: fullCommand });
+              if (result.blocked) return result;
+            }
+          }
+        }
+      }
+      return { blocked: false };
+    }
+    if (cmdLower === "powershell" || cmdLower === "powershell.exe" || cmdLower === "pwsh" || cmdLower === "pwsh.exe" || cmdLower === "cmd" || cmdLower === "cmd.exe") {
+      const shellFlagIndex = args.findIndex((arg) => {
+        const lower = arg.toLowerCase();
+        return lower === "-c" || lower === "-command" || lower === "/c";
+      });
+      if (shellFlagIndex >= 0) {
+        const innerTokens = tokenizeShellCommand(args.slice(shellFlagIndex + 1).join(" "));
+        const innerCommand = innerTokens[0];
+        if (innerCommand) {
+          const result = await checkExecKillCommand(innerCommand, innerTokens.slice(1));
+          if (result.blocked) return result;
+        }
+      }
+    }
+    if (cmdLower === "stop-process" || cmdLower === "kill") {
+      for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "-Name" || a === "-n") {
+          const nameArg = args[i + 1]?.replace(/^['"]|['"]$/g, "");
+          if (nameArg) {
+            const result = await checkKillTarget({
+              name: nameArg,
+              signal: "FORCE",
+              cmd: fullCommand
+            });
+            if (result.blocked) return result;
+          }
+        }
+        if (a === "-Id" || a === "-PID" || a === "-pid") {
+          const pidArg = args[i + 1];
+          if (pidArg && /^\d+$/.test(pidArg)) {
+            const result = await checkKillTarget({
+              pid: parseInt(pidArg, 10),
+              signal: "FORCE",
+              cmd: fullCommand
+            });
+            if (result.blocked) return result;
+          }
+        }
+      }
+      const firstNonFlag = args.find((a) => !a.startsWith("-"));
+      if (firstNonFlag) {
+        const name = firstNonFlag.replace(/^['"]|['"]$/g, "");
+        const result = await checkKillTarget({ name, signal: "TERM", cmd: fullCommand });
+        if (result.blocked) return result;
+      }
+    }
+    if (cmdLower === "wmic" || cmdLower === "wmic.exe") {
+      const joined = args.join(" ").toLowerCase();
+      if (/\bprocess\b/.test(joined) && /\bdelete\b/.test(joined)) {
+        const nameMatch = joined.match(/name\s*=\s*['"]?([^'"]+)/);
+        if (nameMatch?.[1]) {
+          const result = await checkKillTarget({
+            name: nameMatch[1].trim(),
+            signal: "FORCE",
+            cmd: fullCommand
+          });
+          if (result.blocked) return result;
+        }
+        return {
+          blocked: true,
+          reason: "Blocked: wmic process delete targets all matched processes \u2014 would include protected WrongStack processes."
+        };
+      }
+    }
+    if (cmdLower === "node" || cmdLower === "node.exe") {
+      if (args.includes("-e") || args.includes("--eval")) {
+        const evalIdx = args.indexOf("-e") !== -1 ? args.indexOf("-e") : args.indexOf("--eval");
+        const evalCode = args[evalIdx + 1] ?? "";
+        if (/\bprocess\.kill\s*\(/.test(evalCode)) {
+          const pidMatch = evalCode.match(/process\.kill\s*\(\s*(\d+)/);
+          if (pidMatch?.[1]) {
+            const pid = parseInt(pidMatch[1], 10);
+            const result = await checkKillTarget({ pid, signal: "SIGTERM", cmd: fullCommand });
+            if (result.blocked) return result;
+          }
+          return {
+            blocked: true,
+            reason: "Blocked: node -e with process.kill() \u2014 would target protected WrongStack process(es)."
+          };
+        }
+      }
+    }
+  } else {
+    if (cmdLower === "kill") {
+      for (const a of args) {
+        const num = a.replace(/^-/, "");
+        if (/^\d+$/.test(num)) {
+          const pid = parseInt(num, 10);
+          const result = await checkKillTarget({ pid, signal: "SIGTERM", cmd: fullCommand });
+          if (result.blocked) return result;
+        }
+      }
+    }
+    if (cmdLower === "pkill" || cmdLower === "killall") {
+      const firstNonFlag = args.find((a) => !a.startsWith("-"));
+      if (firstNonFlag) {
+        const result = await checkKillTarget({
+          name: firstNonFlag,
+          signal: "SIGTERM",
+          cmd: fullCommand
+        });
+        if (result.blocked) return result;
+      }
+    }
+  }
+  return { blocked: false };
+}
+function tokenizeShellCommand(command) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  for (const char of command.trim()) {
+    if (quote) {
+      if (char === quote) quote = null;
+      else current += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+    } else if (/\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
+async function checkKillTarget(target) {
+  const registry = getPersistentProcessRegistry();
+  if (target.pid !== void 0) {
+    const blocked = await registry.shouldBlockKill(target.pid);
+    if (blocked) {
+      return {
+        blocked: true,
+        reason: `Blocked: kill ${target.signal} PID ${target.pid} targets a protected WrongStack process (${target.cmd.slice(0, 80)}).`
+      };
+    }
+    if (target.pid === process.pid) {
+      return {
+        blocked: true,
+        reason: "Blocked: cannot kill the current WrongStack process."
+      };
+    }
+    if (target.pid === process.ppid) {
+      return {
+        blocked: true,
+        reason: "Blocked: cannot kill the parent terminal hosting WrongStack."
+      };
+    }
+    return { blocked: false };
+  }
+  if (target.name) {
+    const nameLower = target.name.toLowerCase().replace(/\.exe$/, "");
+    if (nameLower.includes("wrongstack")) {
+      return {
+        blocked: true,
+        reason: `Blocked: kill ${target.signal} '${target.name}' targets a WrongStack process name.`
+      };
+    }
+    const currentImage = path24.basename(process.execPath).toLowerCase().replace(/\.exe$/, "");
+    const targetsNodeRuntime = nameLower === "node" || nameLower.startsWith("node");
+    if (targetsNodeRuntime && currentImage === "node") {
+      return {
+        blocked: true,
+        reason: `Blocked: kill ${target.signal} '${target.name}' would kill the active WrongStack node.exe runtime.`
+      };
+    }
+    const protectedPids = await registry.getAllProtectedPids();
+    if (protectedPids.length > 0 && targetsNodeRuntime) {
+      return {
+        blocked: true,
+        reason: `Blocked: kill ${target.signal} '${target.name}' would kill all node.exe processes including active WrongStack instance(s).`
+      };
+    }
+    return { blocked: false };
+  }
+  return { blocked: false };
+}
+
+// src/exec.ts
+var isWin4 = process.platform === "win32";
 var DEFAULT_ALLOWED_COMMANDS = /* @__PURE__ */ new Set([
   // JS / TS toolchain
   "node",
@@ -14094,6 +14457,19 @@ var execTool = {
     const args = (input.args ?? []).slice(0, MAX_ARGS);
     const timeout = Math.max(1, Math.min(input.timeout ?? DEFAULT_TIMEOUT_MS3, DEFAULT_TIMEOUT_MS3));
     const danger = detectDanger(cmd, args, dangerBypass);
+    const killCheck = await checkExecKillCommand(cmd, args);
+    if (killCheck.blocked) {
+      return {
+        command: cmd,
+        args,
+        stdout: "",
+        stderr: killCheck.reason ?? "Kill command blocked: targets a protected WrongStack process.",
+        exitCode: 1,
+        truncated: false,
+        allowed: false,
+        danger
+      };
+    }
     const argError = validateArgs(cmd, args);
     if (argError) {
       return {
@@ -14144,7 +14520,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
     let timedOut = false;
     const spool = createOutputSpool({ tool: `exec-${cmd}`, thresholdBytes: MAX_OUTPUT2 });
     const resolved = resolveWin32Command(cmd);
-    const needsShell = isWin3 && (resolved.endsWith(".cmd") || resolved.endsWith(".bat"));
+    const needsShell = isWin4 && (resolved.endsWith(".cmd") || resolved.endsWith(".bat"));
     const shim = needsShell ? buildWin32CmdShimInvocation(resolved, args) : null;
     const spawnCmd = shim?.command ?? resolved;
     const spawnArgs = shim?.args ?? args;
@@ -14169,7 +14545,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
         env: buildChildEnv2(sessionId),
         stdio: ["ignore", "pipe", "pipe"],
         windowsHide: true,
-        ...isWin3 ? {} : { signal },
+        ...isWin4 ? {} : { signal },
         ...shim ? { windowsVerbatimArguments: shim.windowsVerbatimArguments } : {}
       });
     } catch (err) {
@@ -14208,7 +14584,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
       const isAbort = err && err.code === "ABORT_ERR";
       const stderrText = isAbort ? `Aborted: ${err.message}` : err.message;
       clearTimeout(timer);
-      if (isWin3) signal.removeEventListener("abort", onAbort);
+      if (isWin4) signal.removeEventListener("abort", onAbort);
       if (typeof pid === "number") registry.unregister(pid);
       registry.afterCall(Date.now() - startedAt, true);
       spool.finalize();
@@ -14241,7 +14617,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
       if (typeof pid === "number") registry.kill(pid, { force: true });
       else child.kill("SIGTERM");
     };
-    if (isWin3) {
+    if (isWin4) {
       if (signal.aborted) onAbort();
       else signal.addEventListener("abort", onAbort, { once: true });
     }
@@ -14261,7 +14637,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      if (isWin3) signal.removeEventListener("abort", onAbort);
+      if (isWin4) signal.removeEventListener("abort", onAbort);
       if (typeof pid === "number") registry.unregister(pid);
       const durationMs = Date.now() - startedAt;
       const exitCode = killed ? 124 : code ?? 1;
@@ -15072,7 +15448,7 @@ function runGit2(args, cwd, signal) {
 
 // src/glob.ts
 import * as fs20 from "node:fs/promises";
-import * as path24 from "node:path";
+import * as path25 from "node:path";
 import { compileGlob as compileGlob3 } from "@wrongstack/core";
 
 // src/_concurrency.ts
@@ -15176,7 +15552,7 @@ var globTool = {
         if (DEFAULT_IGNORE2.includes(name)) continue;
         if (ignored.includes(name)) continue;
         const rel = relPrefix ? `${relPrefix}/${name}` : name;
-        const full = path24.join(dir, name);
+        const full = path25.join(dir, name);
         if (e.isDirectory()) {
           subdirs.push({ full, rel });
         } else if (e.isFile()) {
@@ -15220,7 +15596,7 @@ var globTool = {
 };
 async function readGitignore(dir) {
   try {
-    const raw = await fs20.readFile(path24.join(dir, ".gitignore"), "utf8");
+    const raw = await fs20.readFile(path25.join(dir, ".gitignore"), "utf8");
     return raw.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
   } catch {
     return [];
@@ -15231,7 +15607,7 @@ async function readGitignore(dir) {
 import { expectDefined as expectDefined7 } from "@wrongstack/core";
 import { spawn as spawn10 } from "node:child_process";
 import * as fs21 from "node:fs/promises";
-import * as path25 from "node:path";
+import * as path26 from "node:path";
 import { buildChildEnv as buildChildEnv5, compileGlob as compileGlob4, ToolValidationError as ToolValidationError4 } from "@wrongstack/core";
 
 // src/_regex.ts
@@ -15624,7 +16000,7 @@ async function runNative(input, base, mode, limit, signal) {
       if (stopped) return;
       if (DEFAULT_IGNORE3.includes(e.name)) continue;
       if (e.isSymbolicLink()) continue;
-      const full = path25.join(dir, e.name);
+      const full = path26.join(dir, e.name);
       if (e.isDirectory()) {
         subdirs.push(full);
       } else if (e.isFile()) {
@@ -16212,56 +16588,56 @@ function jmespathSearch(data, query) {
 }
 function validateJsonSchema(data, schema) {
   const errors = [];
-  function check(value, s, path33) {
+  function check(value, s, path34) {
     if (s["type"]) {
       const expectedType = s["type"];
       const actualType = Array.isArray(value) ? "array" : value === null ? "null" : typeof value;
       if (expectedType === "integer") {
-        if (!Number.isInteger(value)) errors.push(`${path33}: expected integer, got ${actualType}`);
+        if (!Number.isInteger(value)) errors.push(`${path34}: expected integer, got ${actualType}`);
       } else if (expectedType !== actualType) {
-        errors.push(`${path33}: expected ${expectedType}, got ${actualType}`);
+        errors.push(`${path34}: expected ${expectedType}, got ${actualType}`);
       }
     }
     if (typeof value === "string" && s["format"] === "uri" && value) {
       try {
         new URL(value);
       } catch {
-        errors.push(`${path33}: not a valid URI`);
+        errors.push(`${path34}: not a valid URI`);
       }
     }
     if (typeof value === "string" && s["pattern"]) {
       const re = new RegExp(s["pattern"]);
-      if (!re.test(value)) errors.push(`${path33}: does not match pattern ${s["pattern"]}`);
+      if (!re.test(value)) errors.push(`${path34}: does not match pattern ${s["pattern"]}`);
     }
     if (typeof value === "string" && s["minLength"] !== void 0 && value.length < s["minLength"]) {
-      errors.push(`${path33}: string too short (min ${s["minLength"]})`);
+      errors.push(`${path34}: string too short (min ${s["minLength"]})`);
     }
     if (typeof value === "string" && s["maxLength"] !== void 0 && value.length > s["maxLength"]) {
-      errors.push(`${path33}: string too long (max ${s["maxLength"]})`);
+      errors.push(`${path34}: string too long (max ${s["maxLength"]})`);
     }
     if (typeof value === "number" && s["minimum"] !== void 0 && value < s["minimum"]) {
-      errors.push(`${path33}: below minimum ${s["minimum"]}`);
+      errors.push(`${path34}: below minimum ${s["minimum"]}`);
     }
     if (typeof value === "number" && s["maximum"] !== void 0 && value > s["maximum"]) {
-      errors.push(`${path33}: above maximum ${s["maximum"]}`);
+      errors.push(`${path34}: above maximum ${s["maximum"]}`);
     }
     if (Array.isArray(value) && s["items"] && Array.isArray(s["items"])) {
       for (let i = 0; i < value.length; i++) {
-        check(value[i], s["items"], `${path33}[${i}]`);
+        check(value[i], s["items"], `${path34}[${i}]`);
       }
     }
     if (typeof value === "object" && value !== null && !Array.isArray(value) && s["properties"]) {
       const props = s["properties"];
       for (const [k, propSchema] of Object.entries(props)) {
-        check(value[k], propSchema, `${path33}.${k}`);
+        check(value[k], propSchema, `${path34}.${k}`);
       }
     }
   }
   check(data, schema, "$");
   return { valid: errors.length === 0, errors };
 }
-function simpleQuery(data, path33) {
-  const parts = path33.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+function simpleQuery(data, path34) {
+  const parts = path34.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
   let current = data;
   for (const part of parts) {
     if (current === null || current === void 0) return void 0;
@@ -16364,7 +16740,7 @@ import {
 
 // src/session-kanban.ts
 import { watch } from "node:fs";
-import { basename as basename9, dirname as dirname13 } from "node:path";
+import { basename as basename10, dirname as dirname13 } from "node:path";
 import {
   deserializeTaskGraph,
   GlobalMailbox,
@@ -16846,8 +17222,8 @@ function attachSessionKanbanMirror(context) {
         const name = filename?.toString();
         const currentPlanPath = context.meta["plan.path"];
         const currentTaskPath = context.meta["task.path"];
-        const planName = typeof currentPlanPath === "string" ? basename9(currentPlanPath) : "";
-        const taskName = typeof currentTaskPath === "string" ? basename9(currentTaskPath) : "";
+        const planName = typeof currentPlanPath === "string" ? basename10(currentPlanPath) : "";
+        const taskName = typeof currentTaskPath === "string" ? basename10(currentTaskPath) : "";
         if (name && name !== planName && name !== taskName) return;
         if (timer) clearTimeout(timer);
         timer = setTimeout(() => fireAndForget(refreshFiles()), 60);
@@ -18307,7 +18683,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
 }
 var DOCKER_LOGS_TIMEOUT_MS = 3e3;
 var MAX_TAIL_LINES = 1e5;
-async function fileLogs(path33, lines, filterRe, stream) {
+async function fileLogs(path34, lines, filterRe, stream) {
   const { createInterface } = await import("node:readline");
   const { createReadStream: createReadStream2 } = await import("node:fs");
   const entries = [];
@@ -18316,7 +18692,7 @@ async function fileLogs(path33, lines, filterRe, stream) {
   let writeIdx = 0;
   let totalLines = 0;
   const rl = createInterface({
-    input: createReadStream2(path33),
+    input: createReadStream2(path34),
     crlfDelay: Number.POSITIVE_INFINITY
   });
   for await (const line of rl) {
@@ -18337,7 +18713,7 @@ async function fileLogs(path33, lines, filterRe, stream) {
     if (parsed) entries.push(parsed);
   }
   return {
-    source: path33,
+    source: path34,
     entries,
     total: entries.length,
     truncated: totalLines > effLines,
@@ -18568,8 +18944,8 @@ function parseOutdatedOutput(json2, exitCode) {
 init_util();
 import { spawn as spawn13 } from "node:child_process";
 import * as fs23 from "node:fs/promises";
-import * as os7 from "node:os";
-import * as path26 from "node:path";
+import * as os8 from "node:os";
+import * as path27 from "node:path";
 import { buildChildEnv as buildChildEnv8 } from "@wrongstack/core";
 var patchTool = {
   name: "patch",
@@ -18605,9 +18981,9 @@ var patchTool = {
     for (const t of targets) {
       const stripped = stripPathComponents(t, strip);
       if (!stripped) continue;
-      const candidate = path26.resolve(dir, stripped);
-      const rel = path26.relative(ctx.projectRoot, candidate);
-      if (rel.startsWith("..") || path26.isAbsolute(rel)) {
+      const candidate = path27.resolve(dir, stripped);
+      const rel = path27.relative(ctx.projectRoot, candidate);
+      if (rel.startsWith("..") || path27.isAbsolute(rel)) {
         return {
           applied: 0,
           rejected: 1,
@@ -18624,11 +19000,11 @@ var patchTool = {
         beforeContents.set(target, await readTextForTracking(target));
       }
     }
-    const tmpDir = await fs23.mkdtemp(path26.join(os7.tmpdir(), ".wstack_patch_"));
+    const tmpDir = await fs23.mkdtemp(path27.join(os8.tmpdir(), ".wstack_patch_"));
     try {
       await fs23.chmod(tmpDir, 448).catch(() => {
       });
-      const patchFile = path26.join(tmpDir, "in.diff");
+      const patchFile = path27.join(tmpDir, "in.diff");
       await fs23.writeFile(patchFile, input.patch, { mode: 384 });
       const args = [`-p${strip}`, "--merge", ...dryRun ? ["--dry-run"] : [], "-i", patchFile];
       const result = await runPatch(args, dir, opts.signal);
@@ -19214,7 +19590,7 @@ ${interesting.join("\n")}` : "symbols/imports: (none detected)"
 import { expectDefined as expectDefined8 } from "@wrongstack/core";
 import { spawn as spawn14 } from "node:child_process";
 import * as fs25 from "node:fs/promises";
-import * as path27 from "node:path";
+import * as path28 from "node:path";
 import {
   atomicWrite as atomicWrite3,
   buildChildEnv as buildChildEnv9,
@@ -19303,8 +19679,8 @@ var replaceTool = {
       } catch {
         continue;
       }
-      const rel = path27.relative(realRoot, realPath);
-      if (rel.startsWith("..") || path27.isAbsolute(rel)) continue;
+      const rel = path28.relative(realRoot, realPath);
+      if (rel.startsWith("..") || path28.isAbsolute(rel)) continue;
       const stat18 = await fs25.stat(realPath).catch(() => null);
       if (!stat18?.isFile()) continue;
       let content;
@@ -19433,7 +19809,7 @@ async function globNative(pattern, base, extraGlob) {
     }
     for (const e of entries) {
       if (DEFAULT_IGNORE4.includes(e.name)) continue;
-      const full = path27.join(dir, e.name);
+      const full = path28.join(dir, e.name);
       try {
         const stat18 = await fs25.lstat(full);
         if (stat18.isSymbolicLink()) continue;
@@ -19460,7 +19836,7 @@ async function globNative(pattern, base, extraGlob) {
 // src/scaffold.ts
 init_util();
 import * as fs26 from "node:fs/promises";
-import * as path28 from "node:path";
+import * as path29 from "node:path";
 import { atomicWrite as atomicWrite4 } from "@wrongstack/core";
 var BUILT_IN_TEMPLATES = {
   "npm-package": {
@@ -19610,16 +19986,16 @@ async function handleBuiltIn(name, templateFiles, cwd, ctx, dryRun, vars) {
   let filesCreated = 0;
   for (const [filePath, content] of Object.entries(templateFiles)) {
     const resolvedPath = substituteVars(filePath, name, vars);
-    const joinedPath = path28.join(cwd, resolvedPath);
-    const root = path28.resolve(ctx.projectRoot);
-    const target = path28.resolve(joinedPath);
-    const rel = path28.relative(root, target);
-    if (rel.startsWith("..") || path28.isAbsolute(rel)) {
+    const joinedPath = path29.join(cwd, resolvedPath);
+    const root = path29.resolve(ctx.projectRoot);
+    const target = path29.resolve(joinedPath);
+    const rel = path29.relative(root, target);
+    if (rel.startsWith("..") || path29.isAbsolute(rel)) {
       throw new Error(`scaffold: generated path "${resolvedPath}" would escape project root`);
     }
     const fullPath = target;
     if (!dryRun) {
-      await fs26.mkdir(path28.dirname(fullPath), { recursive: true });
+      await fs26.mkdir(path29.dirname(fullPath), { recursive: true });
       await atomicWrite4(fullPath, substituteVars(content, name, vars));
     }
     files.push(resolvedPath);
@@ -20476,7 +20852,7 @@ ${formatTaskList2(file.tasks)}` : file.tasks.length > 0 ? formatTaskList2(file.t
 init_spawn_stream();
 init_util();
 init_legacy_bridge();
-import * as path29 from "node:path";
+import * as path30 from "node:path";
 var testTool = {
   name: "test",
   category: "Code Quality",
@@ -20583,7 +20959,7 @@ async function detectRunner(cwd) {
   const candidates = ["vitest.config.ts", "jest.config.js", ".mocharc.json"];
   for (const f of candidates) {
     try {
-      await stat18(path29.join(cwd, f));
+      await stat18(path30.join(cwd, f));
       if (f.includes("vitest")) return "vitest";
       if (f.includes("jest")) return "jest";
       if (f.includes("mocha")) return "mocha";
@@ -21054,7 +21430,7 @@ var toolUseTool = {
 init_util();
 import { expectDefined as expectDefined10 } from "@wrongstack/core";
 import * as fs28 from "node:fs/promises";
-import * as path30 from "node:path";
+import * as path31 from "node:path";
 var DEFAULT_IGNORE5 = [
   "node_modules",
   ".git",
@@ -21225,7 +21601,7 @@ async function walkDir(dir, depth, opts) {
     opts.lines.push(opts.prefix + branch + displayName);
     if (entry.isDirectory() && (opts.maxDepth === 0 || depth < opts.maxDepth)) {
       const childPrefix = opts.prefix + connector;
-      await walkDir(path30.join(dir, entry.name), depth + 1, {
+      await walkDir(path31.join(dir, entry.name), depth + 1, {
         ...opts,
         prefix: childPrefix,
         isLast
@@ -21238,7 +21614,7 @@ async function walkDir(dir, depth, opts) {
 init_spawn_stream();
 init_util();
 init_legacy_bridge();
-import * as path31 from "node:path";
+import * as path32 from "node:path";
 var typecheckTool = {
   name: "typecheck",
   category: "Code Quality",
@@ -21341,8 +21717,8 @@ async function findTsConfig(cwd) {
   const candidates = ["tsconfig.json", "tsconfig.base.json"];
   for (const f of candidates) {
     try {
-      const s = await stat18(path31.join(cwd, f));
-      if (s.isFile()) return path31.join(cwd, f);
+      const s = await stat18(path32.join(cwd, f));
+      if (s.isFile()) return path32.join(cwd, f);
     } catch {
     }
   }
@@ -21875,7 +22251,7 @@ var builtinToolsPack = {
 };
 
 // src/process-guardian.ts
-import * as os8 from "node:os";
+import * as os9 from "node:os";
 var ProcessGuardian = class {
   registry;
   config;
@@ -21914,7 +22290,7 @@ var ProcessGuardian = class {
       event: "process_guardian.started",
       instanceId: this.instanceId,
       mainPid: process.pid,
-      hostname: os8.hostname(),
+      hostname: os9.hostname(),
       platform: process.platform
     }));
   }
@@ -22103,8 +22479,8 @@ var ProcessGuardian = class {
       instanceId: this.instanceId,
       mainPid: process.pid,
       protectedCount: this.protectedProcesses.size,
-      platform: os8.platform(),
-      hostname: os8.hostname(),
+      platform: os9.platform(),
+      hostname: os9.hostname(),
       uptime: process.uptime()
     };
   }
@@ -22133,7 +22509,7 @@ function stopProcessGuardian() {
 init_process_registry();
 
 // src/ps-slash.ts
-import * as os9 from "node:os";
+import * as os10 from "node:os";
 var IDLE_THRESHOLD_MS = 2 * 6e4;
 var STALE_THRESHOLD_MS2 = 5 * 6e4;
 function now() {
@@ -22174,7 +22550,7 @@ async function listInstances(options = {}) {
     const mainProc = processes.find((p) => p.spawnMode === "main");
     const firstProc = processes.at(0);
     const mainPid = mainProc?.pid ?? firstProc?.pid ?? 0;
-    const hostname_ = firstProc?.hostname ?? os9.hostname();
+    const hostname_ = firstProc?.hostname ?? os10.hostname();
     const startedAt = Math.min(...processes.map((p) => p.startedAt));
     const lastActivity = Math.max(...processes.map((p) => p.lastHeartbeat));
     const age = timestamp - lastActivity;
@@ -22262,7 +22638,7 @@ async function getGlobalProcessStatus() {
       mainPid: process.pid,
       protectedCount: 0,
       platform: process.platform,
-      hostname: os9.hostname(),
+      hostname: os10.hostname(),
       uptime: 0
     },
     allInstances: instances.map((inst) => ({
@@ -22447,7 +22823,7 @@ function createGlobalPsSlashCommand() {
 
 // src/skill.ts
 import * as fs30 from "node:fs/promises";
-import * as path32 from "node:path";
+import * as path33 from "node:path";
 import {
   SKILL_LIMITS,
   stripFrontmatter,
@@ -22494,7 +22870,7 @@ function makeSkillTool(skillLoader) {
           field: "name"
         });
       }
-      const dir = path32.dirname(manifest.path);
+      const dir = path33.dirname(manifest.path);
       let loadedResource;
       if (input.resource?.trim()) {
         loadedResource = await loadResource(dir, input.resource.trim());
@@ -22544,15 +22920,15 @@ ${listing}`;
 }
 async function loadResource(skillDir, rel) {
   const norm = rel.replace(/\\/g, "/");
-  if (path32.isAbsolute(rel) || norm.split("/").some((seg) => seg === "..")) {
+  if (path33.isAbsolute(rel) || norm.split("/").some((seg) => seg === "..")) {
     throw new ToolValidationError10({
       message: `skill: invalid resource path "${rel}"`,
       field: "resource"
     });
   }
-  const absPath = path32.resolve(skillDir, rel);
-  const root = path32.resolve(skillDir);
-  if (absPath !== root && !absPath.startsWith(root + path32.sep)) {
+  const absPath = path33.resolve(skillDir, rel);
+  const root = path33.resolve(skillDir);
+  if (absPath !== root && !absPath.startsWith(root + path33.sep)) {
     throw new ToolValidationError10({
       message: `skill: resource "${rel}" escapes the skill directory`,
       field: "resource"
@@ -22593,7 +22969,7 @@ async function walk(root, dir, out) {
   }
   for (const e of entries) {
     if (out.length >= MAX_LISTED_RESOURCES) return;
-    const fullPath = path32.join(dir, e.name);
+    const fullPath = path33.join(dir, e.name);
     let isDir = e.isDirectory();
     if (e.isSymbolicLink()) {
       try {
@@ -22609,7 +22985,7 @@ async function walk(root, dir, out) {
       if (e.name === "SKILL.md" || e.name === "SKILL.save.md") continue;
       try {
         const stat18 = await fs30.stat(fullPath);
-        const rel = path32.relative(root, fullPath).split(path32.sep).join("/");
+        const rel = path33.relative(root, fullPath).split(path33.sep).join("/");
         out.push({ path: rel, bytes: stat18.size });
       } catch {
       }
@@ -22832,6 +23208,7 @@ export {
   builtinTools,
   builtinToolsPack,
   cancelPendingReindexes,
+  checkExecKillCommand,
   codebaseIndexStats,
   codebaseIndexTool,
   codebaseSearchTool,