@wrongstack/tools 0.291.0 → 0.291.2

package/dist/builtin.js

@@ -639,8 +639,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) {
@@ -2605,8 +2605,8 @@ async function scanDirectory(directory, depth, profiles, limits, state, extraIgn
     collectFileEvidence(directory, fullPath, entry.name, profiles, state);
   }
 }
-function collectFileEvidence(directory, fullPath, basename9, profiles, state) {
-  const lower = basename9.toLowerCase();
+function collectFileEvidence(directory, fullPath, basename10, profiles, state) {
+  const lower = basename10.toLowerCase();
   const extension = path4.extname(lower);
   for (const profile of profiles) {
     const detector = profile.detectors.find(
@@ -2617,7 +2617,7 @@ function collectFileEvidence(directory, fullPath, basename9, profiles, state) {
       candidate.evidence.push({
         kind: detector.kind,
         path: fullPath,
-        value: basename9,
+        value: basename10,
         weight: detector.weight
       });
       if (detector.kind === "manifest" || detector.kind === "config") {
@@ -3934,15 +3934,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 path32 of after) {
-    if (!beforeSet.has(path32)) changed.add(path32);
+  for (const path33 of after) {
+    if (!beforeSet.has(path33)) changed.add(path33);
   }
-  for (const path32 of before) {
-    if (!afterSet.has(path32)) changed.add(path32);
+  for (const path33 of before) {
+    if (!afterSet.has(path33)) changed.add(path33);
   }
   if (beforeSizes && afterSizes) {
-    for (const path32 of after) {
-      if (beforeSizes.get(path32) !== afterSizes.get(path32)) changed.add(path32);
+    for (const path33 of after) {
+      if (beforeSizes.get(path33) !== afterSizes.get(path33)) changed.add(path33);
     }
   }
   return [...changed].sort();
@@ -5374,17 +5374,18 @@ function getPersistentProcessRegistry() {
 
 // 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];
@@ -5396,22 +5397,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
@@ -5419,18 +5445,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];
@@ -5490,6 +5607,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();
@@ -5529,6 +5649,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)) {
@@ -5552,8 +5678,8 @@ async function checkAndBlockKillCommand(command) {
 
 // src/_shell-pick.ts
 var POSIX_DEFAULT = "cmd";
-function pickShell(platform4, command, env) {
-  if (platform4 !== "win32") return POSIX_DEFAULT;
+function pickShell(platform5, command, env) {
+  if (platform5 !== "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";
@@ -5757,10 +5883,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]
       });
@@ -5789,7 +5915,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 = "";
@@ -5807,7 +5933,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) {
@@ -5918,7 +6044,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 {
@@ -5971,7 +6097,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) {
@@ -6012,7 +6138,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 });
     }
@@ -6126,7 +6252,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();
@@ -9998,9 +10124,9 @@ function parseSymbols5(opts) {
 function regexParse2(opts) {
   const { file, content, lang } = opts;
   const symbols = [];
-  const basename9 = path17.basename(file).toLowerCase();
-  const isPackageJson = basename9 === "package.json";
-  const isTsconfig = basename9 === "tsconfig.json" || basename9 === "tsconfig.build.json";
+  const basename10 = path17.basename(file).toLowerCase();
+  const isPackageJson = basename10 === "package.json";
+  const isTsconfig = basename10 === "tsconfig.json" || basename10 === "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");
@@ -13154,8 +13280,243 @@ function levelRank(level) {
   }
 }
 
+// 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 isWin3 = process.platform === "win32";
+var isWin4 = process.platform === "win32";
 var DEFAULT_ALLOWED_COMMANDS = /* @__PURE__ */ new Set([
   // JS / TS toolchain
   "node",
@@ -13931,6 +14292,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 {
@@ -13981,7 +14355,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;
@@ -14006,7 +14380,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) {
@@ -14045,7 +14419,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();
@@ -14078,7 +14452,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 });
     }
@@ -14098,7 +14472,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;
@@ -14909,7 +15283,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
@@ -15013,7 +15387,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()) {
@@ -15057,7 +15431,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 [];
@@ -15068,7 +15442,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
@@ -15461,7 +15835,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()) {
@@ -16049,56 +16423,56 @@ function jmespathSearch(data, query) {
 }
 function validateJsonSchema(data, schema) {
   const errors = [];
-  function check(value, s, path32) {
+  function check(value, s, path33) {
     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(`${path32}: expected integer, got ${actualType}`);
+        if (!Number.isInteger(value)) errors.push(`${path33}: expected integer, got ${actualType}`);
       } else if (expectedType !== actualType) {
-        errors.push(`${path32}: expected ${expectedType}, got ${actualType}`);
+        errors.push(`${path33}: expected ${expectedType}, got ${actualType}`);
       }
     }
     if (typeof value === "string" && s["format"] === "uri" && value) {
       try {
         new URL(value);
       } catch {
-        errors.push(`${path32}: not a valid URI`);
+        errors.push(`${path33}: not a valid URI`);
       }
     }
     if (typeof value === "string" && s["pattern"]) {
       const re = new RegExp(s["pattern"]);
-      if (!re.test(value)) errors.push(`${path32}: does not match pattern ${s["pattern"]}`);
+      if (!re.test(value)) errors.push(`${path33}: does not match pattern ${s["pattern"]}`);
     }
     if (typeof value === "string" && s["minLength"] !== void 0 && value.length < s["minLength"]) {
-      errors.push(`${path32}: string too short (min ${s["minLength"]})`);
+      errors.push(`${path33}: string too short (min ${s["minLength"]})`);
     }
     if (typeof value === "string" && s["maxLength"] !== void 0 && value.length > s["maxLength"]) {
-      errors.push(`${path32}: string too long (max ${s["maxLength"]})`);
+      errors.push(`${path33}: string too long (max ${s["maxLength"]})`);
     }
     if (typeof value === "number" && s["minimum"] !== void 0 && value < s["minimum"]) {
-      errors.push(`${path32}: below minimum ${s["minimum"]}`);
+      errors.push(`${path33}: below minimum ${s["minimum"]}`);
     }
     if (typeof value === "number" && s["maximum"] !== void 0 && value > s["maximum"]) {
-      errors.push(`${path32}: above maximum ${s["maximum"]}`);
+      errors.push(`${path33}: 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"], `${path32}[${i}]`);
+        check(value[i], s["items"], `${path33}[${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, `${path32}.${k}`);
+        check(value[k], propSchema, `${path33}.${k}`);
       }
     }
   }
   check(data, schema, "$");
   return { valid: errors.length === 0, errors };
 }
-function simpleQuery(data, path32) {
-  const parts = path32.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+function simpleQuery(data, path33) {
+  const parts = path33.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
   let current = data;
   for (const part of parts) {
     if (current === null || current === void 0) return void 0;
@@ -17705,7 +18079,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
 }
 var DOCKER_LOGS_TIMEOUT_MS = 3e3;
 var MAX_TAIL_LINES = 1e5;
-async function fileLogs(path32, lines, filterRe, stream) {
+async function fileLogs(path33, lines, filterRe, stream) {
   const { createInterface } = await import("node:readline");
   const { createReadStream: createReadStream2 } = await import("node:fs");
   const entries = [];
@@ -17714,7 +18088,7 @@ async function fileLogs(path32, lines, filterRe, stream) {
   let writeIdx = 0;
   let totalLines = 0;
   const rl = createInterface({
-    input: createReadStream2(path32),
+    input: createReadStream2(path33),
     crlfDelay: Number.POSITIVE_INFINITY
   });
   for await (const line of rl) {
@@ -17735,7 +18109,7 @@ async function fileLogs(path32, lines, filterRe, stream) {
     if (parsed) entries.push(parsed);
   }
   return {
-    source: path32,
+    source: path33,
     entries,
     total: entries.length,
     truncated: totalLines > effLines,
@@ -17966,8 +18340,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",
@@ -18003,9 +18377,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,
@@ -18022,11 +18396,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);
@@ -18612,7 +18986,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,
@@ -18701,8 +19075,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 stat17 = await fs25.stat(realPath).catch(() => null);
       if (!stat17?.isFile()) continue;
       let content;
@@ -18831,7 +19205,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 stat17 = await fs25.lstat(full);
         if (stat17.isSymbolicLink()) continue;
@@ -18858,7 +19232,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": {
@@ -19008,16 +19382,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);
@@ -19874,7 +20248,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",
@@ -19981,7 +20355,7 @@ async function detectRunner(cwd) {
   const candidates = ["vitest.config.ts", "jest.config.js", ".mocharc.json"];
   for (const f of candidates) {
     try {
-      await stat17(path29.join(cwd, f));
+      await stat17(path30.join(cwd, f));
       if (f.includes("vitest")) return "vitest";
       if (f.includes("jest")) return "jest";
       if (f.includes("mocha")) return "mocha";
@@ -20452,7 +20826,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",
@@ -20623,7 +20997,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
@@ -20636,7 +21010,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",
@@ -20739,8 +21113,8 @@ async function findTsConfig(cwd) {
   const candidates = ["tsconfig.json", "tsconfig.base.json"];
   for (const f of candidates) {
     try {
-      const s = await stat17(path31.join(cwd, f));
-      if (s.isFile()) return path31.join(cwd, f);
+      const s = await stat17(path32.join(cwd, f));
+      if (s.isFile()) return path32.join(cwd, f);
     } catch {
     }
   }