@delt/claude-jev-advisor 0.1.2 → 0.3.0

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) {
@@ -144,7 +164,7 @@ function updateConfig(home, change) {
 // src/features.ts
 var FEATURES = ["rm", "context"];
 var HOOK_SPECS = {
-  rm: [{ event: "PreToolUse", matcher: "Bash", script: "rm-hook.js", args: [] }],
+  rm: [{ event: "PreToolUse", matcher: "Bash|PowerShell", script: "rm-hook.js", args: [] }],
   context: [
     { event: "Stop", script: "context-hook.js", args: ["stop"] },
     { event: "SessionEnd", script: "context-hook.js", args: ["session-end"] }
@@ -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,19 @@ 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 coversPowerShell(matcher) {
+  if (!matcher || matcher === "*") return true;
+  try {
+    return new RegExp(`^(?:${matcher})$`).test("PowerShell");
+  } catch {
+    return false;
+  }
+}
 function statusLines(home, env = process.env) {
   const lines = [`settings: ${settingsPath(home)}`, `config:   ${configPath(home)}`];
   let settings;
@@ -658,11 +869,17 @@ 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 (!commands.some((c) => coversPowerShell(c.matcher))) {
+        lines.push('  Bash only: run "claude-jev-advisor install rm" to cover PowerShell');
+      }
+    }
   }
   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 +898,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 +906,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 +930,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 +952,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 +987,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 +1008,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 +1027,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 +1049,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),