@delt/claude-jev-advisor 0.2.0 → 0.4.0

package/dist/rm-hook.js

@@ -4,19 +4,123 @@
 import os from "os";
 
 // src/rm/guard.ts
+import path2 from "path";
+
+// src/rm/targets.ts
 import fs from "fs";
 import path from "path";
 import { spawnSync } from "child_process";
 var win = path.win32;
+var BUILD_DIRS = /* @__PURE__ */ new Set(["target", "build", "dist", "out", "node_modules", "coverage", "__pycache__", ".pytest_cache", ".gradle", ".next", ".nuxt", ".turbo", ".cache", "bin", "obj"]);
+var MAX_LISTED = 3;
+var emptyRead = () => ({ deny: null, targets: [], failed: [], shells: [] });
+var DELETE_WORDS = /(?<![\w.-])(?:rm|rmdir|del|erase|rd|ri|remove-item)(?![\w-])|(?:\.|::)\s*delete\w*/i;
+function isInside(child, parent) {
+  const c = child.toLowerCase();
+  const p = parent.toLowerCase().replace(/\\+$/, "");
+  return c.startsWith(`${p}\\`);
+}
+function segments(p) {
+  return p.toLowerCase().split("\\");
+}
+function judgePath(p, pattern, ctx) {
+  const shown = pattern === null ? p : `${p.replace(/\\$/, "")}\\${pattern}`;
+  const narrowPattern = pattern !== null && !/^[*?.]+$/.test(pattern);
+  if (ctx.tmpdirs.some((t) => isInside(p, t) || narrowPattern && p.toLowerCase() === t.toLowerCase().replace(/\\+$/, ""))) return null;
+  if (segments(p).includes(".superpowers")) return null;
+  if (pattern === null && !ctx.probe.exists(p)) return null;
+  if (segments(p).some((s) => BUILD_DIRS.has(s)) && ctx.probe.isIgnored(p)) return null;
+  return { shown, path: pattern === null ? p : null };
+}
+function splitPattern(value, wildcard) {
+  const cut = Math.max(value.lastIndexOf("/"), value.lastIndexOf("\\"));
+  if (wildcard.test(value.slice(0, Math.max(cut, 0)))) return null;
+  return { dir: value.slice(0, Math.max(cut, 0)) || ".", pattern: value.slice(cut + 1) };
+}
+function splitWindowsPattern(value, wildcard) {
+  const drive = /^([A-Za-z]:)([^\\/]*)$/.exec(value);
+  if (drive) return { dir: drive[1], pattern: drive[2] };
+  const split = splitPattern(value, wildcard);
+  if (split === null) return null;
+  const root = /^((?:[A-Za-z]:)?[\\/])[^\\/]*$/.exec(value);
+  return root ? { dir: root[1], pattern: split.pattern } : split;
+}
+function resolveWindowsPath(value, cwd, home) {
+  if (/^(?:\\\\|\/\/)/.test(value)) return { unc: value };
+  if (home !== null && /^~(?:[\\/]|$)/.test(value)) return { path: win.resolve(home, value.slice(2) || ".") };
+  if (/^[A-Za-z]:[\\/]/.test(value)) return { path: win.normalize(value) };
+  if (/^[A-Za-z]:/.test(value)) return { unresolvable: `a path relative to another drive's folder (${value})` };
+  if (cwd === null) return { unresolvable: `a path relative to a folder that cannot be worked out (${value})` };
+  return { path: win.resolve(cwd, value) };
+}
+var EXAMPLES = {
+  bash: {
+    what: "this rm",
+    rules: "no shell variables, command substitutions, xargs, brace expansion or wildcards in folder names, and no cd to such a path before it",
+    example: 'rm -f "C:/full/path/file.txt"',
+    then: "rm the printed paths"
+  },
+  powershell: {
+    what: "this PowerShell command",
+    rules: "no variables other than $env:TEMP, $env:TMP, $env:USERPROFILE, $HOME and $PWD, no expressions, script blocks or pipeline input, no wildcards in folder names, and no Set-Location to such a path before it",
+    example: 'Remove-Item -LiteralPath "C:\\full\\path\\file.txt"',
+    then: "delete the printed paths"
+  },
+  cmd: {
+    what: "this del or rd",
+    rules: "no variables other than %TEMP%, %TMP%, %USERPROFILE% and %CD%, no wildcards in folder names, and no cd to such a path before it",
+    example: 'del /q "C:\\full\\path\\file.txt"',
+    then: "delete the printed paths"
+  }
+};
+function denyReason(shell, why) {
+  const { what, rules, example, then } = EXAMPLES[shell];
+  return `rm-guard could not work out what ${what} would delete (${why}). Rewrite it with literal paths: ${rules}. Example: ${example}. If you need a variable or a listing to find the paths, run that on its own first, then ${then}.`;
+}
+function listed(targets) {
+  const names = targets.slice(0, MAX_LISTED).map((t) => t.shown).join(", ");
+  return targets.length > MAX_LISTED ? `${names} \uC678 ${targets.length - MAX_LISTED}\uAC1C` : names;
+}
+var UNREAD_TARGET = "(\uBD84\uC11D\uD558\uC9C0 \uBABB\uD55C \uBA85\uB839)";
+function decisionOf({ deny, targets, failed }) {
+  if (deny !== null) return { decision: "deny", reason: deny };
+  if (failed.length) {
+    const note = `\uC0AD\uC81C \uBA85\uB839\uC744 \uBD84\uC11D\uD558\uC9C0 \uBABB\uD568: ${failed[0]}`;
+    return { decision: "ask", reason: targets.length ? `\uC2E4\uC81C \uD30C\uC77C \uC0AD\uC81C: ${listed(targets)} \xB7 ${note}` : note, targets: [...targets, { shown: UNREAD_TARGET, path: null }] };
+  }
+  if (!targets.length) return null;
+  return { decision: "ask", reason: `\uC2E4\uC81C \uD30C\uC77C \uC0AD\uC81C: ${listed(targets)}`, targets };
+}
+function hookOutput({ decision, reason }) {
+  return JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: decision, permissionDecisionReason: reason } });
+}
+var realProbe = {
+  exists(p) {
+    try {
+      fs.lstatSync(p);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  isIgnored(p) {
+    const r = spawnSync("git", ["-C", win.dirname(p), "check-ignore", "-q", "--", p], { timeout: 3e3, windowsHide: true });
+    return r.status === 0;
+  }
+};
+
+// src/rm/guard.ts
+var win2 = path2.win32;
 var SEPARATORS = /* @__PURE__ */ new Set([";", "&&", "||", "|", "|&", "&", "(", ")"]);
 var SKIP_WORDS = /* @__PURE__ */ new Set(["then", "else", "elif", "do", "while", "until", "if", "!", "{", "time"]);
 var HEADER_WORDS = /* @__PURE__ */ new Set(["for", "select", "case"]);
 var CLOSING_WORDS = /* @__PURE__ */ new Set(["done", "fi", "esac", "}"]);
-var BUILD_DIRS = /* @__PURE__ */ new Set(["target", "build", "dist", "out", "node_modules", "coverage", "__pycache__", ".pytest_cache", ".gradle", ".next", ".nuxt", ".turbo", ".cache", "bin", "obj"]);
-var MAX_LISTED = 3;
 var ASSIGNMENT = /^([A-Za-z_][A-Za-z0-9_]*)=/;
 var DECLARERS = /* @__PURE__ */ new Set(["export", "readonly", "declare", "typeset", "local"]);
 var KNOWN_ENV = ["TEMP", "TMP", "TMPDIR", "HOME", "USERPROFILE"];
+var SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "cmd", "powershell", "pwsh"]);
+var NATIVE_SHELLS = /* @__PURE__ */ new Set(["cmd", "powershell", "pwsh"]);
+var SHELL_WORDS = /\b(?:sh|bash|cmd|powershell|pwsh)(?:\.exe)?\b/i;
 function stripHeredocs(text) {
   const out = [];
   const pending = [];
@@ -149,6 +253,7 @@ function tokenize(text) {
       if (word !== null && /^\d+$/.test(word.value) && !word.dynamic) word = null;
       else finish();
       const m = /^(&>>?|\d*[<>]+[&|]?)/.exec(text.slice(i));
+      if (/^\d*<<<?$/.test(m[0])) tokens.push({ type: "here" });
       i += m[0].length;
       if (/&$/.test(m[0]) && /^\d|^-/.test(text[i] ?? "")) {
         while (i < text.length && /[\d-]/.test(text[i])) i++;
@@ -177,13 +282,16 @@ function tokenize(text) {
 function splitCommands(tokens) {
   const commands = [];
   let current = [];
+  let here = false;
   for (const t of tokens) {
     if (t.type === "op" && SEPARATORS.has(t.value)) {
-      commands.push({ words: current, after: t.value });
+      commands.push({ words: current, after: t.value, here });
       current = [];
+      here = false;
     } else if (t.type === "word") current.push(t);
+    else if (t.type === "here") here = true;
   }
-  commands.push({ words: current, after: null });
+  commands.push({ words: current, after: null, here });
   return commands;
 }
 function expand(word, vars) {
@@ -207,7 +315,7 @@ function assign(word, vars, home) {
 }
 function commandName(word) {
   if (word.dynamic) return null;
-  return win.basename(word.value.replace(/\//g, "\\")).replace(/\.exe$/i, "").toLowerCase();
+  return win2.basename(word.value.replace(/\//g, "\\")).replace(/\.exe$/i, "").toLowerCase();
 }
 function stripPrefixes(words) {
   let rest = words;
@@ -235,23 +343,24 @@ function stripPrefixes(words) {
 }
 function toWindowsPath(word, cwd, home, tmpdir) {
   const v = word.value;
-  if (word.tilde && (v === "~" || v.startsWith("~/") || v.startsWith("~\\"))) return { path: win.resolve(home, v.slice(2) || ".") };
-  if (/^[A-Za-z]:[\\/]/.test(v)) return { path: win.normalize(v) };
+  if (word.tilde && (v === "~" || v.startsWith("~/") || v.startsWith("~\\"))) return { path: win2.resolve(home, v.slice(2) || ".") };
+  if (/^[A-Za-z]:[\\/]/.test(v)) return { path: win2.normalize(v) };
   const drive = /^\/([A-Za-z])(?:\/(.*))?$/.exec(v);
-  if (drive) return { path: win.normalize(`${drive[1].toUpperCase()}:\\${drive[2] ?? ""}`) };
+  if (drive) return { path: win2.normalize(`${drive[1].toUpperCase()}:\\${drive[2] ?? ""}`) };
   const tmp = /^\/tmp(?:\/(.*))?$/.exec(v);
-  if (tmp) return { path: win.resolve(tmpdir, tmp[1] ?? ".") };
+  if (tmp) return { path: win2.resolve(tmpdir, tmp[1] ?? ".") };
   if (v.startsWith("/")) return { unknown: v };
   if (cwd === null) return { unresolvable: "a relative path after cd to a path that cannot be worked out" };
-  return { path: win.resolve(cwd, v) };
-}
-function isInside(child, parent) {
-  const c = child.toLowerCase();
-  const p = parent.toLowerCase().replace(/\\+$/, "");
-  return c.startsWith(`${p}\\`);
+  return { path: win2.resolve(cwd, v) };
 }
-function segments(p) {
-  return p.toLowerCase().split("\\");
+function nativeArg(value, tmpdir) {
+  if (value === null || !value.startsWith("/") || value === "/?") return value;
+  if (value.startsWith("//")) return /^\/\/[^/]*$/.test(value) ? value.slice(1) : value;
+  const drive = /^\/([A-Za-z])(\/.*)?$/.exec(value);
+  if (drive) return `${drive[1].toUpperCase()}:${drive[2] ?? "/"}`;
+  const tmp = /^\/tmp(\/.*)?$/.exec(value);
+  if (tmp) return `${tmpdir}${(tmp[1] ?? "").replace(/\//g, "\\")}`;
+  return null;
 }
 function classify(target, ctx) {
   if (target.brace) return { unresolvable: `brace expansion (${target.value})` };
@@ -260,31 +369,19 @@ function classify(target, ctx) {
   let w = { ...target, value, dynamic: false };
   let pattern = null;
   if (target.glob) {
-    const parts = value.split(/[\\/]/);
-    if (parts.slice(0, -1).some((s) => /[*?[]/.test(s))) return { unresolvable: `a wildcard in a folder name (${target.value})` };
-    pattern = parts[parts.length - 1];
-    w = { ...w, value: parts.slice(0, -1).join("/") || "." };
+    const split = splitWindowsPattern(value, /[*?[]/);
+    if (split === null) return { unresolvable: `a wildcard in a folder name (${target.value})` };
+    pattern = split.pattern;
+    w = { ...w, value: split.dir };
   }
   const resolved = toWindowsPath(w, ctx.cwd, ctx.home, ctx.tmpdirs[0]);
   if (resolved.unresolvable) return { unresolvable: resolved.unresolvable };
   if (resolved.unknown) return { real: { shown: target.value, path: null } };
-  const p = resolved.path;
-  const shown = pattern === null ? p : `${p}\\${pattern}`;
-  const narrowPattern = pattern !== null && !/^[*?.]+$/.test(pattern);
-  if (ctx.tmpdirs.some((t) => isInside(p, t) || narrowPattern && p.toLowerCase() === t.toLowerCase().replace(/\\+$/, ""))) return {};
-  if (segments(p).includes(".superpowers")) return {};
-  if (pattern === null && !ctx.probe.exists(p)) return {};
-  if (segments(p).some((s) => BUILD_DIRS.has(s)) && ctx.probe.isIgnored(p)) return {};
-  return { real: { shown, path: pattern === null ? p : null } };
-}
-function deny(why) {
-  return {
-    decision: "deny",
-    reason: `rm-guard could not work out what this rm would delete (${why}). Rewrite it with literal paths: no shell variables, command substitutions, xargs, brace expansion or wildcards in folder names, and no cd to such a path before it. Example: rm -f "C:/full/path/file.txt". If you need a variable or a listing to find the paths, run that on its own first, then rm the printed paths.`
-  };
+  return { real: judgePath(resolved.path, pattern, ctx) ?? void 0 };
 }
-function decide({ command, cwd, home, tmpdirs, env = {}, probe }) {
-  if (!/\b(?:rm|rmdir|xargs)\b/.test(command)) return null;
+function readBash(command, { cwd, home, tmpdirs, env, probe }) {
+  const out = emptyRead();
+  if (!/\b(?:rm|rmdir|xargs)\b/.test(command) && !SHELL_WORDS.test(command)) return out;
   const commands = splitCommands(tokenize(stripHeredocs(command)));
   const vars = new Map(KNOWN_ENV.filter((n) => env[n]).map((n) => [n, env[n]]));
   const ctx = { cwd, home, tmpdirs, probe, vars };
@@ -292,10 +389,11 @@ function decide({ command, cwd, home, tmpdirs, env = {}, probe }) {
     ctx.cwd = next;
     vars.set("PWD", next);
   };
+  const deny = (why) => ({ ...out, deny: denyReason("bash", why) });
   setCwd(cwd);
   const stack = [];
-  const real = [];
-  for (const { words, after } of commands) {
+  let piped = false;
+  for (const { words, after, here } of commands) {
     const rest = stripPrefixes(words);
     if (!rest.length) {
       for (const w of words) if (ASSIGNMENT.test(w.value)) assign(w, vars, home);
@@ -315,9 +413,11 @@ function decide({ command, cwd, home, tmpdirs, env = {}, probe }) {
         if (rest.slice(1).some((t) => {
           const n = commandName(t);
           return n === "rm" || n === "rmdir";
-        })) {
-          return deny("xargs feeding rm");
-        }
+        })) return deny("xargs feeding rm");
+        if (rest.slice(1).some((t) => SHELLS.has(commandName(t) ?? "")) && DELETE_WORDS.test(rest.slice(1).map((t) => t.value).join(" "))) return deny("xargs feeding a shell that deletes");
+      } else if (name2 !== null && SHELLS.has(name2)) {
+        const args = rest.slice(1).map((t) => t.brace ? null : expand(t, vars));
+        out.shells.push({ name: name2, args: NATIVE_SHELLS.has(name2) ? args.map((a) => nativeArg(a, tmpdirs[0])) : args, cwd: ctx.cwd, raw: rest.map((t) => t.value).join(" "), ...piped || here ? { piped: true } : {} });
       } else if (name2 === "rm" || name2 === "rmdir") {
         let options = true;
         for (const t of rest.slice(1)) {
@@ -328,42 +428,23 @@ function decide({ command, cwd, home, tmpdirs, env = {}, probe }) {
           if (options && !t.dynamic && t.value.length > 1 && t.value.startsWith("-")) continue;
           const c = classify(t, ctx);
           if (c.unresolvable) return deny(c.unresolvable);
-          if (c.real) real.push(c.real);
+          if (c.real) out.targets.push(c.real);
         }
       }
     }
+    piped = after === "|" || after === "|&" || piped && !words.length && after === "(";
     if (after === "(") stack.push(ctx.cwd);
     if (after === ")" && stack.length) setCwd(stack.pop() ?? null);
   }
-  if (!real.length) return null;
-  const listed = real.slice(0, MAX_LISTED).map((t) => t.shown).join(", ");
-  const more = real.length > MAX_LISTED ? ` \uC678 ${real.length - MAX_LISTED}\uAC1C` : "";
-  return { decision: "ask", reason: `\uC2E4\uC81C \uD30C\uC77C \uC0AD\uC81C: ${listed}${more}`, targets: real };
-}
-function hookOutput({ decision, reason }) {
-  return JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: decision, permissionDecisionReason: reason } });
+  return out;
 }
-var realProbe = {
-  exists(p) {
-    try {
-      fs.lstatSync(p);
-      return true;
-    } catch {
-      return false;
-    }
-  },
-  isIgnored(p) {
-    const r = spawnSync("git", ["-C", win.dirname(p), "check-ignore", "-q", "--", p], { timeout: 3e3, windowsHide: true });
-    return r.status === 0;
-  }
-};
 
 // src/rm/run.ts
-import path7 from "path";
+import path10 from "path";
 
 // src/config.ts
 import fs2 from "fs";
-import path3 from "path";
+import path4 from "path";
 
 // src/config-shape.ts
 var CONFIG_VERSION = 2;
@@ -371,6 +452,7 @@ var DEFAULT_CONFIG = {
   lang: "ko",
   keyFile: null,
   display: "mod",
+  shortcut: null,
   context: { enabled: true, minTokens: 25e4, compactMinTokens: 25e4, redRemainingPct: 20, unitDoneYes: 0.6, phaseDoneYes: 0.6 },
   rm: { enabled: true, jev: true, throwawayYes: 0.8, maxDirFiles: 50 }
 };
@@ -398,17 +480,18 @@ function normalizeConfig(raw) {
     lang: typeof r.lang === "string" && LANGS.includes(r.lang) ? r.lang : DEFAULT_CONFIG.lang,
     keyFile: typeof r.keyFile === "string" && r.keyFile !== "" ? r.keyFile : null,
     display: typeof r.display === "string" && DISPLAYS.includes(r.display) ? r.display : DEFAULT_CONFIG.display,
+    shortcut: typeof r.shortcut === "string" && r.shortcut !== "" ? r.shortcut : null,
     context: mergeSection(DEFAULT_CONFIG.context, r.version === CONFIG_VERSION ? r.context : withoutLegacyDefaults(r.context)),
     rm: mergeSection(DEFAULT_CONFIG.rm, r.rm)
   };
 }
 
 // src/paths.ts
-import path2 from "path";
-var claudeDir = (home) => path2.join(home, ".claude");
-var dataDir = (home) => path2.join(claudeDir(home), "claude-jev-advisor");
-var configPath = (home) => path2.join(dataDir(home), "config.json");
-var logDir = (home) => path2.join(dataDir(home), "log");
+import path3 from "path";
+var claudeDir = (home) => path3.join(home, ".claude");
+var dataDir = (home) => path3.join(claudeDir(home), "claude-jev-advisor");
+var configPath = (home) => path3.join(dataDir(home), "config.json");
+var logDir = (home) => path3.join(dataDir(home), "log");
 
 // src/config.ts
 function readConfig(home) {
@@ -421,13 +504,13 @@ function readConfig(home) {
 
 // src/context/files.ts
 import fs3 from "fs";
-import path4 from "path";
+import path5 from "path";
 function logFile(home, now) {
-  return path4.join(logDir(home), `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}.jsonl`);
+  return path5.join(logDir(home), `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}.jsonl`);
 }
 function appendLog(home, now, record, secrets = []) {
   const file = logFile(home, now);
-  fs3.mkdirSync(path4.dirname(file), { recursive: true });
+  fs3.mkdirSync(path5.dirname(file), { recursive: true });
   let line = JSON.stringify({ at: now.toISOString(), ...record });
   for (const secret of secrets) {
     if (!secret) continue;
@@ -506,16 +589,796 @@ async function callJev(request, opts) {
   }
 }
 
+// src/rm/cmd.ts
+import path6 from "path";
+var win3 = path6.win32;
+var SHELLS2 = /* @__PURE__ */ new Set(["sh", "bash", "cmd", "powershell", "pwsh"]);
+var DELETES = /* @__PURE__ */ new Set(["del", "erase", "rd", "rmdir"]);
+var CONTROL = /* @__PURE__ */ new Set(["if", "else", "for", "call", "start"]);
+var UNKNOWN = "\0";
+var EXCERPT_CHARS = 200;
+function expandVars(line, vars) {
+  return line.replace(/%([^%\s"]+)%/g, (_m, name2) => vars.get(name2.toLowerCase()) ?? UNKNOWN).replace(/%~[^\s"]*/g, UNKNOWN).replace(/![^!\s"]+!/g, UNKNOWN);
+}
+function hasBlock(line) {
+  let quoted = false;
+  for (let i = 0; i < line.length; i++) {
+    if (line[i] === '"') quoted = !quoted;
+    else if (!quoted && line[i] === "^") i++;
+    else if (!quoted && (line[i] === "(" || line[i] === ")")) return true;
+  }
+  return false;
+}
+function segmentsOf(line) {
+  const out = [];
+  let current = "";
+  let piped = false;
+  let quoted = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (c === '"') quoted = !quoted;
+    if (!quoted && c === "^" && i + 1 < line.length) {
+      current += c + line[++i];
+      continue;
+    }
+    const redirect = c === "&" && /[<>]$/.test(current);
+    if (!quoted && !redirect && "&|\n".includes(c)) {
+      out.push({ text: current, piped });
+      current = "";
+      piped = c === "|" && line[i + 1] !== "|";
+      if ((c === "&" || c === "|") && line[i + 1] === c) i++;
+      continue;
+    }
+    current += c;
+  }
+  out.push({ text: current, piped });
+  return out.filter((s) => s.text.trim() !== "");
+}
+function wordsOf(segment, delimiters) {
+  const words = [];
+  let word = null;
+  let quoted = false;
+  let skipNext = false;
+  const start = () => word ??= { value: "", dynamic: false, shown: "", end: 0 };
+  const add = (c) => {
+    const w = start();
+    if (c === UNKNOWN) {
+      w.dynamic = true;
+      w.shown += "%?%";
+    } else {
+      w.value += c;
+      w.shown += c;
+    }
+  };
+  const finish = (at) => {
+    if (word === null) return;
+    word.end = at;
+    if (skipNext) skipNext = false;
+    else words.push(word);
+    word = null;
+  };
+  for (let i = 0; i < segment.length; i++) {
+    const c = segment[i];
+    if (c === '"') {
+      quoted = !quoted;
+      start();
+      continue;
+    }
+    if (quoted) {
+      add(c);
+      continue;
+    }
+    if (c === "^") {
+      if (i + 1 < segment.length) add(segment[++i]);
+      continue;
+    }
+    if (c === " " || c === "	" || c === "\r" || delimiters.includes(c)) {
+      finish(i);
+      continue;
+    }
+    if (c === ">" || c === "<") {
+      if (word !== null && /^\d$/.test(word.value) && !word.dynamic) word = null;
+      else finish(i);
+      while (segment[i + 1] === ">") i++;
+      if (segment[i + 1] === "&") {
+        i++;
+        while (/\d/.test(segment[i + 1] ?? "")) i++;
+        continue;
+      }
+      skipNext = true;
+      continue;
+    }
+    add(c);
+  }
+  finish(segment.length);
+  return words;
+}
+function nameOf(word) {
+  if (word.dynamic && /%\?%[^\\/]*$/.test(word.shown)) return null;
+  const text = word.value.replace(/^@/, "");
+  const glued = /^(del|erase|rd|rmdir|cd|chdir|pushd|popd|if|else|for|call|start)([/,;=].*)$/i.exec(text) ?? /^(cd|chdir|pushd)([.\\].*)$/i.exec(text);
+  if (glued) return { name: glued[1].toLowerCase(), rest: glued[2] };
+  return { name: win3.basename(text.replace(/\//g, "\\")).replace(/\.(?:exe|com)$/i, "").toLowerCase(), rest: "" };
+}
+function classify2(word, cwd, everywhere, ctx) {
+  if (word.dynamic || word.value.includes("%")) return { unresolvable: `a variable that cannot be worked out (${word.shown})` };
+  let base = word.value;
+  let pattern = null;
+  if (everywhere || /[*?]/.test(word.value)) {
+    const split = splitWindowsPattern(word.value, /[*?]/);
+    if (split === null) return { unresolvable: `a wildcard in a folder name (${word.value})` };
+    base = split.dir;
+    pattern = split.pattern;
+  }
+  const resolved = resolveWindowsPath(base, cwd, null);
+  if ("unresolvable" in resolved) return { unresolvable: resolved.unresolvable };
+  if ("unc" in resolved) return { real: { shown: word.value, path: null } };
+  return { real: judgePath(resolved.path, pattern, ctx) ?? void 0 };
+}
+function readCmd(line, ctx) {
+  const out = emptyRead();
+  const vars = /* @__PURE__ */ new Map();
+  for (const name2 of ["TEMP", "TMP", "USERPROFILE"]) {
+    const value = ctx.env[name2];
+    if (value) vars.set(name2.toLowerCase(), value);
+  }
+  if (ctx.cwd !== null) vars.set("cd", ctx.cwd);
+  let cwd = ctx.cwd;
+  const deny = (why) => ({ ...out, deny: denyReason("cmd", why) });
+  const expanded = expandVars(line, vars);
+  const pieces = segmentsOf(expanded).map((s) => ({ ...s, text: s.text.replace(/^[\s@,;=]+/, "") })).filter((s) => s.text !== "");
+  const segments2 = pieces.map((s) => s.text);
+  const control = segments2.some((s) => {
+    const first = wordsOf(s, "")[0];
+    const named = first ? nameOf(first) : null;
+    return first !== void 0 && (named === null || CONTROL.has(named.name));
+  });
+  if (control || hasBlock(expanded)) {
+    if (!DELETE_WORDS.test(expanded)) return out;
+    const shown = expanded.trim().replace(/\s+/g, " ").slice(0, EXCERPT_CHARS).split(UNKNOWN).join("%?%");
+    return deny(`a delete on a cmd line with if, else, for, call, start, parentheses or a command that cannot be worked out (${shown}); write plain del or rd lines, with names that hold parentheses in double quotes`);
+  }
+  for (const { text: segment, piped } of pieces) {
+    const words = wordsOf(segment, "");
+    if (!words.length) continue;
+    const first = words[0];
+    const named = nameOf(first);
+    const shown = segment.trim().split(UNKNOWN).join("%?%");
+    const { name: name2, rest } = named;
+    const args = () => [...rest ? wordsOf(rest, ",;=") : [], ...wordsOf(segment.slice(first.end), ",;=")];
+    if (/^[a-z]:$/i.test(first.value.replace(/^@/, ""))) {
+      cwd = null;
+    } else if (SHELLS2.has(name2)) {
+      const msys = name2 === "sh" || name2 === "bash";
+      out.shells.push({ name: name2, args: words.slice(1).map((w) => w.dynamic || msys && w.value.includes("'") ? null : w.value), cwd, raw: shown, ...piped ? { piped } : {} });
+    } else if (name2 === "popd") {
+      cwd = null;
+    } else if (name2 === "cd" || name2 === "chdir" || name2 === "pushd") {
+      const given = args();
+      const switchDrive = name2 === "pushd" || given.some((w) => !w.dynamic && w.value.toLowerCase() === "/d");
+      const parts = given.filter((w) => w.dynamic || w.value.toLowerCase() !== "/d");
+      if (!parts.length) continue;
+      const resolved = parts.some((w) => w.dynamic) ? null : resolveWindowsPath(parts.map((w) => w.value).join(" "), cwd, null);
+      if (resolved === null || !("path" in resolved)) cwd = null;
+      else if (switchDrive || cwd === null || resolved.path.slice(0, 2).toLowerCase() === cwd.slice(0, 2).toLowerCase()) cwd = resolved.path;
+    } else if (DELETES.has(name2)) {
+      const given = args();
+      const switches = given.filter((w) => !w.dynamic && w.value.startsWith("/"));
+      const everywhere = (name2 === "del" || name2 === "erase") && switches.some((w) => w.value.split("/").some((s) => s.toLowerCase() === "s"));
+      for (const word of given) {
+        if (switches.includes(word)) continue;
+        const c = classify2(word, cwd, everywhere, ctx);
+        if (c.unresolvable) return deny(c.unresolvable);
+        if (c.real) out.targets.push(c.real);
+      }
+    }
+  }
+  return out;
+}
+
+// src/rm/powershell.ts
+import fs5 from "fs";
+import path7 from "path";
+import { spawn } from "child_process";
+var PS_PARSE_TIMEOUT_MS = 3e3;
+var POWERSHELL_WORDS = /\b(?:remove-item|ri|rm|del|erase|rd|rmdir|sh|bash|cmd|powershell|pwsh)(?:\.exe)?\b|\bdelete/i;
+var DELETE_WORD = new RegExp(`${DELETE_WORDS.source}|\\bdelete`, "i");
+var OTHER_DRIVES = /* @__PURE__ */ new Set(["alias", "env", "function", "variable", "hklm", "hkcu", "cert", "wsman"]);
+var EXCERPT_CHARS2 = 200;
+var KNOWN_ENV2 = ["TEMP", "TMP", "TMPDIR", "HOME", "USERPROFILE"];
+var READER = String.raw`
+param($source)
+$ErrorActionPreference = 'Stop'
+$tokens = $null
+$errors = $null
+$root = [System.Management.Automation.Language.Parser]::ParseInput($source, [ref]$tokens, [ref]$errors)
+
+function Value($ast) {
+  if ($null -eq $ast) { return @{ dynamic = '' } }
+  if ($ast -is [System.Management.Automation.Language.StringConstantExpressionAst]) { return @{ const = $ast.Value } }
+  if ($ast -is [System.Management.Automation.Language.ConstantExpressionAst]) { return @{ const = [string]$ast.Value } }
+  if ($ast -is [System.Management.Automation.Language.ExpandableStringExpressionAst]) {
+    if ($ast.Extent.Text.Contains([string][char]96 + '$')) { return @{ dynamic = $ast.Extent.Text } }
+    $parts = New-Object System.Collections.ArrayList
+    $at = 0
+    foreach ($n in $ast.NestedExpressions) {
+      if (-not ($n -is [System.Management.Automation.Language.VariableExpressionAst]) -or $n.Splatted) { return @{ dynamic = $ast.Extent.Text } }
+      $i = $ast.Value.IndexOf($n.Extent.Text, $at, [System.StringComparison]::Ordinal)
+      if ($i -lt 0) { return @{ dynamic = $ast.Extent.Text } }
+      if ($i -gt $at) { [void]$parts.Add(@{ const = $ast.Value.Substring($at, $i - $at) }) }
+      [void]$parts.Add(@{ variable = $n.VariablePath.UserPath })
+      $at = $i + $n.Extent.Text.Length
+    }
+    if ($at -lt $ast.Value.Length) { [void]$parts.Add(@{ const = $ast.Value.Substring($at) }) }
+    return @{ expand = $parts.ToArray(); text = $ast.Extent.Text }
+  }
+  if ($ast -is [System.Management.Automation.Language.VariableExpressionAst] -and -not $ast.Splatted) { return @{ variable = $ast.VariablePath.UserPath } }
+  if ($ast -is [System.Management.Automation.Language.ArrayLiteralAst]) { return @{ array = @($ast.Elements | ForEach-Object { Value $_ }) } }
+  if ($ast -is [System.Management.Automation.Language.CommandParameterAst]) { return @{ const = $ast.Extent.Text } }
+  return @{ dynamic = $ast.Extent.Text }
+}
+
+function Constant($ast) {
+  if ($ast -is [System.Management.Automation.Language.CommandParameterAst]) { return ($null -eq $ast.Argument) -or (Constant $ast.Argument) }
+  if ($ast -is [System.Management.Automation.Language.ArrayLiteralAst]) { return @($ast.Elements | Where-Object { -not (Constant $_) }).Count -eq 0 }
+  return $ast -is [System.Management.Automation.Language.ConstantExpressionAst]
+}
+
+function NameOf($command) {
+  $name = $command.GetCommandName()
+  if ($null -eq $name) { return $null }
+  if ($name -eq 'cd..' -or $name -eq 'cd\') { return $name }
+  $name = $name -replace '^Microsoft\.PowerShell\.Management\\', ''
+  $name = ($name -split '[\\/]')[-1]
+  return ($name -replace '\.exe$', '').ToLowerInvariant()
+}
+
+function TopLevel($ast) {
+  for ($p = $ast.Parent; $null -ne $p; $p = $p.Parent) {
+    if ($p -eq $root) { return $true }
+    if (-not ($p -is [System.Management.Automation.Language.PipelineAst] -or $p -is [System.Management.Automation.Language.NamedBlockAst])) { return $false }
+  }
+  return $false
+}
+
+function InOrder($ast) {
+  for ($p = $ast.Parent; $null -ne $p -and $p -ne $root; $p = $p.Parent) {
+    if ($p -is [System.Management.Automation.Language.LoopStatementAst] -or $p -is [System.Management.Automation.Language.SwitchStatementAst] -or $p -is [System.Management.Automation.Language.ScriptBlockAst] -or $p -is [System.Management.Automation.Language.TrapStatementAst]) { return $false }
+  }
+  return $true
+}
+
+function Bound($command) {
+  $binding = [System.Management.Automation.Language.StaticParameterBinder]::BindCommand($command, $true)
+  $out = @{ bindError = ($binding.BindingExceptions.Count -gt 0); whatIf = $false }
+  foreach ($key in $binding.BoundParameters.Keys) {
+    $result = $binding.BoundParameters[$key]
+    switch ($key) {
+      'Path' { $out.path = Value $result.Value }
+      'LiteralPath' { $out.literalPath = Value $result.Value }
+      'Name' { $out.name = $result }
+      'MemberName' { $out.member = $result }
+      'WhatIf' {
+        $v = $result.Value
+        if ($null -eq $v) { $out.whatIf = ($result.ConstantValue -eq $true) }
+        else { $out.whatIf = ($v -is [System.Management.Automation.Language.VariableExpressionAst]) -and ($v.VariablePath.UserPath -eq 'true') }
+      }
+    }
+  }
+  return $out
+}
+
+$deletes = @('remove-item', 'ri', 'rm', 'del', 'erase', 'rd', 'rmdir')
+$moves = @('set-location', 'sl', 'cd', 'chdir', 'push-location', 'pushd')
+$pops = @('pop-location', 'popd')
+$shells = @('sh', 'bash', 'cmd', 'powershell', 'pwsh')
+$dynamics = @('invoke-expression', 'iex', 'start-process', 'saps', 'start', 'invoke-command', 'icm', 'start-job', 'sajb', 'start-threadjob', 'set-alias', 'sal', 'new-alias', 'nal', 'add-type')
+$members = @('foreach-object', '%', 'foreach')
+$drives = @('new-psdrive', 'ndr', 'mount')
+$variableCommands = @('set-variable', 'sv', 'new-variable', 'nv', 'remove-variable', 'rv', 'clear-variable', 'clv', 'get-variable', 'gv')
+$variableParameters = @('outvariable', 'errorvariable', 'warningvariable', 'informationvariable', 'pipelinevariable')
+$variableAliases = @('ov', 'ev', 'wv', 'iv', 'pv')
+$nameParameters = @('variable', 'bindingvariable') + $variableParameters
+
+function NamesVariable($element) {
+  if (-not ($element -is [System.Management.Automation.Language.CommandParameterAst])) { return $false }
+  $p = $element.ParameterName.ToLowerInvariant()
+  return $variableAliases -contains $p -or ($p.Length -ge 2 -and @($nameParameters | Where-Object { $_.StartsWith($p) }).Count -gt 0)
+}
+$codeMethods = @('invoke', 'invokereturnasis', 'invokewithcontext', 'invokescript', 'newscriptblock', 'addscript', 'addcommand', 'begininvoke')
+$dotnet = @('system.io.file', 'io.file', 'file', 'system.io.directory', 'io.directory', 'directory')
+$fileCommands = @('get-item', 'gi', 'get-childitem', 'gci', 'ls', 'dir', 'new-item', 'ni')
+$unstable = New-Object System.Collections.ArrayList
+$anyVariable = $false
+# An instance Delete() deletes a file only on an object a file command, -PassThru or a FileInfo made; COM objects have
+# one too.
+$fileObjects = ($source -match 'FileInfo|DirectoryInfo|FileSystemInfo') -or @($root.FindAll({
+  param($x)
+  ($x -is [System.Management.Automation.Language.CommandAst] -and $fileCommands -contains (NameOf $x)) -or
+  ($x -is [System.Management.Automation.Language.CommandParameterAst] -and $x.ParameterName.Length -ge 3 -and 'passthru'.StartsWith($x.ParameterName.ToLowerInvariant()))
+}, $true)).Count -gt 0
+$processStart = $source -match 'ProcessStartInfo|Diagnostics\.Process'
+
+# A name handed over as text (-OutVariable d, Tee-Object -Variable d, Set-Item variable:d, 'TEMP' handed to
+# SetEnvironmentVariable, '$d = 1' handed to iex) can write a variable without the parser seeing a variable there.
+$named = New-Object 'System.Collections.Generic.HashSet[string]' ([System.StringComparer]::OrdinalIgnoreCase)
+foreach ($s in $root.FindAll({ param($x) $x -is [System.Management.Automation.Language.StringConstantExpressionAst] }, $true)) {
+  foreach ($m in [regex]::Matches($s.Value, '\$\{?(?:\w+:)?([\w?]+)')) { [void]$named.Add($m.Groups[1].Value) }
+  $parent = $s.Parent
+  $at = if ($parent -is [System.Management.Automation.Language.CommandAst]) { $parent.CommandElements.IndexOf($s) } else { -1 }
+  # A bare Variable: or Env: drive (New-Item -Path Env: -Name TEMP, Set-Location Variable:) writes names given elsewhere.
+  if ($s.Value -match '^(?:[\w.]+\\)?(?:variable|env|environment):{1,2}[\\/]?$') { $anyVariable = $true }
+  elseif ($s.Value -match '^(?:[\w.]+\\)?(?:variable|env|environment):{1,2}[\\/]?(.+)$') { [void]$named.Add($Matches[1]) }
+  elseif (($at -gt 0 -and (NamesVariable $parent.CommandElements[$at - 1])) -or (NamesVariable $parent) -or ($parent -is [System.Management.Automation.Language.InvokeMemberExpressionAst] -and $parent.Member -ne $s -and $parent.Member.Value -match 'variable|^set$|^get$')) {
+    [void]$named.Add(($s.Value -replace '^\+', '' -replace '^(?:script|global|local|private):', ''))
+  }
+}
+foreach ($d in $root.FindAll({ param($x) $x -is [System.Management.Automation.Language.DataStatementAst] }, $true)) { if ($d.Variable) { [void]$named.Add($d.Variable) } }
+foreach ($v in $root.FindAll({ param($x) $x -is [System.Management.Automation.Language.VariableExpressionAst] }, $true)) {
+  $path = $v.VariablePath.UserPath
+  if ($v.Parent -is [System.Management.Automation.Language.ParameterAst] -or $named.Contains(($path -split ':')[-1])) { [void]$unstable.Add($path) }
+}
+
+$items = New-Object System.Collections.ArrayList
+$found = $root.FindAll({
+  param($a)
+  $a -is [System.Management.Automation.Language.CommandAst] -or
+  $a -is [System.Management.Automation.Language.AssignmentStatementAst] -or
+  $a -is [System.Management.Automation.Language.InvokeMemberExpressionAst] -or
+  $a -is [System.Management.Automation.Language.UnaryExpressionAst] -or
+  $a -is [System.Management.Automation.Language.ForEachStatementAst] -or
+  $a -is [System.Management.Automation.Language.ConvertExpressionAst] -or
+  $a -is [System.Management.Automation.Language.CommandParameterAst]
+}, $true)
+foreach ($a in $found) {
+  if ($a -is [System.Management.Automation.Language.AssignmentStatementAst]) {
+    $left = $a.Left
+    if ($left -is [System.Management.Automation.Language.VariableExpressionAst] -and -not $left.Splatted -and ($left.VariablePath.IsUnqualified -or $left.VariablePath.IsDriveQualified) -and $a.Operator -eq 'Equals' -and (TopLevel $a)) {
+      $right = if ($a.Right -is [System.Management.Automation.Language.CommandExpressionAst]) { Value $a.Right.Expression } else { @{ dynamic = $a.Right.Extent.Text } }
+      [void]$items.Add(@{ kind = 'assign'; name = $left.VariablePath.UserPath; value = $right })
+    } else {
+      foreach ($v in $left.FindAll({ param($x) $x -is [System.Management.Automation.Language.VariableExpressionAst] }, $true)) { [void]$unstable.Add($v.VariablePath.UserPath) }
+    }
+    continue
+  }
+  if ($a -is [System.Management.Automation.Language.UnaryExpressionAst]) {
+    if ($a.Child -is [System.Management.Automation.Language.VariableExpressionAst] -and @('PlusPlus', 'MinusMinus', 'PostfixPlusPlus', 'PostfixMinusMinus') -contains [string]$a.TokenKind) { [void]$unstable.Add($a.Child.VariablePath.UserPath) }
+    continue
+  }
+  if ($a -is [System.Management.Automation.Language.ForEachStatementAst]) {
+    [void]$unstable.Add($a.Variable.VariablePath.UserPath)
+    continue
+  }
+  if ($a -is [System.Management.Automation.Language.ConvertExpressionAst]) {
+    if ($a.Type.TypeName.Name -eq 'ref' -and $a.Child -is [System.Management.Automation.Language.VariableExpressionAst]) { [void]$unstable.Add($a.Child.VariablePath.UserPath) }
+    continue
+  }
+  if ($a -is [System.Management.Automation.Language.CommandParameterAst]) {
+    # PowerShell takes any unambiguous start of a parameter name, so -OutVar and -ErrorVar count too.
+    $p = $a.ParameterName.ToLowerInvariant()
+    if ($variableAliases -contains $p -or ($p.Length -ge 2 -and @($variableParameters | Where-Object { $_.StartsWith($p) }).Count -gt 0)) { $anyVariable = $true }
+    continue
+  }
+  if ($a -is [System.Management.Automation.Language.InvokeMemberExpressionAst]) {
+    $member = if ($a.Member -is [System.Management.Automation.Language.StringConstantExpressionAst]) { $a.Member.Value.ToLowerInvariant() } else { $null }
+    $type = if ($a.Expression -is [System.Management.Automation.Language.TypeExpressionAst]) { $a.Expression.TypeName.FullName.ToLowerInvariant() } else { $null }
+    if ($a.Static -and $member -eq 'delete' -and $dotnet -contains $type) {
+      $first = if ($a.Arguments -and $a.Arguments.Count -gt 0) { Value $a.Arguments[0] } else { @{ dynamic = $a.Extent.Text } }
+      [void]$items.Add(@{ kind = 'delete'; path = $first; literalPath = $null; literal = $true; dotnet = $true; whatIf = $false; bindError = $false; inPipeline = $false; ordered = (InOrder $a) })
+    } elseif ($null -eq $member -or ($a.Static -and $null -eq $type) -or $codeMethods -contains $member -or
+      ($member -eq 'create' -and $type -match '(^|\.)(scriptblock|powershell)$') -or
+      ($member -eq 'start' -and ($type -match '(^|\.)process$' -or ($null -eq $type -and $processStart))) -or
+      ($member.StartsWith('delete') -and ($null -ne $type -or $fileObjects))) {
+      [void]$items.Add(@{ kind = 'dynamic'; text = $null; args = @() })
+    }
+    continue
+  }
+  if ($a.CommandElements[0] -is [System.Management.Automation.Language.ScriptBlockExpressionAst]) { continue }
+  $name = NameOf $a
+  if ($null -eq $name) {
+    [void]$items.Add(@{ kind = 'dynamic'; text = $null; args = @() })
+    continue
+  }
+  $pipeline = $a.Parent
+  $inPipeline = ($pipeline -is [System.Management.Automation.Language.PipelineAst]) -and ($pipeline.PipelineElements.IndexOf($a) -gt 0)
+  if ($deletes -contains $name) {
+    $b = Bound $a
+    [void]$items.Add(@{ kind = 'delete'; path = $b.path; literalPath = $b.literalPath; literal = ($null -ne $b.literalPath); dotnet = $false; whatIf = $b.whatIf; bindError = $b.bindError; inPipeline = $inPipeline; ordered = (InOrder $a) })
+  } elseif ($name -eq 'cd..' -or $name -eq 'cd\') {
+    [void]$items.Add(@{ kind = 'cd'; path = @{ const = $name.Substring(2) }; literal = $true; inBlock = -not (TopLevel $a) })
+  } elseif ($moves -contains $name) {
+    $b = Bound $a
+    $to = if ($null -ne $b.literalPath) { $b.literalPath } else { $b.path }
+    [void]$items.Add(@{ kind = 'cd'; path = $to; literal = ($null -ne $b.literalPath); inBlock = -not (TopLevel $a) })
+  } elseif ($pops -contains $name) {
+    [void]$items.Add(@{ kind = 'pop' })
+  } elseif ($shells -contains $name) {
+    $elements = @($a.CommandElements | Select-Object -Skip 1 | ForEach-Object { Value $_ })
+    [void]$items.Add(@{ kind = 'shell'; name = $name; args = $elements; raw = $a.Extent.Text; inPipeline = $inPipeline; ordered = (InOrder $a) })
+  } elseif ($dynamics -contains $name) {
+    if ($inPipeline) {
+      [void]$items.Add(@{ kind = 'dynamic'; text = $null; args = @() })
+    } else {
+      $values = New-Object System.Collections.ArrayList
+      foreach ($e in @($a.CommandElements | Select-Object -Skip 1)) {
+        if (Constant $e) { continue }
+        [void]$values.Add((Value $(if ($e -is [System.Management.Automation.Language.CommandParameterAst]) { $e.Argument } else { $e })))
+      }
+      [void]$items.Add(@{ kind = 'dynamic'; text = $a.Extent.Text; args = $values.ToArray() })
+    }
+  } elseif ($members -contains $name) {
+    $m = (Bound $a).member
+    if ($null -ne $m) {
+      $v = $m.ConstantValue
+      if ($null -eq $v -or ([string]$v) -match '^delete' -or $codeMethods -contains ([string]$v).ToLowerInvariant()) { [void]$items.Add(@{ kind = 'dynamic'; text = $null; args = @() }) }
+    }
+  } elseif ($drives -contains $name) {
+    # A drive made here can carry a one-letter name that reads like a real drive.
+    [void]$items.Add(@{ kind = 'dynamic'; text = $null; args = @() })
+  } elseif ($variableCommands -contains $name) {
+    $b = Bound $a
+    $names = if ($null -ne $b.name) { @($b.name.ConstantValue) } else { @() }
+    if ($names.Count -eq 0 -or @($names | Where-Object { $null -eq $_ -or [System.Management.Automation.WildcardPattern]::ContainsWildcardCharacters([string]$_) }).Count -gt 0) { $anyVariable = $true }
+    else { foreach ($n in $names) { [void]$unstable.Add([string]$n) } }
+  }
+}
+$result = @{ errors = ($errors.Count -gt 0); items = $items.ToArray(); unstable = $unstable.ToArray(); anyVariable = $anyVariable }
+[Console]::Out.Write((ConvertTo-Json -InputObject $result -Depth 12 -Compress))
+`;
+var LOADER = String.raw`
+$utf8 = New-Object System.Text.UTF8Encoding $false
+[Console]::InputEncoding = $utf8
+[Console]::OutputEncoding = $utf8
+$all = [Console]::In.ReadToEnd()
+$cut = $all.IndexOf([char]0)
+& ([scriptblock]::Create($all.Substring(0, $cut))) $all.Substring($cut + 1)
+`;
+function powerShellExe(env) {
+  for (const dir of (env.PATH ?? env.Path ?? "").split(path7.delimiter)) {
+    if (dir && fs5.existsSync(path7.join(dir, "pwsh.exe"))) return path7.join(dir, "pwsh.exe");
+  }
+  return "powershell.exe";
+}
+function realPowerShell(env, timeoutMs = PS_PARSE_TIMEOUT_MS) {
+  const encoded = Buffer.from(LOADER, "utf16le").toString("base64");
+  return (source) => new Promise((resolve) => {
+    let out = "";
+    let done = false;
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const child = spawn(powerShellExe(env), ["-NoProfile", "-NonInteractive", "-NoLogo", "-ExecutionPolicy", "Bypass", "-EncodedCommand", encoded], { windowsHide: true, stdio: ["pipe", "pipe", "ignore"] });
+    const timer = setTimeout(() => {
+      child.kill();
+      finish(null);
+    }, timeoutMs);
+    child.on("error", () => finish(null));
+    child.on("close", (code) => finish(code === 0 ? out : null));
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      out += chunk;
+    });
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(`${READER}\0${source}`, "utf8");
+  });
+}
+var list = (value) => Array.isArray(value) ? value : value == null ? [] : [value];
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function partOf(raw) {
+  if (!isRecord2(raw)) throw new Error("bad value");
+  if (typeof raw.const === "string") return { const: raw.const };
+  if (typeof raw.variable === "string") return { variable: raw.variable };
+  throw new Error("bad value");
+}
+function valueOf(raw) {
+  if (!isRecord2(raw)) throw new Error("bad value");
+  if ("expand" in raw) {
+    if (!Array.isArray(raw.expand) || typeof raw.text !== "string") throw new Error("bad value");
+    return { expand: raw.expand.map(partOf), text: raw.text };
+  }
+  if ("array" in raw) return { array: list(raw.array).map(valueOf) };
+  if ("dynamic" in raw) {
+    if (typeof raw.dynamic !== "string") throw new Error("bad value");
+    return { dynamic: raw.dynamic };
+  }
+  return partOf(raw);
+}
+var optionalValue = (raw) => raw == null ? null : valueOf(raw);
+var flag = (raw) => {
+  if (typeof raw !== "boolean") throw new Error("bad flag");
+  return raw;
+};
+function itemOf(raw) {
+  if (!isRecord2(raw) || typeof raw.kind !== "string") throw new Error("bad item");
+  switch (raw.kind) {
+    case "delete":
+      return { kind: "delete", path: optionalValue(raw.path), literalPath: optionalValue(raw.literalPath), literal: flag(raw.literal), dotnet: flag(raw.dotnet), whatIf: flag(raw.whatIf), bindError: flag(raw.bindError), inPipeline: flag(raw.inPipeline), ordered: flag(raw.ordered) };
+    case "cd":
+      return { kind: "cd", path: optionalValue(raw.path), literal: flag(raw.literal), inBlock: flag(raw.inBlock) };
+    case "pop":
+      return { kind: "pop" };
+    case "assign":
+      if (typeof raw.name !== "string") throw new Error("bad item");
+      return { kind: "assign", name: raw.name, value: valueOf(raw.value) };
+    case "shell":
+      if (typeof raw.name !== "string" || typeof raw.raw !== "string") throw new Error("bad item");
+      return { kind: "shell", name: raw.name, args: list(raw.args).map(valueOf), raw: raw.raw, inPipeline: flag(raw.inPipeline), ordered: flag(raw.ordered) };
+    case "dynamic":
+      if (raw.text != null && typeof raw.text !== "string" || !Array.isArray(raw.args)) throw new Error("bad item");
+      return { kind: "dynamic", text: typeof raw.text === "string" ? raw.text : null, args: raw.args.map(valueOf) };
+    default:
+      throw new Error("bad item");
+  }
+}
+function parse(stdout) {
+  const parsed = JSON.parse(stdout);
+  if (!isRecord2(parsed) || parsed.errors !== false || !Array.isArray(parsed.items) || !Array.isArray(parsed.unstable) || typeof parsed.anyVariable !== "boolean") throw new Error("bad answer");
+  const unstable = parsed.unstable.map((name2) => {
+    if (typeof name2 !== "string") throw new Error("bad answer");
+    return baseName(name2);
+  });
+  return { items: parsed.items.map(itemOf), unstable: new Set(unstable), anyVariable: parsed.anyVariable };
+}
+var baseName = (name2) => name2.toLowerCase().replace(/^(?:script|local|global|private|using|variable):/, "");
+function fileSystemPath(value) {
+  const qualified = /^(?:[\w.]+\\)?(\w+)::/.exec(value);
+  if (!qualified) return value;
+  return qualified[1].toLowerCase() === "filesystem" ? value.slice(qualified[0].length) : null;
+}
+function classify3(value, literal, cwd, ctx) {
+  const text = fileSystemPath(value);
+  if (text === null) return {};
+  const drive = /^([A-Za-z][A-Za-z0-9_]+):/.exec(text);
+  if (drive) return OTHER_DRIVES.has(drive[1].toLowerCase()) ? {} : { unresolvable: `a path on a PowerShell drive that cannot be worked out (${value})` };
+  let base = text;
+  let pattern = null;
+  if (!literal && /[*?[]/.test(text)) {
+    const split = splitWindowsPattern(text, /[*?[]/);
+    if (split === null) return { unresolvable: `a wildcard in a folder name (${value})` };
+    base = split.dir;
+    pattern = split.pattern;
+  }
+  const resolved = resolveWindowsPath(base, cwd, ctx.home);
+  if ("unresolvable" in resolved) return { unresolvable: resolved.unresolvable };
+  if ("unc" in resolved) return { real: { shown: value, path: null } };
+  return { real: judgePath(resolved.path, pattern, ctx) ?? void 0 };
+}
+function folderOf(value, literal, cwd, home) {
+  const text = fileSystemPath(value);
+  if (text === null || text === "-" || text === "+" || /^[A-Za-z][A-Za-z0-9_]+:/.test(text) || !literal && /[*?[]/.test(text)) return null;
+  const resolved = resolveWindowsPath(text, cwd, home);
+  return "path" in resolved ? resolved.path : null;
+}
+async function readPowerShell(source, ctx, run) {
+  const out = emptyRead();
+  if (!POWERSHELL_WORDS.test(source)) return out;
+  const excerpt = source.slice(0, EXCERPT_CHARS2);
+  const failed = () => ({ ...emptyRead(), failed: [excerpt] });
+  try {
+    const stdout = await run(source);
+    if (stdout === null) return failed();
+    const { items, unstable, anyVariable } = parse(stdout);
+    const assigned = /* @__PURE__ */ new Map();
+    for (const item of items) if (item.kind === "assign") assigned.set(baseName(item.name), (assigned.get(baseName(item.name)) ?? 0) + 1);
+    const moves = items.some((item) => item.kind === "cd" || item.kind === "pop");
+    const processFolder = /CurrentDirectory/i.test(source) ? null : ctx.cwd;
+    const vars = /* @__PURE__ */ new Map();
+    for (const name2 of KNOWN_ENV2) {
+      const value = ctx.env[name2];
+      if (value) vars.set(`env:${name2.toLowerCase()}`, value);
+    }
+    vars.set("home", ctx.home);
+    let cwd = ctx.cwd;
+    const variable = (name2, here) => {
+      const key = baseName(name2);
+      if (anyVariable || unstable.has(key)) return null;
+      if (key === "pwd") return assigned.has("pwd") ? null : here;
+      return vars.get(key) ?? null;
+    };
+    const textOf = (value, here = cwd) => {
+      if (!value) return null;
+      if ("const" in value) return value.const;
+      if ("variable" in value) return variable(value.variable, here);
+      if ("expand" in value) {
+        let text = "";
+        for (const part of value.expand) {
+          const piece = "const" in part ? part.const : variable(part.variable, here);
+          if (piece === null) return null;
+          text += piece;
+        }
+        return text;
+      }
+      return null;
+    };
+    const deny = (why) => ({ ...out, deny: denyReason("powershell", why) });
+    for (const item of items) {
+      if (item.kind === "assign") {
+        const key = baseName(item.name);
+        vars.set(key, assigned.get(key) === 1 ? textOf(item.value) : null);
+      } else if (item.kind === "pop") {
+        cwd = null;
+      } else if (item.kind === "cd") {
+        const to = item.inBlock ? null : textOf(item.path);
+        cwd = to === null ? null : folderOf(to, item.literal, cwd, ctx.home);
+      } else if (item.kind === "shell") {
+        if (item.inPipeline && DELETE_WORD.test(source)) return deny(`pipeline input feeding a shell (${item.raw})`);
+        const here = item.ordered || !moves ? cwd : null;
+        const args = item.args.map((a) => textOf(a, here)).map((t) => t !== null && item.name !== "cmd" && t.includes('"') ? null : t);
+        out.shells.push({ name: item.name, args, cwd: here, raw: item.raw });
+      } else if (item.kind === "dynamic") {
+        const values = item.text === null ? null : item.args.map((a) => textOf(a));
+        const code = values === null || values.includes(null) ? source : [item.text, ...values].join(" ");
+        if (DELETE_WORD.test(code) && !out.failed.length) out.failed.push(excerpt);
+      } else {
+        if (item.whatIf) continue;
+        if (item.bindError) {
+          if (!out.failed.length) out.failed.push(excerpt);
+          continue;
+        }
+        if (item.inPipeline) return deny("pipeline input feeding Remove-Item");
+        const here = item.ordered || !moves ? cwd : null;
+        const values = list(item.literalPath ?? item.path).flatMap((v) => "array" in v ? v.array : [v]);
+        for (const v of values) {
+          if ("dynamic" in v || "array" in v) return deny(`an expression that cannot be worked out (${"dynamic" in v ? v.dynamic : "a nested list"})`);
+          const text = textOf(v, here);
+          if (text === null) return deny(`a variable that cannot be worked out (${"variable" in v ? `$${v.variable}` : "expand" in v ? v.text : ""})`);
+          const c = classify3(text, item.literal, item.dotnet ? processFolder : here, ctx);
+          if (c.unresolvable) return deny(c.unresolvable);
+          if (c.real) out.targets.push(c.real);
+        }
+      }
+    }
+    return out;
+  } catch {
+    return failed();
+  }
+}
+
+// src/rm/dispatch.ts
+var MAX_NESTING = 3;
+var POWERSHELL_VALUE_PARAMS = [["executionpolicy", 2], ["windowstyle", 2], ["outputformat", 2], ["inputformat", 2], ["workingdirectory", 2], ["configurationname", 6], ["settingsfile", 2], ["version", 2], ["psconsolefile", 2], ["custompipename", 2]];
+var POWERSHELL_VALUE_ALIASES = ["ep", "ex", "w", "o", "of", "if", "wd", "v"];
+var CMD_RUN = /^\/{1,2}(?:[a-z]+\/)*[ck](.*)$/is;
+var paramName = (arg) => arg.replace(/^(?:--|-|\/)/, "").toLowerCase();
+var isParam = (arg) => /^(?:--|-|\/)[A-Za-z]/.test(arg);
+var startsWord = (name2, full, min) => name2.length >= min && full.startsWith(name2);
+function cmdLine(args) {
+  const line = args.map((a) => /\s/.test(a) && !/^".*"$/.test(a) ? `"${a}"` : a).join(" ");
+  const last = line.lastIndexOf('"');
+  return line.startsWith('"') && last > 0 ? `${line.slice(1, last)}${line.slice(last + 1)}` : line;
+}
+function bashScript(args) {
+  let hasC = false;
+  let i = 0;
+  for (; i < args.length; i++) {
+    const a = args[i];
+    if (a === null) return { shell: "bash", script: null };
+    if (a === "--") {
+      i++;
+      break;
+    }
+    if (!/^[-+]/.test(a)) break;
+    if (/^-[A-Za-z]*c[A-Za-z]*$/.test(a)) hasC = true;
+    if (/^[-+][oO]$/.test(a) || a === "--rcfile" || a === "--init-file") i++;
+  }
+  if (!hasC || i >= args.length) return null;
+  return { shell: "bash", script: args[i] };
+}
+function powerShellScript(name2, args) {
+  let moved = false;
+  const found = (script) => ({ shell: "powershell", script, ...moved ? { moved } : {} });
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === null) return found(null);
+    if (a === "-") return null;
+    if (!isParam(a)) {
+      if (name2 === "pwsh") return null;
+      const rest = args.slice(i);
+      return found(rest.includes(null) ? null : rest.join(" "));
+    }
+    const p = paramName(a);
+    if (p === "e" || p === "ec" || startsWord(p, "encodedcommand", 2)) {
+      const encoded = args[i + 1];
+      if (encoded === void 0) return null;
+      return found(encoded === null ? null : Buffer.from(encoded, "base64").toString("utf16le"));
+    }
+    if (p === "cwa" || startsWord(p, "command", 1) || startsWord(p, "commandwithargs", 8)) {
+      const rest = args.slice(i + 1);
+      if (!rest.length || rest[0] === "-") return null;
+      return found(rest.includes(null) ? null : rest.join(" "));
+    }
+    if (p === "f" || startsWord(p, "file", 2)) return null;
+    if (POWERSHELL_VALUE_ALIASES.includes(p) || POWERSHELL_VALUE_PARAMS.some(([full, min]) => startsWord(p, full, min))) {
+      if (p === "wd" || startsWord(p, "workingdirectory", 2)) moved = true;
+      i++;
+    }
+  }
+  return null;
+}
+function nestedScript({ name: name2, args }) {
+  if (name2 === "sh" || name2 === "bash") return bashScript(args);
+  if (name2 === "powershell" || name2 === "pwsh") return powerShellScript(name2, args);
+  if (name2 === "cmd") {
+    const at = args.findIndex((a) => a !== null && CMD_RUN.test(a));
+    if (at === -1) return null;
+    const glued = CMD_RUN.exec(args[at])[1];
+    const rest = [...glued ? [glued] : [], ...args.slice(at + 1)];
+    return rest.includes(null) ? { shell: "cmd", script: null } : { shell: "cmd", script: cmdLine(rest) };
+  }
+  return null;
+}
+function readsStdin({ name: name2, args }) {
+  if (args.includes(null)) return false;
+  const given = args;
+  if (name2 === "sh" || name2 === "bash") {
+    for (let i = 0; i < given.length; i++) {
+      const a = given[i];
+      if (a === "--") return i + 1 === given.length;
+      if (!/^[-+]/.test(a)) return false;
+      if (/^-[A-Za-z]*s[A-Za-z]*$/.test(a)) return true;
+      if (/^[-+][oO]$/.test(a) || a === "--rcfile" || a === "--init-file") i++;
+    }
+    return true;
+  }
+  if (name2 === "powershell" || name2 === "pwsh") {
+    for (let i = 0; i < given.length; i++) {
+      const a = given[i];
+      if (a === "-") return true;
+      if (!isParam(a)) return false;
+      const p = paramName(a);
+      if (p === "cwa" || startsWord(p, "command", 1) || startsWord(p, "commandwithargs", 8)) return given[i + 1] === void 0 || given[i + 1] === "-";
+      if (p === "f" || startsWord(p, "file", 2) || p === "e" || p === "ec" || startsWord(p, "encodedcommand", 2)) return false;
+      if (POWERSHELL_VALUE_ALIASES.includes(p) || POWERSHELL_VALUE_PARAMS.some(([full, min]) => startsWord(p, full, min))) i++;
+    }
+    return true;
+  }
+  return name2 === "cmd" && !given.some((a) => CMD_RUN.test(a));
+}
+function readShell(shell, script, ctx, run) {
+  if (shell === "bash") return readBash(script, ctx);
+  if (shell === "cmd") return readCmd(script, ctx);
+  return readPowerShell(script, ctx, run);
+}
+async function readNested(shell, script, ctx, run, depth) {
+  const result = await readShell(shell, script, ctx, run);
+  if (result.deny !== null) return result;
+  const merged = { deny: null, targets: [...result.targets], failed: [...result.failed], shells: [] };
+  for (const call of result.shells) {
+    const nested = nestedScript(call);
+    if (nested === null) {
+      if ((call.piped || readsStdin(call)) && DELETE_WORDS.test(script)) return { ...merged, deny: denyReason(shell, `a shell reading its script from stdin (${call.raw})`) };
+      continue;
+    }
+    if (nested.script === null || depth >= MAX_NESTING) {
+      if (!DELETE_WORDS.test(call.raw) && !DELETE_WORDS.test(nested.script ?? "")) continue;
+      const why = nested.script === null ? `a ${call.name} script that cannot be worked out (${call.raw})` : `shells nested more than ${MAX_NESTING} deep (${call.raw})`;
+      return { ...merged, deny: denyReason(shell, why) };
+    }
+    const inner = await readNested(nested.shell, nested.script, { ...ctx, cwd: nested.moved ? null : call.cwd }, run, depth + 1);
+    if (inner.deny !== null) return { ...merged, deny: inner.deny };
+    merged.targets.push(...inner.targets);
+    merged.failed.push(...inner.failed);
+  }
+  return merged;
+}
+async function decideTool(tool, command, ctx, run) {
+  return decisionOf(await readNested(tool === "Bash" ? "bash" : "powershell", command, ctx, run, 0));
+}
+
 // src/rm/facts.ts
-import fs6 from "fs";
-import path5 from "path";
+import fs7 from "fs";
+import path8 from "path";
 import { spawnSync as spawnSync2 } from "child_process";
 
 // src/context/transcript.ts
-import fs5 from "fs";
+import fs6 from "fs";
 var TAIL_START_BYTES = 1024 * 1024;
 var TAIL_MAX_BYTES = 8 * 1024 * 1024;
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseLines(text) {
@@ -524,7 +1387,7 @@ function parseLines(text) {
     if (!line.trim()) continue;
     try {
       const value = JSON.parse(line);
-      if (isRecord2(value)) entries.push(value);
+      if (isRecord3(value)) entries.push(value);
     } catch {
     }
   }
@@ -534,11 +1397,13 @@ function parseLines(text) {
 // src/rm/facts.ts
 var SESSION_LOG_MAX_BYTES = 32 * 1024 * 1024;
 var CALLS_PER_TARGET = 3;
-var win2 = path5.win32;
+var win4 = path8.win32;
 var DELETING = /\b(?:rm|rmdir|del|erase|rd|ri|Remove-Item|xargs)\b/i;
 var GIT_LOCATION_ENV = ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_COMMON_DIR"];
-var CHANGES_FOLDER = /(^|[\s;&|(])(?:cd|pushd|popd|chdir|Set-Location|sl)(?=\s|$)/i;
-function isRecord3(value) {
+var MOVES = ["cd", "pushd", "popd", "chdir", "set-location", "sl", "push-location", "pop-location"];
+var CHANGES_FOLDER = new RegExp(`(^|[\\s;&|(])(?:${MOVES.join("|")})(?=[\\s;&|)]|$)`, "i");
+var MOVING_TOOLS = /* @__PURE__ */ new Set(["EnterWorktree", "ExitWorktree"]);
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function callOf(tool, input, result, cwd) {
@@ -550,7 +1415,7 @@ function callOf(tool, input, result, cwd) {
       return { tool, file: text("file_path"), text: text("new_string"), kind: "change", cwd };
     case "MultiEdit": {
       const edits = Array.isArray(input.edits) ? input.edits : [];
-      return { tool, file: text("file_path"), text: edits.map((e) => isRecord3(e) && typeof e.new_string === "string" ? e.new_string : "").join("\n"), kind: "change", cwd };
+      return { tool, file: text("file_path"), text: edits.map((e) => isRecord4(e) && typeof e.new_string === "string" ? e.new_string : "").join("\n"), kind: "change", cwd };
     }
     case "NotebookEdit":
       return { tool, file: text("notebook_path"), text: text("new_source"), kind: "change", cwd };
@@ -566,10 +1431,10 @@ function callOf(tool, input, result, cwd) {
 function resultTypes(entries) {
   const types = /* @__PURE__ */ new Map();
   for (const entry of entries) {
-    if (entry.type !== "user" || !isRecord3(entry.toolUseResult) || typeof entry.toolUseResult.type !== "string" || !isRecord3(entry.message)) continue;
+    if (entry.type !== "user" || !isRecord4(entry.toolUseResult) || typeof entry.toolUseResult.type !== "string" || !isRecord4(entry.message)) continue;
     const content = entry.message.content;
     const block = Array.isArray(content) ? content[0] : void 0;
-    if (isRecord3(block) && typeof block.tool_use_id === "string") types.set(block.tool_use_id, entry.toolUseResult.type);
+    if (isRecord4(block) && typeof block.tool_use_id === "string") types.set(block.tool_use_id, entry.toolUseResult.type);
   }
   return types;
 }
@@ -579,12 +1444,13 @@ function toolCalls(entries) {
   let message;
   let moved = false;
   for (const entry of entries) {
-    if (entry.type !== "assistant" || entry.isSidechain === true || !isRecord3(entry.message) || !Array.isArray(entry.message.content)) continue;
+    if (entry.type !== "assistant" || entry.isSidechain === true || !isRecord4(entry.message) || !Array.isArray(entry.message.content)) continue;
     if (entry.message.id === void 0 || entry.message.id !== message) moved = false;
     message = entry.message.id;
     const cwd = typeof entry.cwd === "string" ? entry.cwd : null;
     for (const block of entry.message.content) {
-      if (!isRecord3(block) || block.type !== "tool_use" || typeof block.name !== "string" || !isRecord3(block.input)) continue;
+      if (!isRecord4(block) || block.type !== "tool_use" || typeof block.name !== "string" || !isRecord4(block.input)) continue;
+      if (MOVING_TOOLS.has(block.name)) moved = true;
       const call = callOf(block.name, block.input, typeof block.id === "string" ? results.get(block.id) : void 0, moved ? null : cwd);
       if (!call) continue;
       calls.push(call);
@@ -596,8 +1462,8 @@ function toolCalls(entries) {
 function readSessionLog(file, maxBytes = SESSION_LOG_MAX_BYTES) {
   let text;
   try {
-    if (fs6.statSync(file).size > maxBytes) return null;
-    text = fs6.readFileSync(file, "utf8");
+    if (fs7.statSync(file).size > maxBytes) return null;
+    text = fs7.readFileSync(file, "utf8");
   } catch {
     return null;
   }
@@ -611,8 +1477,8 @@ function normalized(text) {
 var escaped = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 function shellRefs(target, cwd) {
   const refs = [`(?<![\\w.-])${escaped(normalized(target))}(?![\\w.-])`];
-  const relative = cwd === null ? "" : win2.relative(cwd, target);
-  if (relative && !relative.startsWith("..") && !win2.isAbsolute(relative)) {
+  const relative = cwd === null ? "" : win4.relative(cwd, target);
+  if (relative && !relative.startsWith("..") && !win4.isAbsolute(relative)) {
     refs.push(`(?<![\\w.\\-/:])(?:\\./)?${escaped(normalized(relative))}(?![\\w.-])`);
   }
   return refs;
@@ -677,18 +1543,18 @@ var pathWord = (word) => word.replace(/\\/g, "/").replace(/^\/([A-Za-z])\//, "$1
 function createsTarget(call, target) {
   if (call.kind !== "shell") return call.kind === "create";
   const full = pathWord(target);
-  const relative = call.cwd === null ? "" : win2.relative(call.cwd, target);
-  const short = relative && !relative.startsWith("..") && !win2.isAbsolute(relative) ? pathWord(relative) : null;
+  const relative = call.cwd === null ? "" : win4.relative(call.cwd, target);
+  const short = relative && !relative.startsWith("..") && !win4.isAbsolute(relative) ? pathWord(relative) : null;
   let moved = false;
   const isTarget = (word) => word !== void 0 && (pathWord(word) === full || !moved && pathWord(word) === short);
   for (const { words, writes } of shellCommands(stripHeredocs(call.text))) {
     if (writes.some(isTarget)) return true;
     const start = words.findIndex((w) => !/^[A-Za-z_][A-Za-z0-9_]*=/.test(w));
     const args = start === -1 ? [] : words.slice(start);
-    const name2 = win2.basename((args[0] ?? "").replace(/\//g, "\\")).replace(/\.exe$/i, "").toLowerCase();
+    const name2 = win4.basename((args[0] ?? "").replace(/\//g, "\\")).replace(/\.exe$/i, "").toLowerCase();
     if ((name2 === "touch" || name2 === "mkdir") && args.slice(1).some(isTarget)) return true;
     if (name2 === "curl" && args.some((w, i) => (w === "-o" || w === "--output") && isTarget(args[i + 1]))) return true;
-    if (name2 === "cd" || name2 === "pushd" || name2 === "popd") moved = true;
+    if (MOVES.includes(name2)) moved = true;
   }
   return false;
 }
@@ -712,8 +1578,9 @@ function gatherFacts(target, session, probe, maxFiles) {
 function candidateKind(facts, startedAt) {
   const fresh = (bornAt2) => bornAt2 >= startedAt;
   const freshInside = !facts.folder || facts.listing !== null && !facts.listing.more && facts.listing.entries.every((e) => fresh(e.bornAt));
-  if (!facts.tracked && !facts.existedBefore && facts.createdBy.length > 0 && fresh(facts.bornAt) && freshInside) return "session";
-  if (facts.folder && facts.ignored && !facts.listing?.repo) return "ignored";
+  const repo = facts.folder && (facts.listing === null || facts.listing.repo);
+  if (!facts.tracked && !facts.existedBefore && facts.createdBy.length > 0 && fresh(facts.bornAt) && freshInside && !repo) return "session";
+  if (facts.folder && facts.ignored && !repo) return "ignored";
   return null;
 }
 var bornAt = (stat) => stat.birthtimeMs > 0 ? stat.birthtimeMs : stat.mtimeMs;
@@ -725,7 +1592,7 @@ function git(args, extraEnv = {}) {
 var realFactProbe = {
   info(p) {
     try {
-      const stat = fs6.lstatSync(p);
+      const stat = fs7.lstatSync(p);
       return { folder: stat.isDirectory(), bornAt: bornAt(stat) };
     } catch {
       return null;
@@ -737,7 +1604,7 @@ var realFactProbe = {
     let more = false;
     let repo = false;
     const walk = (folder, prefix) => {
-      for (const item of fs6.readdirSync(folder, { withFileTypes: true })) {
+      for (const item of fs7.readdirSync(folder, { withFileTypes: true })) {
         if (more) return;
         if (seen >= limit) {
           more = true;
@@ -745,33 +1612,36 @@ var realFactProbe = {
         }
         seen += 1;
         if (item.name === ".git") repo = true;
-        const full = path5.join(folder, item.name);
+        const full = path8.join(folder, item.name);
         const name2 = prefix ? `${prefix}/${item.name}` : item.name;
         if (item.isDirectory()) walk(full, name2);
-        else entries.push({ name: name2, bornAt: bornAt(fs6.lstatSync(full)) });
+        else entries.push({ name: name2, bornAt: bornAt(fs7.lstatSync(full)) });
       }
     };
     try {
       walk(dir, "");
+      if (!repo) {
+        repo = fs7.readdirSync(dir, { withFileTypes: true }).some((item) => item.name === ".git" || item.isDirectory() && fs7.existsSync(path8.join(dir, item.name, ".git")));
+      }
       return { entries, more, repo };
     } catch {
       return null;
     }
   },
   tracked(p) {
-    if (fs6.existsSync(path5.join(p, ".git"))) return true;
-    const r = git(["-C", win2.dirname(p), "ls-files", "--", p], { GIT_ICASE_PATHSPECS: "1" });
+    if (fs7.existsSync(path8.join(p, ".git"))) return true;
+    const r = git(["-C", win4.dirname(p), "ls-files", "--", p], { GIT_ICASE_PATHSPECS: "1" });
     if (r.status === 0) return r.stdout.trim() !== "";
     return !(r.status === 128 && /not a git repository/i.test(r.stderr ?? ""));
   },
   ignored(p) {
-    if (fs6.existsSync(path5.join(p, ".git"))) return false;
-    return git(["-C", win2.dirname(p), "check-ignore", "-q", "--", p]).status === 0;
+    if (fs7.existsSync(path8.join(p, ".git"))) return false;
+    return git(["-C", win4.dirname(p), "check-ignore", "-q", "--", p]).status === 0;
   }
 };
 
 // src/rm/judge.ts
-import path6 from "path";
+import path9 from "path";
 var CALL_EXCERPT_CHARS = 600;
 var SAMPLE_FILES = 10;
 var RM_QUESTIONS = {
@@ -830,7 +1700,7 @@ ${c.text}` : c.text).slice(0, CALL_EXCERPT_CHARS) }));
   }
   return { state, questions: { ok: RM_QUESTIONS[kind] } };
 }
-var name = (item) => path6.win32.basename(item.path);
+var name = (item) => path9.win32.basename(item.path);
 var prob = (p) => p.toFixed(2);
 function lifts(items, threshold) {
   return items.length > 0 && items.every((item) => item.p !== null && item.p >= threshold);
@@ -850,6 +1720,7 @@ function askNote(lang, items) {
 
 // src/rm/run.ts
 var MAX_JEV_TARGETS = 5;
+var READ_BUDGET_MS = 9e3;
 var FACTS_BUDGET_MS = 5e3;
 var JEV_PATH_BUDGET_MS = 12e3;
 var MIN_JEV_MS = 1e3;
@@ -892,10 +1763,14 @@ async function runRmHook(raw, deps) {
   const input = JSON.parse(raw);
   if (typeof input !== "object" || input === null) return null;
   const command = input.tool_input?.command;
-  if (input.tool_name !== "Bash" || typeof command !== "string") return null;
-  const tmpdirs = [...new Set([deps.tmpdir, deps.env.TEMP, deps.env.TMP].filter((t) => Boolean(t)).map((t) => path7.win32.resolve(t)))];
+  const tool = input.tool_name;
+  if (tool !== "Bash" && tool !== "PowerShell" || typeof command !== "string") return null;
+  const tmpdirs = [...new Set([deps.tmpdir, deps.env.TEMP, deps.env.TMP].filter((t) => Boolean(t)).map((t) => path10.win32.resolve(t)))];
   const cwd = typeof input.cwd === "string" && input.cwd ? input.cwd : deps.cwd;
-  const result = decide({ command, cwd, home: deps.home, tmpdirs, env: deps.env, probe: deps.probe });
+  const ctx = { cwd, home: deps.home, tmpdirs, env: deps.env, probe: deps.probe };
+  const powershell = deps.powershell ?? realPowerShell(deps.env);
+  const read = (source) => now().getTime() - started >= READ_BUDGET_MS ? Promise.resolve(null) : powershell(source);
+  const result = await decideTool(tool, command, ctx, read);
   if (!result) return null;
   if (result.decision !== "ask" || !result.targets || !config.rm.jev) return hookOutput(result);
   const key = readJevKey(deps.env, config.keyFile);
@@ -918,6 +1793,7 @@ async function runRmHook(raw, deps) {
         event: "pre_tool_use",
         sessionId: typeof input.session_id === "string" ? input.session_id : null,
         transcriptPath: input.transcript_path,
+        tool,
         command,
         cwd,
         decision: pass ? "pass" : "ask",