@delt/claude-jev-advisor 0.1.1 → 0.2.0

package/dist/rm-hook.js

@@ -200,10 +200,10 @@ 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;
@@ -214,17 +214,17 @@ function stripPrefixes(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);
@@ -267,7 +267,7 @@ function classify(target, ctx) {
   }
   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 };
+  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);
@@ -275,7 +275,7 @@ function classify(target, ctx) {
   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 };
+  return { real: { shown, path: pattern === null ? p : null } };
 }
 function deny(why) {
   return {
@@ -302,23 +302,23 @@ function decide({ command, cwd, home, tmpdirs, env = {}, probe }) {
     } 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") {
+      } else if (name2 === "rm" || name2 === "rmdir") {
         let options = true;
         for (const t of rest.slice(1)) {
           if (options && !t.dynamic && t.value === "--") {
@@ -336,9 +336,9 @@ function decide({ command, cwd, home, tmpdirs, env = {}, probe }) {
     if (after === ")" && stack.length) setCwd(stack.pop() ?? null);
   }
   if (!real.length) return null;
-  const listed = real.slice(0, MAX_LISTED).join(", ");
+  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}` };
+  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 } });
@@ -359,20 +359,22 @@ var realProbe = {
 };
 
 // src/rm/run.ts
-import path4 from "path";
+import path7 from "path";
 
 // src/config.ts
 import fs2 from "fs";
 import path3 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,13 +388,17 @@ 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)
   };
 }
@@ -402,6 +408,7 @@ 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");
 
 // src/config.ts
 function readConfig(home) {
@@ -412,17 +419,517 @@ function readConfig(home) {
   }
 }
 
+// src/context/files.ts
+import fs3 from "fs";
+import path4 from "path";
+function logFile(home, now) {
+  return path4.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 });
+  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/facts.ts
+import fs6 from "fs";
+import path5 from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+
+// src/context/transcript.ts
+import fs5 from "fs";
+var TAIL_START_BYTES = 1024 * 1024;
+var TAIL_MAX_BYTES = 8 * 1024 * 1024;
+function isRecord2(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 (isRecord2(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 win2 = path5.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) {
+  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) => isRecord3(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" || !isRecord3(entry.toolUseResult) || typeof entry.toolUseResult.type !== "string" || !isRecord3(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);
+  }
+  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 || !isRecord3(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;
+      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 (fs6.statSync(file).size > maxBytes) return null;
+    text = fs6.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 ? "" : win2.relative(cwd, target);
+  if (relative && !relative.startsWith("..") && !win2.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 ? "" : win2.relative(call.cwd, target);
+  const short = relative && !relative.startsWith("..") && !win2.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();
+    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;
+  }
+  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));
+  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";
+  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 = fs6.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 fs6.readdirSync(folder, { withFileTypes: true })) {
+        if (more) return;
+        if (seen >= limit) {
+          more = true;
+          return;
+        }
+        seen += 1;
+        if (item.name === ".git") repo = true;
+        const full = path5.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)) });
+      }
+    };
+    try {
+      walk(dir, "");
+      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 (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;
+  }
+};
+
+// src/rm/judge.ts
+import path6 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) => path6.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 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 tmpdirs = [...new Set([deps.tmpdir, deps.env.TEMP, deps.env.TMP].filter((t) => Boolean(t)).map((t) => path7.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;
+  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,
+        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 +937,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(() => {