@delt/claude-jev-advisor 0.1.2 → 0.3.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) {
@@ -200,31 +308,31 @@ function expand(word, vars) {
   return known && !/[$`]/.test(out) ? out : null;
 }
 function assign(word, vars, home) {
-  const name = ASSIGNMENT.exec(word.value)[1];
-  let value = expand({ value: word.value.slice(name.length + 1), dynamic: word.dynamic }, vars);
+  const name2 = ASSIGNMENT.exec(word.value)[1];
+  let value = expand({ value: word.value.slice(name2.length + 1), dynamic: word.dynamic }, vars);
   if (value !== null && /^~(?:[\\/]|$)/.test(value)) value = home + value.slice(1);
-  vars.set(name, value);
+  vars.set(name2, value);
 }
 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;
   for (; ; ) {
     while (rest.length && ASSIGNMENT.test(rest[0].value)) rest = rest.slice(1);
     if (!rest.length) return rest;
-    const name = commandName(rest[0]);
-    if (SKIP_WORDS.has(rest[0].value) || name === "command" || name === "builtin" || name === "exec" || name === "nohup") {
+    const name2 = commandName(rest[0]);
+    if (SKIP_WORDS.has(rest[0].value) || name2 === "command" || name2 === "builtin" || name2 === "exec" || name2 === "nohup") {
       rest = rest.slice(1);
       continue;
     }
-    if (name === "sudo" || name === "env") {
+    if (name2 === "sudo" || name2 === "env") {
       rest = rest.slice(1);
       while (rest.length && !rest[0].dynamic && rest[0].value.startsWith("-")) rest = rest.slice(1);
       continue;
     }
-    if (name === "timeout") {
+    if (name2 === "timeout") {
       rest = rest.slice(1);
       while (rest.length && !rest[0].dynamic && rest[0].value.startsWith("-")) rest = rest.slice(1);
       rest = rest.slice(1);
@@ -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) };
+  return { path: win2.resolve(cwd, v) };
 }
-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 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: target.value };
-  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 };
+  if (resolved.unknown) return { real: { shown: target.value, path: null } };
+  return { real: judgePath(resolved.path, pattern, ctx) ?? void 0 };
 }
-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.`
-  };
-}
-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,33 +389,36 @@ 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);
     } else if (HEADER_WORDS.has(rest[0].value)) {
       if (rest[0].value !== "case" && rest[1]) vars.set(rest[1].value, null);
     } else if (!CLOSING_WORDS.has(rest[0].value)) {
-      const name = commandName(rest[0]);
-      if (name !== null && DECLARERS.has(name)) {
+      const name2 = commandName(rest[0]);
+      if (name2 !== null && DECLARERS.has(name2)) {
         for (const w of rest.slice(1)) if (ASSIGNMENT.test(w.value)) assign(w, vars, home);
-      } else if (name === "cd" || name === "pushd" || name === "popd") {
+      } else if (name2 === "cd" || name2 === "pushd" || name2 === "popd") {
         const arg = rest[1];
         const value = arg ? expand(arg, vars) : null;
-        if (name === "popd" || arg && (value === null || value === "-")) setCwd(null);
+        if (name2 === "popd" || arg && (value === null || value === "-")) setCwd(null);
         else if (!arg) setCwd(home);
         else setCwd(toWindowsPath({ ...arg, value }, ctx.cwd, home, tmpdirs[0]).path ?? null);
-      } else if (name === "xargs") {
+      } else if (name2 === "xargs") {
         if (rest.slice(1).some((t) => {
           const n = commandName(t);
           return n === "rm" || n === "rmdir";
-        })) {
-          return deny("xargs feeding rm");
-        }
-      } else if (name === "rm" || name === "rmdir") {
+        })) 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)) {
           if (options && !t.dynamic && t.value === "--") {
@@ -328,51 +428,34 @@ 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).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}` };
-}
-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 path4 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;
 var DEFAULT_CONFIG = {
   lang: "ko",
   keyFile: null,
   display: "mod",
-  context: { enabled: true, minTokens: 1e5, compactMinTokens: 2e5, redRemainingPct: 20, unitDoneYes: 0.7, goalDoneYes: 0.8 },
+  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 }
 };
+var LEGACY_CONTEXT_DEFAULTS = { minTokens: 1e5, compactMinTokens: 2e5, unitDoneYes: 0.7 };
 var LANGS = ["ko", "en"];
 var DISPLAYS = ["mod", "statusline", "message"];
 function isRecord(value) {
@@ -386,22 +469,27 @@ function mergeSection(defaults, raw) {
   }
   return out;
 }
+function withoutLegacyDefaults(context) {
+  if (!isRecord(context)) return context;
+  return Object.fromEntries(Object.entries(context).filter(([key, value]) => LEGACY_CONTEXT_DEFAULTS[key] !== value));
+}
 function normalizeConfig(raw) {
   const r = isRecord(raw) ? raw : {};
   return {
     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,
-    context: mergeSection(DEFAULT_CONFIG.context, r.context),
+    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");
+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) {
@@ -412,17 +500,1310 @@ function readConfig(home) {
   }
 }
 
+// src/context/files.ts
+import fs3 from "fs";
+import path5 from "path";
+function logFile(home, now) {
+  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(path5.dirname(file), { recursive: true });
+  let line = JSON.stringify({ at: now.toISOString(), ...record });
+  for (const secret of secrets) {
+    if (!secret) continue;
+    for (const form of [secret, JSON.stringify(secret).slice(1, -1)]) line = line.split(form).join("[redacted]");
+  }
+  fs3.appendFileSync(file, `${line}
+`);
+}
+
+// src/jev.ts
+import fs4 from "fs";
+var JEV_URL = "https://api.typesafe.ai/v1/systemone";
+var JEV_TIMEOUT_MS = 8e3;
+var KEY_PREFIX = "TYPESAFE_API_KEY=";
+function readJevKey(env, keyFile) {
+  const fromEnv = env.TYPESAFE_API_KEY?.trim();
+  if (fromEnv) return fromEnv;
+  if (!keyFile) return null;
+  let text;
+  try {
+    text = fs4.readFileSync(keyFile, "utf8");
+  } catch {
+    return null;
+  }
+  const line = text.replace(/^\uFEFF/, "").split(/\r?\n/).find((l) => l.startsWith(KEY_PREFIX));
+  const key = line?.slice(KEY_PREFIX.length).trim().replace(/^["']|["']$/g, "");
+  return key || null;
+}
+function jevKeys(env, keyFile) {
+  return [...new Set([readJevKey(env, keyFile), readJevKey({}, keyFile)].filter((key) => Boolean(key)))];
+}
+function withoutKeys(text, keys) {
+  return keys.reduce((out, key) => out.split(key).join("[redacted]"), text);
+}
+async function callJev(request, opts) {
+  const now = opts.now ?? Date.now;
+  const fetchFn = opts.fetchFn ?? fetch;
+  const limit = opts.timeoutMs ?? JEV_TIMEOUT_MS;
+  const redact = (text) => text.split(opts.key).join("[redacted]");
+  const started = now();
+  const controller = new AbortController();
+  let timer;
+  const expired = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      const err = new Error(`Jev did not answer within ${limit} ms`);
+      controller.abort(err);
+      reject(err);
+    }, limit);
+  });
+  let requestId = null;
+  const exchange = (async () => {
+    const res = await fetchFn(JEV_URL, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${opts.key}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ model: "jev-latest", ...request }),
+      signal: controller.signal
+    });
+    requestId = res.headers.get("request-id") ?? res.headers.get("x-request-id");
+    return { res, text: await res.text() };
+  })();
+  exchange.catch(() => {
+  });
+  try {
+    const { res, text } = await Promise.race([exchange, expired]);
+    if (!res.ok) return { error: redact(`HTTP ${res.status}: ${text}`).slice(0, 300), requestId, ms: now() - started };
+    const body = JSON.parse(text);
+    const answers = {};
+    for (const [id, answer] of Object.entries(body.answers ?? {})) {
+      if (typeof answer?.noul === "number") answers[id] = answer.noul;
+    }
+    return { answers, model: typeof body.model === "string" ? body.model : null, requestId, ms: now() - started };
+  } catch (err) {
+    return { error: redact(String(err?.message ?? err)).slice(0, 300), requestId, ms: now() - started };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// 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 fs7 from "fs";
+import path8 from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+
+// src/context/transcript.ts
+import fs6 from "fs";
+var TAIL_START_BYTES = 1024 * 1024;
+var TAIL_MAX_BYTES = 8 * 1024 * 1024;
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseLines(text) {
+  const entries = [];
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const value = JSON.parse(line);
+      if (isRecord3(value)) entries.push(value);
+    } catch {
+    }
+  }
+  return entries;
+}
+
+// src/rm/facts.ts
+var SESSION_LOG_MAX_BYTES = 32 * 1024 * 1024;
+var CALLS_PER_TARGET = 3;
+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 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) {
+  const text = (key) => typeof input[key] === "string" ? input[key] : "";
+  switch (tool) {
+    case "Write":
+      return { tool, file: text("file_path"), text: text("content"), kind: result === "create" ? "create" : "change", cwd };
+    case "Edit":
+      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) => 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 };
+    case "Read":
+      return { tool, file: text("file_path"), text: "", kind: "read", cwd };
+    case "Bash":
+    case "PowerShell":
+      return { tool, file: null, text: text("command"), kind: "shell", cwd };
+    default:
+      return null;
+  }
+}
+function resultTypes(entries) {
+  const types = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    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 (isRecord4(block) && typeof block.tool_use_id === "string") types.set(block.tool_use_id, entry.toolUseResult.type);
+  }
+  return types;
+}
+function toolCalls(entries) {
+  const results = resultTypes(entries);
+  const calls = [];
+  let message;
+  let moved = false;
+  for (const entry of entries) {
+    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 (!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);
+      if (call.kind === "shell" && CHANGES_FOLDER.test(call.text)) moved = true;
+    }
+  }
+  return calls;
+}
+function readSessionLog(file, maxBytes = SESSION_LOG_MAX_BYTES) {
+  let text;
+  try {
+    if (fs7.statSync(file).size > maxBytes) return null;
+    text = fs7.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  const entries = parseLines(text);
+  const first = entries.find((e) => typeof e.timestamp === "string" && !Number.isNaN(Date.parse(e.timestamp)));
+  return first ? { startedAt: Date.parse(first.timestamp), calls: toolCalls(entries) } : null;
+}
+function normalized(text) {
+  return text.replace(/\\/g, "/").replace(/(^|[\s"'=(>])\/([A-Za-z])\//g, "$1$2:/").toLowerCase();
+}
+var escaped = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function shellRefs(target, cwd) {
+  const refs = [`(?<![\\w.-])${escaped(normalized(target))}(?![\\w.-])`];
+  const relative = cwd === null ? "" : win4.relative(cwd, target);
+  if (relative && !relative.startsWith("..") && !win4.isAbsolute(relative)) {
+    refs.push(`(?<![\\w.\\-/:])(?:\\./)?${escaped(normalized(relative))}(?![\\w.-])`);
+  }
+  return refs;
+}
+function namesTarget(call, target, folder) {
+  const wanted = normalized(target);
+  if (call.file !== null) {
+    const file = normalized(call.file);
+    return file === wanted || folder && file.startsWith(`${wanted}/`);
+  }
+  if (DELETING.test(call.text)) return false;
+  const text = normalized(call.text);
+  return shellRefs(target, call.cwd).some((ref) => new RegExp(ref).test(text));
+}
+function shellCommands(text) {
+  const commands = [];
+  let current = { words: [], writes: [] };
+  let word = null;
+  let redirect = null;
+  const endWord = () => {
+    if (word === null) return;
+    if (redirect === null) current.words.push(word);
+    else if (redirect === ">" || redirect === "&>") current.writes.push(word);
+    word = null;
+    redirect = null;
+  };
+  const endCommand = () => {
+    endWord();
+    commands.push(current);
+    current = { words: [], writes: [] };
+  };
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === "'" || c === '"') {
+      const close = text.indexOf(c, i + 1);
+      const stop = close === -1 ? text.length : close;
+      word = (word ?? "") + text.slice(i + 1, stop);
+      i = stop;
+    } else if (c === "\\") {
+      word = (word ?? "") + (text[i + 1] ?? "");
+      i += 1;
+    } else if (c === "#" && word === null) {
+      while (i + 1 < text.length && text[i + 1] !== "\n") i += 1;
+    } else if (c === " " || c === "	" || c === "\r") {
+      endWord();
+    } else if (c === "\n" || c === ";" || c === "|" || c === "(" || c === ")" || c === "&" && text[i + 1] !== ">") {
+      endCommand();
+    } else if (c === ">" || c === "<" || c === "&") {
+      if (word !== null && /^\d+$/.test(word)) word = null;
+      endWord();
+      let op = c;
+      while (text[i + 1] === ">" || text[i + 1] === "&" || text[i + 1] === "|") op += text[++i];
+      redirect = op;
+    } else {
+      word = (word ?? "") + c;
+    }
+  }
+  endCommand();
+  return commands;
+}
+var pathWord = (word) => word.replace(/\\/g, "/").replace(/^\/([A-Za-z])\//, "$1:/").replace(/^\.\//, "").replace(/\/+$/, "").toLowerCase();
+function createsTarget(call, target) {
+  if (call.kind !== "shell") return call.kind === "create";
+  const full = pathWord(target);
+  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 = 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 (MOVES.includes(name2)) moved = true;
+  }
+  return false;
+}
+function gatherFacts(target, session, probe, maxFiles) {
+  const info = probe.info(target);
+  if (!info) return null;
+  const naming = session.calls.filter((call) => namesTarget(call, target, info.folder));
+  return {
+    path: target,
+    folder: info.folder,
+    bornAt: info.bornAt,
+    listing: info.folder ? probe.list(target, maxFiles) : null,
+    tracked: probe.tracked(target),
+    ignored: info.folder && probe.ignored(target),
+    // Write, Edit and sed -i replace a file, which resets its Windows birth time, so the birth time alone cannot tell
+    // a new file from an edited one: the first call that named the target must be the one that visibly created it.
+    existedBefore: naming.length === 0 || !createsTarget(naming[0], target),
+    createdBy: naming.length <= CALLS_PER_TARGET ? naming : [naming[0], ...naming.slice(1 - CALLS_PER_TARGET)]
+  };
+}
+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));
+  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;
+function git(args, extraEnv = {}) {
+  const env = { ...process.env, LC_ALL: "C", ...extraEnv };
+  for (const name2 of GIT_LOCATION_ENV) delete env[name2];
+  return spawnSync2("git", args, { encoding: "utf8", timeout: 3e3, windowsHide: true, env });
+}
+var realFactProbe = {
+  info(p) {
+    try {
+      const stat = fs7.lstatSync(p);
+      return { folder: stat.isDirectory(), bornAt: bornAt(stat) };
+    } catch {
+      return null;
+    }
+  },
+  list(dir, limit) {
+    const entries = [];
+    let seen = 0;
+    let more = false;
+    let repo = false;
+    const walk = (folder, prefix) => {
+      for (const item of fs7.readdirSync(folder, { withFileTypes: true })) {
+        if (more) return;
+        if (seen >= limit) {
+          more = true;
+          return;
+        }
+        seen += 1;
+        if (item.name === ".git") repo = true;
+        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(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 (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 (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 path9 from "path";
+var CALL_EXCERPT_CHARS = 600;
+var SAMPLE_FILES = 10;
+var RM_QUESTIONS = {
+  session: {
+    type: "noul",
+    instructions: "Is `target` a throwaway file or folder that Claude made during this session only to try something out, so that deleting it with `command` loses nothing the user wants? `created_by` lists the tool calls of this session that name it; `git` says it is not tracked by git.",
+    criteria: {
+      true: [
+        "A scratch or probe file for a one-off check: captured output, a dump or log, a quick test script, a sample input made up for a trial.",
+        "Nothing in the tool calls treats it as part of the work the user asked for."
+      ],
+      false: [
+        "Part of the work: source code, tests in the project test folders, documentation, configuration, migrations, or data or output the user asked for.",
+        "It is unclear what it is for, or it may still be wanted."
+      ]
+    }
+  },
+  ignored: {
+    type: "noul",
+    instructions: "Is `target` a folder of generated output or cache that a build, install or tool run makes again, so that deleting it with `command` loses nothing? `git` says git ignores it; `sample` lists some of its entries.",
+    criteria: {
+      true: "Build output, compiled files, bundles, a dependency or package cache, test or coverage output, or a tool cache that is recreated on the next run.",
+      false: "Hand-made or downloaded content, user data, local configuration, secrets, logs worth keeping, or anything that cannot simply be made again; or it is unclear."
+    }
+  }
+};
+var PASS = {
+  ko: {
+    session: "Jev\uAC00 \uC774 \uC138\uC158\uC758 \uC2DC\uD5D8 \uD30C\uC77C\uB85C \uD310\uB2E8\uD574 \uBB3B\uC9C0 \uC54A\uACE0 \uC9C0\uC6C1\uB2C8\uB2E4",
+    ignored: "Jev\uAC00 \uB2E4\uC2DC \uB9CC\uB4E4 \uC218 \uC788\uB294 \uD3F4\uB354\uB85C \uD310\uB2E8\uD574 \uBB3B\uC9C0 \uC54A\uACE0 \uC9C0\uC6C1\uB2C8\uB2E4",
+    mixed: "Jev\uAC00 \uC9C0\uC6CC\uB3C4 \uB418\uB294 \uB300\uC0C1\uC73C\uB85C \uD310\uB2E8\uD574 \uBB3B\uC9C0 \uC54A\uACE0 \uC9C0\uC6C1\uB2C8\uB2E4"
+  },
+  en: {
+    session: "Jev judged it a throwaway test file of this session, so it is deleted without asking",
+    ignored: "Jev judged it a folder that is made again, so it is deleted without asking",
+    mixed: "Jev judged these safe to delete, so they are deleted without asking"
+  }
+};
+var NOTE = {
+  ko: { session: "\uC2DC\uD5D8\uC6A9 \uD30C\uC77C\uC77C \uD655\uB960", ignored: "\uB2E4\uC2DC \uB9CC\uB4E4 \uC218 \uC788\uC744 \uD655\uB960", none: "\uD310\uB2E8 \uBABB \uD568" },
+  en: { session: "chance it is a test file", ignored: "chance it can be made again", none: "no answer" }
+};
+function rmJevRequest(kind, facts, command, description, clean = (text) => text) {
+  const target = { path: facts.path, kind: facts.folder ? "folder" : "file" };
+  if (facts.listing) {
+    target.files = facts.listing.more ? `more than ${facts.listing.entries.length}` : facts.listing.entries.length;
+    target.sample = facts.listing.entries.slice(0, SAMPLE_FILES).map((e) => e.name);
+  }
+  const state = { target, command: clean(command), description: clean(description) };
+  if (kind === "session") {
+    state.created_by = facts.createdBy.map((c) => ({ tool: c.tool, input: clean(c.file ? `${c.file}
+${c.text}` : c.text).slice(0, CALL_EXCERPT_CHARS) }));
+    state.git = "untracked";
+  } else {
+    state.git = "ignored";
+  }
+  return { state, questions: { ok: RM_QUESTIONS[kind] } };
+}
+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);
+}
+function passMessage(lang, items) {
+  const kinds = new Set(items.map((i) => i.kind));
+  const phrase = PASS[lang][kinds.size === 1 ? items[0].kind : "mixed"];
+  return `[jev-advisor] ${phrase}: ${items.map((i) => `${name(i)} (${prob(i.p ?? 0)})`).join(", ")}`;
+}
+function askNote(lang, items) {
+  if (items.length === 1) {
+    const [item] = items;
+    return ` \xB7 Jev: ${item.p === null ? NOTE[lang].none : `${NOTE[lang][item.kind]} ${prob(item.p)}`}`;
+  }
+  return ` \xB7 Jev: ${items.map((i) => `${name(i)} ${i.p === null ? "?" : prob(i.p)}`).join(", ")}`;
+}
+
 // src/rm/run.ts
-function runRmHook(raw, deps) {
-  if (!readConfig(deps.home).rm.enabled) return null;
+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;
+async function judgeTargets(targets, input, command, key, keys, config, deps, elapsed) {
+  if (targets.length === 0 || targets.length > MAX_JEV_TARGETS || targets.some((t) => t.path === null)) return null;
+  if (typeof input.transcript_path !== "string") return null;
+  const session = readSessionLog(input.transcript_path);
+  if (!session) return null;
+  const found = [];
+  for (const target of targets) {
+    if (elapsed() > FACTS_BUDGET_MS) return null;
+    const facts = gatherFacts(target.path, session, deps.facts ?? realFactProbe, config.rm.maxDirFiles);
+    const kind = facts ? candidateKind(facts, session.startedAt) : null;
+    if (!facts || !kind) return null;
+    found.push({ target, facts, kind });
+  }
+  const timeoutMs = Math.min(JEV_TIMEOUT_MS, JEV_PATH_BUDGET_MS - elapsed());
+  if (timeoutMs < MIN_JEV_MS) return null;
+  const description = typeof input.tool_input?.description === "string" ? input.tool_input.description : "";
+  const answered = await Promise.all(
+    found.map(async ({ kind, facts }) => {
+      const request = rmJevRequest(kind, facts, command, description, (text) => withoutKeys(text, keys));
+      return { request, result: await callJev(request, { key, fetchFn: deps.fetchFn, timeoutMs }) };
+    })
+  );
+  return {
+    items: found.map(({ target, kind }, i) => {
+      const { result } = answered[i];
+      const p = "error" in result ? null : result.answers.ok;
+      return { path: target.path, shown: target.shown, kind, p: typeof p === "number" ? p : null };
+    }),
+    calls: answered.map(({ request, result }) => ({ state: request.state, ...result }))
+  };
+}
+async function runRmHook(raw, deps) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const started = now().getTime();
+  const config = readConfig(deps.home);
+  if (!config.rm.enabled) return null;
   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) => path4.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 });
-  return result ? hookOutput(result) : null;
+  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);
+  if (!key) return hookOutput(result);
+  const keys = jevKeys(deps.env, config.keyFile);
+  let judged = null;
+  try {
+    judged = await judgeTargets(result.targets, input, command, key, keys, config, deps, () => now().getTime() - started);
+  } catch {
+    judged = null;
+  }
+  if (!judged) return hookOutput(result);
+  const pass = lifts(judged.items, config.rm.throwawayYes);
+  try {
+    appendLog(
+      deps.home,
+      now(),
+      {
+        helper: "rm",
+        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",
+        targets: judged.items,
+        jev: judged.calls
+      },
+      keys
+    );
+  } catch {
+  }
+  if (pass) return JSON.stringify({ systemMessage: passMessage(config.lang, judged.items) });
+  return hookOutput({ ...result, reason: `${result.reason}${askNote(config.lang, judged.items)}` });
 }
 
 // src/rm/hook.ts
@@ -430,7 +1811,7 @@ async function main() {
   let raw = "";
   process.stdin.setEncoding("utf8");
   for await (const chunk of process.stdin) raw += chunk;
-  const out = runRmHook(raw, { home: os.homedir(), env: process.env, tmpdir: os.tmpdir(), cwd: process.cwd(), probe: realProbe });
+  const out = await runRmHook(raw, { home: os.homedir(), env: process.env, tmpdir: os.tmpdir(), cwd: process.cwd(), probe: realProbe });
   if (out) process.stdout.write(out);
 }
 main().catch(() => {