@delt/claude-jev-advisor 0.1.2 → 0.2.0

package/README.md

@@ -2,20 +2,23 @@
 
 Unofficial helpers for [Claude Code](https://claude.com/claude-code), installed as command hooks in `~/.claude/settings.json`. They use [TypeSafe](https://typesafe.ai) Jev for judgments that need to understand the conversation.
 
-The `context` helper sends parts of your conversation to TypeSafe's Jev API (`api.typesafe.ai`): your last three requests, each cut to its first 1,000 characters, and Claude's last reply, cut to its first and last 1,500 characters. The `rm` helper sends nothing.
+What is sent to TypeSafe's Jev API (`api.typesafe.ai`):
+
+- `context`: your last three requests (typed by you, or sent through a channel or from another Claude Code session), each cut to its first 1,000 characters, and Claude's last reply, cut to its first and last 1,500 characters.
+- `rm`: only for a delete it would otherwise ask about, and only when the target is a file this session made or a folder git ignores. It sends the path, the `rm` command and its description, up to three tool calls of this session that name the target (each cut to 600 characters), and for a folder up to ten of its file names.
 
 Not affiliated with Anthropic or TypeSafe.
 
 | Helper | What it does | Systems |
 |---|---|---|
 | `context` | At the end of each turn, suggests `/compact` or `/clear` when the conversation is large and the work has reached a stopping point. Shown at the end of Claude Code's bottom row. | Any |
-| `rm` | Asks before a Bash `rm` deletes real files. Lets temp files through and refuses an `rm` whose targets it cannot work out. | Windows |
+| `rm` | Asks before a Bash `rm` deletes real files. Lets temp files through and refuses an `rm` whose targets it cannot work out. Jev can lift the ask for a test file this session made or a folder git ignores. | Windows |
 
 ## Requirements
 
 - Node.js 18 or later
 - Claude Code (the bottom-row display uses Claude Code mods, an early-access feature that may change between releases)
-- A TypeSafe API key for the `context` helper, in `TYPESAFE_API_KEY` or in a key file (`--key-file`)
+- A TypeSafe API key for the `context` helper and for the Jev check of the `rm` helper, in `TYPESAFE_API_KEY` or in a key file (`--key-file`). Without a key, `rm` asks about every real file.
 - Windows for the `rm` helper. On other systems `install` skips it and says why.
 
 ## Install
@@ -44,6 +47,7 @@ The hooks also reach Claude Code sessions that are already open; the bottom-row
 | `claude-jev-advisor uninstall [rm] [context]` | Removes this package's hooks and display from `settings.json` |
 | `claude-jev-advisor on [rm] [context]` / `off [rm] [context]` | Switches helpers on or off without touching `settings.json` |
 | `claude-jev-advisor status` | Shows what is registered and on, the display, whether a key is set, the thresholds and the last judgment |
+| `claude-jev-advisor report [--days 7]` | Lists the `/compact` and `/clear` advice shown and what followed it, and the deletions Jev let through |
 | `claude-jev-advisor key` | Asks for the TypeSafe API key, checks it and saves it (needs an interactive terminal) |
 | `claude-jev-advisor help` | Prints the usage |
 
@@ -51,32 +55,33 @@ If you leave out the helper names, the command applies to all helpers. The displ
 
 ## The context helper
 
-When a turn ends, a `Stop` hook reads the size of the conversation from the session transcript. From 100k tokens it asks Jev two questions about the last three requests and the last reply:
+When a turn ends, a `Stop` hook reads the size of the conversation from the session transcript. If the turn's last reply is not in the transcript yet, it waits up to 3 seconds for it. From 250k tokens it asks Jev two questions about the last three requests and the last reply:
 
-- has the work asked for reached a natural stopping point?
-- is the goal behind it finished, with nothing left to do next?
+- has Claude finished or handed back the work asked for, so this is a natural break?
+- does the reply close a whole stage of the work (a plan carried out and pushed, a release, a finished investigation, a design or plan saved as a document), so the next stage can start from the saved results?
 
-The answer is saved for the display. Nothing is added to what Claude sees, so it costs no Claude tokens. If Jev does not answer within 8 seconds, only the size is shown.
+The answer is saved for the display. Nothing is added to what Claude sees, so it costs no Claude tokens. If Jev does not answer within 8 seconds, only the size is shown. While a subagent or a workflow runs in the background, the turn counts as work in progress and Jev is not asked; background shells and monitors do not count.
 
 | Situation | Shown |
 |---|---|
-| Under 100k, or no judgment (no key, Jev unreachable) | `52k` |
+| Under 250k, or no judgment (no key, Jev unreachable) | `52k` |
 | Work in progress | `🟢 312k` |
-| Goal finished (from 100k) | `🟡 312k 새롭게 시작하는 건 어떠세요? /clear` |
-| Work unit finished (from 200k) | `🟡 312k 지금까지 정리하고 이어가는 건 어떠세요? /compact` |
-| Work unit finished, under 200k | `🟢 150k` |
+| A whole stage closed (from 250k) | `🟡 312k 새롭게 시작하는 건 어떠세요? /clear` |
+| Work finished, stage goes on (from 250k) | `🟡 312k 지금까지 정리하고 이어가는 건 어떠세요? /compact` |
 | Within 20% of auto-compact | `🔴 790k 18%`, then ` · ` and the `/clear` or `/compact` advice above, or `작업이 끝나면 정리하고 이어가는 건 어떠세요? /compact` while the work is still going |
 
 With `--lang en` the advice reads `Start fresh? /clear`, `Wrap up what you have and continue? /compact` and `When this work is done, wrap up and continue? /compact`.
 
-`/clear` is suggested only when Jev is confident the goal is finished; when in doubt it suggests `/compact`. `/compact` waits until 200k because compacting a smaller conversation costs more than it saves. The suggestion is hidden while a new request runs, and a judgment made before a `/compact` is dropped.
+Judging starts at 250k because a conversation passes 100k after a request or two, and compacting a small conversation costs more than it saves. If you set `compactMinTokens` above `minTokens`, finished work between the two stays green. The suggestion is hidden while a new request runs, and a judgment made before a `/compact` is dropped.
 
 | `--display` | Where |
 |---|---|
 | `mod` (default) | At the end of the bottom row, after `⏵⏵ … mode on`. A small Claude Code mod in the package's `mod/` folder draws it. The mod is listed in `env.CLAUDE_CODE_PLUGIN_DIRS` and told the data folder through `pluginConfigs`. |
-| `statusline` | Claude Code's status line, the row above the bottom row. An existing status line of yours keeps running first, with our text after it, and is put back when you switch away or uninstall. On Windows that command is run through `cmd.exe`, so a status line that needs bash may not show. No red zone, because the auto-compact threshold is not known there. |
+| `statusline` | Claude Code's status line, the row above the bottom row. An existing status line of yours keeps running first, with our text after it, and is put back when you switch away or uninstall. On Windows that command runs in Git Bash when it is installed and in PowerShell otherwise, as Claude Code runs it; it gets 2 seconds. No red zone, because the auto-compact threshold is not known there. |
 | `message` | A `Stop says: …` line in the transcript when there is advice. Claude does not see it. No red zone. |
 
+`claude-jev-advisor report` shows each piece of advice with the time, the session, the size, Jev's answers, the start of the last request and what followed: compacted or cleared within the next three requests, auto-compacted, or kept going.
+
 ## The rm helper
 
 It runs before every Bash tool call (`PreToolUse`, matcher `Bash`, 15-second timeout) and looks only at `rm`, `rmdir` and `xargs`.
@@ -87,7 +92,7 @@ It runs before every Bash tool call (`PreToolUse`, matcher `Bash`, 15-second tim
 | A path with a `.superpowers` folder in it | No decision |
 | A path that does not exist | No decision |
 | A git-ignored path inside a build folder (`target`, `build`, `dist`, `out`, `node_modules`, `coverage`, `__pycache__`, `.pytest_cache`, `.gradle`, `.next`, `.nuxt`, `.turbo`, `.cache`, `bin`, `obj`) | No decision |
-| Any other existing file or folder | `ask`, with the reason `실제 파일 삭제: <paths>` ("deleting real files") |
+| Any other existing file or folder | `ask`, with the reason `실제 파일 삭제: <paths>` ("deleting real files"), unless Jev lifts it (below) |
 | A target it cannot work out | `deny`, with a hint to rewrite the command using literal paths |
 
 A target cannot be worked out when it uses:
@@ -113,9 +118,20 @@ What its decisions do depends on Claude Code's permission mode:
 | `bypassPermissions` | A prompt. Claude Code's documentation does not say this; it was seen in a test on 2026-10-03. | Blocked | Runs |
 | Other modes | A prompt (`dontAsk` refuses the call instead) | Blocked | Claude Code's normal permission handling |
 
+### When Jev can lift the ask
+
+The facts are checked by code; Jev only judges what the target is for. Jev is asked only when every target of the command is one of these (at most five):
+
+| Target | Checked first | Jev is asked |
+|---|---|---|
+| A file or folder this session made | Not tracked by git; the first call of this session that names it created it: a Write that made a new file, or a shell command whose `>` redirect, `touch`, `mkdir` or `curl -o` makes it (deletes do not count, and a Read, an Edit or any other shell command first means it was already there); made after the session started; for a folder, every file inside too, and at most 50 files | Is it a throwaway made only to try something out? |
+| A folder git ignores, outside the build folders above | It is a folder (a single ignored file such as `.env` still asks) | Is it generated output or a cache that is made again? |
+
+When Jev answers 0.8 or more for every target, the hook makes no decision (the last column of the table above), and a line like `[jev-advisor] Jev가 이 세션의 시험 파일로 판단해 묻지 않고 지웁니다: out.json (0.93)` is shown. Otherwise the ask stays, with Jev's answer added: `실제 파일 삭제: …\out.json · Jev: 시험용 파일일 확률 0.42`. Without a key, when Jev fails, or with `"jev": false`, every real file asks as before. A `deny` is never sent to Jev.
+
 `install rm` also replaces an older personal hook at `~/.claude/hooks/rm-guard/rm-guard.mjs` if one is registered. Its files are left in place.
 
-If a hook of this package fails in any way, it prints nothing and exits 0, so it never blocks Claude Code.
+If a hook of this package fails in any way, it prints nothing and exits 0, so it never blocks Claude Code. A failure during the Jev check of `rm` leaves the ask in place.
 
 ## Uninstall
 
@@ -134,26 +150,28 @@ A key saved by `install` or `key` stays in `~/.claude/claude-jev-advisor/jev-key
 
 | Path | Contents |
 |---|---|
-| `~/.claude/claude-jev-advisor/config.json` | Switches and settings. A missing or broken file reads as the defaults. A value of the wrong type falls back to its default, so only `"enabled": false` turns a helper off. |
+| `~/.claude/claude-jev-advisor/config.json` | Switches and settings that differ from the defaults. A missing or broken file reads as the defaults. A value of the wrong type falls back to its default, so only `"enabled": false` turns a helper off. |
 | `~/.claude/claude-jev-advisor/state/<session>.json` | The last judgment of each open session, read by the display. Removed when the session ends. |
-| `~/.claude/claude-jev-advisor/log/YYYY-MM.jsonl` | One line per judgment: the size, what was sent to Jev (parts of your conversation), the answers and the result. Never the key. |
+| `~/.claude/claude-jev-advisor/log/YYYY-MM.jsonl` | One line per context judgment and per `rm` Jev check: the size or the command, what was sent to Jev (parts of your conversation), the answers and the result. Never the key. |
 | `~/.claude/claude-jev-advisor/statusline-before.json` | Your own status line while `--display statusline` is in use |
 | `~/.claude/claude-jev-advisor/jev-key.env` | Your TypeSafe API key, when you typed it in `install` or `key` |
 | `~/.claude/backups/settings.json.*-before-claude-jev-advisor` | Copies of `settings.json` from before each change |
 
-Default config:
+Defaults:
 
 ```json
 {
   "lang": "ko",
   "keyFile": null,
   "display": "mod",
-  "context": { "enabled": true, "minTokens": 100000, "compactMinTokens": 200000, "redRemainingPct": 20, "unitDoneYes": 0.7, "goalDoneYes": 0.8 },
+  "context": { "enabled": true, "minTokens": 250000, "compactMinTokens": 250000, "redRemainingPct": 20, "unitDoneYes": 0.6, "phaseDoneYes": 0.6 },
   "rm": { "enabled": true, "jev": true, "throwawayYes": 0.8, "maxDirFiles": 50 }
 }
 ```
 
-`minTokens` is where judging starts, `compactMinTokens` where `/compact` is suggested, `redRemainingPct` where the red zone starts, and `unitDoneYes` / `goalDoneYes` are the Jev probabilities needed for "unit finished" and "goal finished". The `rm` settings other than `enabled` are reserved for a later version.
+`minTokens` is where judging starts, `compactMinTokens` where `/compact` is suggested, `redRemainingPct` where the red zone starts, and `unitDoneYes` / `phaseDoneYes` are the Jev probabilities needed for "work finished" (`/compact`) and "stage closed" (`/clear`). For `rm`, `jev` switches the Jev check, `throwawayYes` is the probability needed to lift an ask, and `maxDirFiles` the most files a folder of this session may hold.
+
+`config.json` keeps only the values you changed, with `"version": 2`. A config written by 0.1.x, which saved every value, has its old default thresholds (`minTokens` 100000, `compactMinTokens` 200000, `unitDoneYes` 0.7) read as unset, so the new defaults apply.
 
 ## Development
 

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import os from "os";
-import path9 from "path";
+import path10 from "path";
 import { fileURLToPath } from "url";
 
 // src/cli/prompt.ts
@@ -71,21 +71,23 @@ function terminalPrompt(terminal = PROCESS_TERMINAL) {
 }
 
 // src/cli/run.ts
-import fs7 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path9 from "path";
 
 // src/config.ts
 import fs from "fs";
 import path2 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) {
@@ -99,16 +101,33 @@ 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)
   };
 }
+function changedValues(values, defaults) {
+  return Object.fromEntries(Object.entries(values).filter(([key, value]) => value !== defaults[key]));
+}
+function configToSave(config) {
+  const { context, rm, ...top } = config;
+  const { context: defaultContext, rm: defaultRm, ...defaultTop } = DEFAULT_CONFIG;
+  const out = { version: CONFIG_VERSION, ...changedValues(top, defaultTop) };
+  const changedContext = changedValues(context, defaultContext);
+  const changedRm = changedValues(rm, defaultRm);
+  if (Object.keys(changedContext).length) out.context = changedContext;
+  if (Object.keys(changedRm).length) out.rm = changedRm;
+  return out;
+}
 
 // src/paths.ts
 import path from "path";
@@ -118,6 +137,7 @@ var configPath = (home) => path.join(dataDir(home), "config.json");
 var settingsPath = (home) => path.join(claudeDir(home), "settings.json");
 var backupsDir = (home) => path.join(claudeDir(home), "backups");
 var stateDir = (home) => path.join(dataDir(home), "state");
+var logDir = (home) => path.join(dataDir(home), "log");
 var statusLineBeforePath = (home) => path.join(dataDir(home), "statusline-before.json");
 var savedKeyPath = (home) => path.join(dataDir(home), "jev-key.env");
 
@@ -132,7 +152,7 @@ function readConfig(home) {
 function writeConfig(home, config) {
   const file = configPath(home);
   fs.mkdirSync(path2.dirname(file), { recursive: true });
-  fs.writeFileSync(file, `${JSON.stringify(config, null, 2)}
+  fs.writeFileSync(file, `${JSON.stringify(configToSave(config), null, 2)}
 `);
 }
 function updateConfig(home, change) {
@@ -247,8 +267,8 @@ function withoutModDisplay(settings, delimiter) {
   const dirs = env?.[PLUGIN_DIRS_ENV];
   if (env && typeof dirs === "string") {
     const all = dirs.split(delimiter);
-    const kept = all.filter((dir) => !MOD_DIR_PATTERN.test(forwardSlashes2(dir)));
-    if (kept.length !== all.length) {
+    if (all.some((dir) => MOD_DIR_PATTERN.test(forwardSlashes2(dir)))) {
+      const kept = all.filter((dir) => dir !== "" && !MOD_DIR_PATTERN.test(forwardSlashes2(dir)));
       const { [PLUGIN_DIRS_ENV]: _ours, ...otherEnv } = env;
       const nextEnv = kept.length ? { ...env, [PLUGIN_DIRS_ENV]: kept.join(delimiter) } : otherEnv;
       next = Object.keys(nextEnv).length ? { ...next, env: nextEnv } : withoutKey(next, "env");
@@ -264,11 +284,11 @@ function withoutModDisplay(settings, delimiter) {
 function withModDisplay(settings, modDir, dataDirPath, delimiter) {
   const base = withoutModDisplay(settings, delimiter);
   const env = isRecord2(base.env) ? base.env : {};
-  const dirs = typeof env[PLUGIN_DIRS_ENV] === "string" && env[PLUGIN_DIRS_ENV] !== "" ? `${env[PLUGIN_DIRS_ENV]}${delimiter}` : "";
+  const dirs = typeof env[PLUGIN_DIRS_ENV] === "string" ? env[PLUGIN_DIRS_ENV].split(delimiter).filter(Boolean) : [];
   const configs = isRecord2(base.pluginConfigs) ? base.pluginConfigs : {};
   return {
     ...base,
-    env: { ...env, [PLUGIN_DIRS_ENV]: `${dirs}${forwardSlashes2(modDir)}` },
+    env: { ...env, [PLUGIN_DIRS_ENV]: [...dirs, forwardSlashes2(modDir)].join(delimiter) },
     pluginConfigs: { ...configs, [MOD_PLUGIN_NAME]: { options: { dataDir: forwardSlashes2(dataDirPath) } } }
   };
 }
@@ -548,10 +568,42 @@ async function promptForKey(prompt, check) {
   }
 }
 
-// src/status.ts
-import fs6 from "fs";
+// src/report.ts
+import fs7 from "fs";
 import path7 from "path";
 
+// src/context/transcript.ts
+import fs6 from "fs";
+var TAIL_START_BYTES = 1024 * 1024;
+var TAIL_MAX_BYTES = 8 * 1024 * 1024;
+var REQUEST_ORIGINS = /* @__PURE__ */ new Set(["human", "channel", "peer"]);
+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;
+}
+function messageText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((block) => isRecord3(block) && block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n");
+}
+function isRequest(entry) {
+  return entry.type === "user" && entry.isSidechain !== true && isRecord3(entry.origin) && REQUEST_ORIGINS.has(String(entry.origin.kind));
+}
+function requestText(entry) {
+  return messageText(isRecord3(entry.message) ? entry.message.content : void 0).trim();
+}
+
 // src/display/line.ts
 var PHRASES = {
   ko: {
@@ -565,7 +617,7 @@ var PHRASES = {
     compactLater: "When this work is done, wrap up and continue? /compact"
   }
 };
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function formatSize(tokens) {
@@ -574,6 +626,11 @@ function formatSize(tokens) {
 function remainingPct(size, threshold) {
   return Math.max(0, Math.round((threshold - size) / threshold * 100));
 }
+function adviceKind(size, judgment, config) {
+  if (size === null || size < config.context.minTokens || !judgment || judgment.phase === "working") return null;
+  if (judgment.clear) return "clear";
+  return size >= config.context.compactMinTokens ? "compact" : null;
+}
 function adviceLine({ size, threshold, judgment, config }) {
   if (size === null) return "";
   const k = formatSize(size);
@@ -586,41 +643,181 @@ function adviceLine({ size, threshold, judgment, config }) {
     return `${head} \xB7 ${counted.clear ? phrases.clear : phrases.compact}`;
   }
   if (!counted) return k;
-  if (counted.phase === "working") return `\u{1F7E2} ${k}`;
-  if (counted.clear) return `\u{1F7E1} ${k} ${phrases.clear}`;
-  if (size >= config.context.compactMinTokens) return `\u{1F7E1} ${k} ${phrases.compact}`;
-  return `\u{1F7E2} ${k}`;
+  const kind = adviceKind(size, counted, config);
+  return kind ? `\u{1F7E1} ${k} ${phrases[kind]}` : `\u{1F7E2} ${k}`;
 }
 function parseState(raw) {
-  if (!isRecord3(raw) || typeof raw.sessionId !== "string" || typeof raw.at !== "number") return null;
+  if (!isRecord4(raw) || typeof raw.sessionId !== "string" || typeof raw.at !== "number") return null;
   const j = raw.judgment;
-  const judgment = isRecord3(j) && (j.phase === "working" || j.phase === "unit_done") && typeof j.clear === "boolean" ? { phase: j.phase, clear: j.clear } : null;
+  const judgment = isRecord4(j) && (j.phase === "working" || j.phase === "unit_done") && typeof j.clear === "boolean" ? { phase: j.phase, clear: j.clear } : null;
   return { sessionId: raw.sessionId, at: raw.at, size: typeof raw.size === "number" ? raw.size : null, judgment };
 }
 
+// src/report.ts
+var FOLLOW_REQUESTS = 3;
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function monthFiles(home, since, now) {
+  const files = [];
+  for (let d = new Date(since.getFullYear(), since.getMonth(), 1); d <= now; d = new Date(d.getFullYear(), d.getMonth() + 1, 1)) {
+    files.push(path7.join(logDir(home), `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}.jsonl`));
+  }
+  return files;
+}
+function readLogRecords(home, since, now) {
+  const records = [];
+  for (const file of monthFiles(home, since, now)) {
+    let text;
+    try {
+      text = fs7.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    for (const record of parseLines(text)) {
+      const at = typeof record.at === "string" ? Date.parse(record.at) : NaN;
+      if (at >= since.getTime() && at <= now.getTime()) records.push(record);
+    }
+  }
+  return records;
+}
+function adviceOf(record, config) {
+  if ("advice" in record) return record.advice === "clear" || record.advice === "compact" ? record.advice : null;
+  const state = parseState({ sessionId: record.sessionId, at: 0, size: record.size, judgment: record.judgment });
+  return state ? adviceKind(state.size, state.judgment, config) : null;
+}
+function outcomeAfter(entries, at, endedByClear) {
+  let requests = 0;
+  for (const entry of entries) {
+    const time = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : NaN;
+    if (!(time > at)) continue;
+    if (entry.type === "system" && entry.subtype === "compact_boundary") {
+      const trigger = isRecord5(entry.compactMetadata) ? entry.compactMetadata.trigger : void 0;
+      return { kind: trigger === "auto" ? "auto_compact" : "compact" };
+    }
+    if (isRequest(entry) && requestText(entry)) {
+      requests += 1;
+      if (requests >= FOLLOW_REQUESTS) return { kind: "kept", requests };
+    }
+  }
+  return endedByClear ? { kind: "clear" } : { kind: "kept", requests };
+}
+function adviceRows(home, now, days) {
+  const config = readConfig(home);
+  const records = readLogRecords(home, new Date(now.getTime() - days * DAY_MS), now);
+  const cleared = new Set(records.filter((r) => r.event === "session_end" && r.reason === "clear").map((r) => r.sessionId));
+  const transcripts = /* @__PURE__ */ new Map();
+  const entriesOf = (file) => {
+    if (typeof file !== "string") return null;
+    if (!transcripts.has(file)) {
+      try {
+        transcripts.set(file, parseLines(fs7.readFileSync(file, "utf8")));
+      } catch {
+        transcripts.set(file, null);
+      }
+    }
+    return transcripts.get(file) ?? null;
+  };
+  const rows = [];
+  for (const record of records) {
+    if (record.helper !== "context" || record.event !== "stop" || typeof record.sessionId !== "string" || typeof record.size !== "number") continue;
+    const advice = adviceOf(record, config);
+    if (!advice) continue;
+    const at = new Date(record.at);
+    const entries = entriesOf(record.transcriptPath);
+    const jev = isRecord5(record.jev) ? record.jev : {};
+    const state = isRecord5(jev.state) ? jev.state : {};
+    const requests = Array.isArray(state.recent_requests) ? state.recent_requests : [];
+    const last = requests[requests.length - 1];
+    rows.push({
+      at,
+      sessionId: record.sessionId,
+      size: record.size,
+      advice,
+      answers: isRecord5(jev.answers) ? jev.answers : null,
+      request: typeof last === "string" ? last : "",
+      outcome: entries ? outcomeAfter(entries, at.getTime(), cleared.has(record.sessionId)) : { kind: "unknown" }
+    });
+  }
+  return rows;
+}
+function localTime(date) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}-${p(date.getMonth() + 1)}-${p(date.getDate())} ${p(date.getHours())}:${p(date.getMinutes())}`;
+}
+function outcomeText(outcome) {
+  switch (outcome.kind) {
+    case "compact":
+      return "compacted";
+    case "clear":
+      return "cleared";
+    case "auto_compact":
+      return "auto-compacted";
+    case "kept":
+      return outcome.requests >= FOLLOW_REQUESTS ? `kept going, ${FOLLOW_REQUESTS}+ requests` : `kept going, ${outcome.requests} request${outcome.requests === 1 ? "" : "s"}`;
+    default:
+      return "transcript not found";
+  }
+}
+function answersText(answers) {
+  if (!answers) return "";
+  return Object.entries(answers).filter(([, p]) => typeof p === "number").map(([id, p]) => `${id.replace(/_done$/, "")} ${p.toFixed(2)}`).join(" ");
+}
+function rmLines(home, now, days) {
+  const records = readLogRecords(home, new Date(now.getTime() - days * DAY_MS), now).filter((r) => r.helper === "rm");
+  const passed = records.filter((r) => r.decision === "pass");
+  const lines = [`rm deletions Jev let through: ${passed.length} (asked anyway after a Jev check: ${records.length - passed.length})`];
+  for (const record of passed) {
+    const targets = Array.isArray(record.targets) ? record.targets.filter(isRecord5) : [];
+    const listed = targets.map((t) => `${String(t.shown)} (${typeof t.p === "number" ? t.p.toFixed(2) : "?"})`).join(", ");
+    lines.push(`  ${localTime(new Date(record.at))}  ${String(record.sessionId ?? "").slice(0, 8)}  ${listed}`);
+  }
+  return lines;
+}
+function reportLines(home, now, days) {
+  const rows = adviceRows(home, now, days);
+  const lines = [`Advice shown in the last ${days} day${days === 1 ? "" : "s"}: ${rows.length}`];
+  for (const row of rows) {
+    const request = row.request.replace(/\s+/g, " ").trim().slice(0, 40);
+    lines.push(`  ${localTime(row.at)}  ${row.sessionId.slice(0, 8)}  ${formatSize(row.size)}  /${row.advice}  ${answersText(row.answers)}  "${request}"  -> ${outcomeText(row.outcome)}`);
+  }
+  for (const advice of ["clear", "compact"]) {
+    const mine = rows.filter((r) => r.advice === advice);
+    if (!mine.length) continue;
+    const count = (kind) => mine.filter((r) => r.outcome.kind === kind).length;
+    lines.push(
+      `/${advice}: ${mine.length} - compacted ${count("compact")}, cleared ${count("clear")}, auto-compacted ${count("auto_compact")}, kept going ${count("kept")}, unknown ${count("unknown")}`
+    );
+  }
+  return [...lines, ...rmLines(home, now, days)];
+}
+
 // src/status.ts
+import fs8 from "fs";
+import path8 from "path";
 var SCRIPT_IN_COMMAND = /^node "([^"]+)"/;
-function isRecord4(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function displaySetUp(settings, config) {
   if (config.display === "message") return true;
   if (config.display === "statusline") return isOurStatusLine(settings.statusLine);
-  const env = isRecord4(settings.env) ? settings.env : {};
+  const env = isRecord6(settings.env) ? settings.env : {};
   const dirs = typeof env[PLUGIN_DIRS_ENV] === "string" ? env[PLUGIN_DIRS_ENV] : "";
-  const hasDir = dirs.split(path7.delimiter).some((dir) => MOD_DIR_PATTERN.test(dir.replace(/\\/g, "/")));
-  return hasDir && isRecord4(settings.pluginConfigs) && MOD_PLUGIN_NAME in settings.pluginConfigs;
+  const hasDir = dirs.split(path8.delimiter).some((dir) => MOD_DIR_PATTERN.test(dir.replace(/\\/g, "/")));
+  return hasDir && isRecord6(settings.pluginConfigs) && MOD_PLUGIN_NAME in settings.pluginConfigs;
 }
 function newestState(home) {
   let newest = null;
   try {
-    for (const name of fs6.readdirSync(stateDir(home))) {
+    for (const name of fs8.readdirSync(stateDir(home))) {
       if (!name.endsWith(".json")) continue;
-      const file = path7.join(stateDir(home), name);
-      const mtime = fs6.statSync(file).mtimeMs;
+      const file = path8.join(stateDir(home), name);
+      const mtime = fs8.statSync(file).mtimeMs;
       if (!newest || mtime > newest.mtime) newest = { file, mtime };
     }
-    return newest ? parseState(JSON.parse(fs6.readFileSync(newest.file, "utf8"))) : null;
+    return newest ? parseState(JSON.parse(fs8.readFileSync(newest.file, "utf8"))) : null;
   } catch {
     return null;
   }
@@ -630,7 +827,8 @@ function contextLines(home, settings, config, env) {
   const lines = [
     `  display: ${config.display}${displaySetUp(settings, config) ? "" : ` (not set up in settings.json - run "claude-jev-advisor install context --display ${config.display}")`}`,
     `  key: ${readJevKey(env, config.keyFile) ? "set" : "missing"}`,
-    `  thresholds: judge from ${formatSize(c.minTokens)}, /compact from ${formatSize(c.compactMinTokens)}, red at ${c.redRemainingPct}% left`
+    `  thresholds: judge from ${formatSize(c.minTokens)}, /compact from ${formatSize(c.compactMinTokens)}, red at ${c.redRemainingPct}% left`,
+    `  Jev: work done from ${c.unitDoneYes}, stage done (/clear) from ${c.phaseDoneYes}`
   ];
   const last = newestState(home);
   if (last) {
@@ -639,6 +837,11 @@ function contextLines(home, settings, config, env) {
   }
   return lines;
 }
+function rmJevLine(config, env) {
+  if (!config.rm.jev) return "  jev: off";
+  const key = readJevKey(env, config.keyFile) ? "" : " (no key - every real file asks)";
+  return `  jev: on, lifts the ask from ${config.rm.throwawayYes}${key}`;
+}
 function statusLines(home, env = process.env) {
   const lines = [`settings: ${settingsPath(home)}`, `config:   ${configPath(home)}`];
   let settings;
@@ -658,11 +861,12 @@ function statusLines(home, env = process.env) {
     lines.push(`${feature}: installed, ${state}`);
     for (const c of commands) {
       const script = SCRIPT_IN_COMMAND.exec(c.command)?.[1];
-      if (script && !fs6.existsSync(script)) {
+      if (script && !fs8.existsSync(script)) {
         lines.push(`  broken: ${c.event} hook points to a missing file (${script}) - run "claude-jev-advisor install ${feature}" again, or "claude-jev-advisor uninstall ${feature}"`);
       }
     }
     if (feature === "context") lines.push(...contextLines(home, settings, config, env));
+    if (feature === "rm") lines.push(rmJevLine(config, env));
   }
   if (findCommands(settings, LEGACY_RM_GUARD).length) {
     lines.push('legacy rm-guard hook (~/.claude/hooks/rm-guard) is still registered - "claude-jev-advisor install rm" replaces it');
@@ -681,6 +885,7 @@ var USAGE = [
   "  off [rm] [context]         switch helpers off (open sessions too)",
   "  status                     show what is registered and switched on",
   "  key                        ask for the TypeSafe API key, check it and save it",
+  "  report [--days 7]          list the /compact and /clear advice shown and what followed",
   "",
   "Options for install: --lang ko|en  --key-file <path>  --display mod|statusline|message",
   'The display is set up when context is installed: "install context --display <mode>" switches it.',
@@ -688,6 +893,7 @@ var USAGE = [
   'Run "claude-jev-advisor uninstall" before "npm rm -g": npm does not run uninstall scripts.'
 ].join("\n");
 var INSTALL_OPTIONS = ["lang", "key-file", "display"];
+var REPORT_DAYS = 7;
 var LANGS2 = ["ko", "en"];
 var DISPLAYS2 = ["mod", "statusline", "message"];
 function parse(argv) {
@@ -711,7 +917,12 @@ function parse(argv) {
 }
 function checkOptions(command, options) {
   const names = Object.keys(options);
-  if (command !== "install") return names.length ? `options are only for install (got --${names[0]})` : null;
+  if (command === "report") {
+    const unknown2 = names.find((n) => n !== "days");
+    if (unknown2) return `unknown option --${unknown2}`;
+    return options.days === void 0 || /^[1-9]\d{0,3}$/.test(options.days) ? null : "--days takes a whole number of days from 1";
+  }
+  if (command !== "install") return names.length ? `options are only for install and report (got --${names[0]})` : null;
   const unknown = names.find((n) => !INSTALL_OPTIONS.includes(n));
   if (unknown) return `unknown option --${unknown}`;
   if (options.lang !== void 0 && !LANGS2.includes(options.lang)) return "--lang takes ko or en";
@@ -728,7 +939,7 @@ async function askAndSaveKey(io, prompt) {
   const file = saveJevKey(io.home, key);
   updateConfig(io.home, (c) => ({ ...c, keyFile: file }));
   io.out(`Saved the key to ${file}`);
-  if (before && path8.resolve(before) !== path8.resolve(file)) io.out(`The config now uses this file instead of ${before}.`);
+  if (before && path9.resolve(before) !== path9.resolve(file)) io.out(`The config now uses this file instead of ${before}.`);
   if ((io.env ?? process.env).TYPESAFE_API_KEY?.trim()) io.out("TYPESAFE_API_KEY is set in your environment; the hooks use it before the saved key.");
 }
 async function ensureKey(io, keyFileGiven) {
@@ -763,7 +974,7 @@ async function runCli(argv, io) {
           platform: io.platform,
           now: io.now(),
           lang: options.lang,
-          keyFile: options["key-file"] === void 0 || path8.isAbsolute(options["key-file"]) ? options["key-file"] : path8.resolve(options["key-file"]),
+          keyFile: options["key-file"] === void 0 || path9.isAbsolute(options["key-file"]) ? options["key-file"] : path9.resolve(options["key-file"]),
           display: options.display
         });
         for (const f of r.installed) io.out(`installed ${f}`);
@@ -784,7 +995,7 @@ async function runCli(argv, io) {
         if (!r.removed.length) io.out("nothing to remove");
         for (const f of r.removed) io.out(`removed ${f}`);
         if (r.backup) io.out(`backup: ${r.backup}`);
-        if (r.removed.includes("context") && fs7.existsSync(savedKeyPath(io.home))) io.out(`kept your saved TypeSafe key at ${savedKeyPath(io.home)}`);
+        if (r.removed.includes("context") && fs9.existsSync(savedKeyPath(io.home))) io.out(`kept your saved TypeSafe key at ${savedKeyPath(io.home)}`);
         return 0;
       }
       case "key": {
@@ -803,6 +1014,9 @@ async function runCli(argv, io) {
       case "status":
         for (const line of statusLines(io.home)) io.out(line);
         return 0;
+      case "report":
+        for (const line of reportLines(io.home, io.now(), options.days === void 0 ? REPORT_DAYS : Number(options.days))) io.out(line);
+        return 0;
       case "help":
       case "--help":
       case "-h":
@@ -822,7 +1036,7 @@ async function runCli(argv, io) {
 // src/cli.ts
 runCli(process.argv.slice(2), {
   home: os.homedir(),
-  distDir: path9.dirname(fileURLToPath(import.meta.url)),
+  distDir: path10.dirname(fileURLToPath(import.meta.url)),
   platform: process.platform,
   now: () => /* @__PURE__ */ new Date(),
   out: (line) => console.log(line),