@joenandez/academy 0.4.0 → 0.5.12

package/hooks/roque/roque.js

@@ -0,0 +1,1690 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/main.ts
+var import_node_fs10 = __toESM(require("node:fs"));
+var import_node_path10 = __toESM(require("node:path"));
+
+// src/capture.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var VALUE_FIELDS = [
+  "session_id",
+  "transcript_path",
+  "cwd",
+  "hook_event_name",
+  "source",
+  "trigger",
+  "model",
+  "tool_name",
+  "permission_mode",
+  "turn_id"
+];
+var OPAQUE_FIELDS = /* @__PURE__ */ new Set(["tool_input", "tool_response", "tool_output"]);
+var ENV_VALUE_FIELDS = ["CLAUDE_PROJECT_DIR", "PLUGIN_ROOT", "CLAUDE_PLUGIN_ROOT", "PLUGIN_DATA", "CLAUDE_PLUGIN_DATA"];
+var ENV_NAME_PATTERN = /^(CLAUDE|CODEX|PLUGIN|ANTHROPIC|OPENAI)/;
+var COMPACT_ENV_PATTERN = /COMPACT/i;
+var MAX_ANCESTORS = 6;
+function shapeOf(value, depth) {
+  if (Array.isArray(value)) return value.length && depth > 0 ? [shapeOf(value[0], depth - 1)] : "array";
+  if (value === null) return "null";
+  if (typeof value !== "object") return typeof value;
+  if (depth <= 0) return "object";
+  return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, shapeOf(v, depth - 1)]));
+}
+function payloadShape(payload) {
+  return Object.fromEntries(
+    Object.entries(payload).map(([k, v]) => [k, shapeOf(v, OPAQUE_FIELDS.has(k) ? 1 : 4)])
+  );
+}
+function ancestors() {
+  const chain = [];
+  let pid = process.ppid;
+  for (let i = 0; i < MAX_ANCESTORS && pid > 1; i++) {
+    let line = "";
+    try {
+      line = (0, import_node_child_process.execFileSync)("ps", ["-o", "ppid=,args=", "-p", String(pid)], { encoding: "utf8" }).trim();
+    } catch {
+      break;
+    }
+    const [, ppid, args] = line.match(/^(\d+)\s+(.*)$/) ?? [];
+    if (!args) break;
+    const autocompact = args.match(/--autocompact[= ](\S+)/)?.[1];
+    chain.push({ pid, exe: import_node_path.default.basename(args.split(" ")[0]), ...autocompact ? { autocompact } : {} });
+    pid = Number(ppid);
+  }
+  return chain;
+}
+function captureRecord({ tool, event, payload, env }) {
+  const summary = payload.compact_summary;
+  return {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    tool,
+    event,
+    values: Object.fromEntries(VALUE_FIELDS.filter((k) => k in payload).map((k) => [k, payload[k]])),
+    shape: payloadShape(payload),
+    ...typeof summary === "string" ? { compact_summary_chars: summary.length } : {},
+    env: Object.fromEntries(
+      Object.entries(env).filter(([k]) => ENV_VALUE_FIELDS.includes(k) || COMPACT_ENV_PATTERN.test(k))
+    ),
+    env_names: Object.keys(env).filter((k) => ENV_NAME_PATTERN.test(k)).sort(),
+    ancestors: ancestors()
+  };
+}
+function canaryFile(dir, { tool, event, payload }) {
+  const source = typeof payload.source === "string" ? `-${payload.source}` : "";
+  return import_node_path.default.join(dir, `emit-${tool}-${event}${source}.txt`);
+}
+function capture(dir, ctx) {
+  import_node_fs.default.appendFileSync(import_node_path.default.join(dir, "capture.jsonl"), JSON.stringify(captureRecord(ctx)) + "\n");
+  const canary = canaryFile(dir, ctx);
+  if (!import_node_fs.default.existsSync(canary)) return void 0;
+  const text = import_node_fs.default.readFileSync(canary, "utf8").replaceAll("{session_id}", String(ctx.payload.session_id));
+  return { hookSpecificOutput: { hookEventName: ctx.event, additionalContext: text } };
+}
+function captureHandlers(dir) {
+  const handler = (ctx) => capture(dir, ctx);
+  return { PostToolUse: handler, SessionStart: handler, PostCompact: handler };
+}
+
+// src/home.ts
+var import_node_os = __toESM(require("node:os"));
+var import_node_path2 = __toESM(require("node:path"));
+
+// src/name.ts
+var NAME = "roque";
+var ENV_PREFIX = NAME.toUpperCase();
+var PROJECT_DIR = `.${NAME}`;
+var PROJECT_STATE_DIR = `${PROJECT_DIR}/state`;
+var PROJECT_OFF_FILE = `${PROJECT_DIR}/off`;
+var PROJECT_GITIGNORE_FILE = `${PROJECT_DIR}/.gitignore`;
+var HOME_DIR = `.${NAME}`;
+var HOME_LOGS_DIR = "logs";
+var HOME_SETTINGS_FLAG_FILE = "settings-applied.json";
+var HOME_PROJECTS_DIR = "projects";
+function homeCompactionsDir(projectKey, contextKey) {
+  return `${HOME_PROJECTS_DIR}/${projectKey}/contexts/${contextKey}/compactions`;
+}
+function sessionFileStem(session) {
+  return session.replace(/[^A-Za-z0-9_-]/g, "_") || "_";
+}
+var HOME_ENV = `${ENV_PREFIX}_HOME`;
+var CAPTURE_ENV = `${ENV_PREFIX}_CAPTURE`;
+
+// src/home.ts
+function claudeConfigDir(env, userHome = import_node_os.default.homedir()) {
+  return env.CLAUDE_CONFIG_DIR || import_node_path2.default.join(userHome, ".claude");
+}
+function roqueHome(env) {
+  return env[HOME_ENV] || import_node_path2.default.join(import_node_os.default.homedir(), HOME_DIR);
+}
+
+// src/hook.ts
+var TOOLS = ["claude", "codex"];
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseTool(argv) {
+  const value = argv[argv.indexOf("--tool") + 1];
+  if (!argv.includes("--tool") || !TOOLS.includes(value)) {
+    throw new Error(`expected --tool claude|codex, got ${JSON.stringify(argv)}`);
+  }
+  return value;
+}
+function parsePayload(stdin) {
+  const payload = JSON.parse(stdin);
+  if (!isPlainObject(payload)) throw new Error("hook stdin is not a JSON object");
+  return payload;
+}
+function serialise(result) {
+  if (result === void 0) return "";
+  if (!isPlainObject(result)) throw new Error(`handler result is not a JSON object: ${typeof result}`);
+  return JSON.stringify(result);
+}
+async function runHook(stdin, argv, env, handlers, onError) {
+  let tool;
+  let event;
+  try {
+    tool = parseTool(argv);
+    const payload = parsePayload(stdin);
+    event = String(payload.hook_event_name ?? "");
+    const handler = handlers[event];
+    if (!handler) return "";
+    const projectDir = env.CLAUDE_PROJECT_DIR || String(payload.cwd ?? "");
+    return serialise(await handler({ tool, event, projectDir, payload, env }));
+  } catch (error) {
+    try {
+      onError({ tool, event, error });
+    } catch {
+    }
+    return "";
+  }
+}
+
+// src/limit.ts
+var import_node_child_process3 = require("node:child_process");
+var import_node_fs4 = __toESM(require("node:fs"));
+var import_node_os2 = __toESM(require("node:os"));
+var import_node_path5 = __toESM(require("node:path"));
+
+// src/log.ts
+var import_node_fs3 = __toESM(require("node:fs"));
+var import_node_path4 = __toESM(require("node:path"));
+
+// src/scope.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_crypto = __toESM(require("node:crypto"));
+var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_path3 = __toESM(require("node:path"));
+var GIT_BUDGET_MS = 2e3;
+var FIXED_GITS = ["/usr/bin/git", "/opt/homebrew/bin/git", "/usr/local/bin/git"];
+var hashIdentity = (scope, value) => import_node_crypto.default.createHash("sha256").update(`spectre-memory/v1/${scope}\0${value}`).digest("hex");
+function cwdScope(dir, source) {
+  const projectKey = hashIdentity("cwd", dir);
+  return { projectKey, contextKey: hashIdentity("context", projectKey), source };
+}
+function gitEnv(env) {
+  const kept = Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith("GIT_")));
+  return { ...kept, GIT_CONFIG_GLOBAL: "/dev/null", GIT_CONFIG_NOSYSTEM: "1" };
+}
+function findGit(env, fixedGits) {
+  const onPath = (env.PATH ?? "").split(import_node_path3.default.delimiter).filter((dir) => import_node_path3.default.isAbsolute(dir)).map((dir) => import_node_path3.default.join(dir, "git"));
+  return [...onPath, ...fixedGits].find((file) => {
+    try {
+      return import_node_fs2.default.statSync(file).isFile();
+    } catch {
+      return false;
+    }
+  });
+}
+function runGit(git, dir, args, env, deadline) {
+  const result = (0, import_node_child_process2.spawnSync)(git, args, {
+    cwd: dir,
+    env: gitEnv(env),
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: Math.max(1, deadline - Date.now())
+  });
+  return { ok: result.status === 0, lines: (result.stdout ?? "").split("\n"), error: result.error };
+}
+function gitScope(dir, env, fixedGits) {
+  const git = findGit(env, fixedGits);
+  if (!git) return void 0;
+  const deadline = Date.now() + GIT_BUDGET_MS;
+  const first = runGit(git, dir, ["rev-parse", "--show-toplevel", "--git-common-dir", "HEAD", "--abbrev-ref=loose", "HEAD"], env, deadline);
+  if (first.error) throw first.error;
+  const [toplevel, commonDir, head, abbrev] = first.lines;
+  if (!toplevel) return void 0;
+  const projectKey = hashIdentity("project", `local:${import_node_fs2.default.realpathSync(import_node_path3.default.resolve(dir, commonDir))}`);
+  let branch;
+  if (first.ok && abbrev !== "HEAD") branch = abbrev;
+  else if (!first.ok) {
+    const ref = runGit(git, dir, ["symbolic-ref", "--quiet", "--short", "HEAD"], env, deadline);
+    if (!ref.ok) throw ref.error ?? new Error("git HEAD is unresolvable");
+    branch = ref.lines[0];
+  }
+  if (!(branch || head)) throw new Error("git HEAD is unresolvable");
+  const context = branch ? `branch:${branch}` : `detached:${head}`;
+  return { projectKey, contextKey: hashIdentity("context", `${projectKey}:${context}`), ...branch ? { branch } : {}, source: "git" };
+}
+function resolveScope(projectDir, env = process.env, fixedGits = FIXED_GITS) {
+  let dir;
+  try {
+    dir = import_node_fs2.default.realpathSync(projectDir);
+  } catch {
+    return cwdScope(import_node_path3.default.resolve(projectDir), "cwd_fallback");
+  }
+  try {
+    return gitScope(dir, env, fixedGits) ?? cwdScope(dir, "cwd");
+  } catch {
+    return cwdScope(dir, "cwd_fallback");
+  }
+}
+var memo = /* @__PURE__ */ new Map();
+function scopeOf(projectDir) {
+  let scope = memo.get(projectDir);
+  if (!scope) memo.set(projectDir, scope = resolveScope(projectDir));
+  return scope;
+}
+
+// src/log.ts
+var UNAVAILABLE = "unavailable";
+var RETRY_MS = 10;
+function logsDir(home) {
+  return import_node_path4.default.join(home, HOME_LOGS_DIR);
+}
+function logPath(home, session) {
+  return import_node_path4.default.join(logsDir(home), `${sessionFileStem(session)}.jsonl`);
+}
+function lockPath(home, session) {
+  return import_node_path4.default.join(logsDir(home), `${sessionFileStem(session)}.lock`);
+}
+function breakerPath(home, session) {
+  return import_node_path4.default.join(logsDir(home), `${sessionFileStem(session)}.break.lock`);
+}
+function scopeFields(project) {
+  if (!project) return {};
+  const { projectKey, contextKey, branch, source } = scopeOf(project);
+  return {
+    project_key: projectKey,
+    context_key: contextKey,
+    ...branch ? { branch } : {},
+    ...source === "cwd_fallback" ? { scope_source: source } : {}
+  };
+}
+function prepareScope(project) {
+  if (project) scopeOf(project);
+}
+function appendEvent(home, input, now = /* @__PURE__ */ new Date()) {
+  const event = {
+    ts: now.toISOString(),
+    event: input.event,
+    tool: input.tool,
+    session: input.session,
+    project: input.project,
+    ...scopeFields(input.project),
+    observed_tokens: input.observed_tokens ?? UNAVAILABLE,
+    params: input.params ?? {},
+    result: input.result ?? null,
+    status: input.status ?? "ok",
+    latency_ms: input.latency_ms ?? null,
+    ...input.stack === void 0 ? {} : { stack: input.stack }
+  };
+  import_node_fs3.default.mkdirSync(logsDir(home), { recursive: true });
+  import_node_fs3.default.appendFileSync(logPath(home, input.session), JSON.stringify(event) + "\n");
+  return event;
+}
+function readEvents(home, session) {
+  let text;
+  try {
+    text = import_node_fs3.default.readFileSync(logPath(home, session), "utf8");
+  } catch {
+    return [];
+  }
+  const events = [];
+  for (const line of text.split("\n")) {
+    if (!line) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed && typeof parsed === "object" && typeof parsed.event === "string") {
+        events.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return events;
+}
+function marks(home, session) {
+  const current = { nudge: false, warning: false };
+  for (const { event } of readEvents(home, session)) {
+    if (event === "handback") {
+      current.nudge = false;
+      current.warning = false;
+    } else if (event === "nudge" || event === "warning") {
+      current[event] = true;
+    }
+  }
+  return current;
+}
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function createExclusive(file, token) {
+  let fd;
+  try {
+    fd = import_node_fs3.default.openSync(file, "wx");
+  } catch (error) {
+    if (error.code === "EEXIST") return false;
+    throw error;
+  }
+  try {
+    import_node_fs3.default.writeSync(fd, token);
+  } catch (error) {
+    import_node_fs3.default.closeSync(fd);
+    import_node_fs3.default.rmSync(file, { force: true });
+    throw error;
+  }
+  import_node_fs3.default.closeSync(fd);
+  return true;
+}
+function lockIdentity(lock) {
+  let stats;
+  try {
+    stats = import_node_fs3.default.statSync(lock);
+  } catch {
+    return void 0;
+  }
+  let token;
+  try {
+    token = import_node_fs3.default.readFileSync(lock, "utf8");
+  } catch {
+    token = null;
+  }
+  return { ino: stats.ino, mtimeMs: stats.mtimeMs, token };
+}
+var sameLock = (a, b) => a.ino === b.ino && a.mtimeMs === b.mtimeMs && a.token === b.token;
+function breakIfStale(lock, breaker, staleMs, token) {
+  const seen = lockIdentity(lock);
+  if (!seen || Date.now() - seen.mtimeMs <= staleMs) return;
+  try {
+    if (!createExclusive(breaker, token)) {
+      if (Date.now() - import_node_fs3.default.statSync(breaker).mtimeMs > staleMs) import_node_fs3.default.unlinkSync(breaker);
+      return;
+    }
+  } catch {
+    return;
+  }
+  try {
+    const current = lockIdentity(lock);
+    if (current && sameLock(current, seen)) import_node_fs3.default.unlinkSync(lock);
+  } catch {
+  } finally {
+    releaseClaim(breaker, token);
+  }
+}
+function claimSession(home, session, options = {}) {
+  return claimLock(lockPath(home, session), breakerPath(home, session), options);
+}
+function claimLock(lock, breaker, options) {
+  const { timeoutMs = 2e3, staleMs = 15e3 } = options;
+  const token = `${process.pid}:${Date.now()}:${Math.random()}`;
+  const deadline = Date.now() + timeoutMs;
+  import_node_fs3.default.mkdirSync(import_node_path4.default.dirname(lock), { recursive: true });
+  for (; ; ) {
+    if (createExclusive(lock, token)) return () => releaseClaim(lock, token);
+    breakIfStale(lock, breaker, staleMs, token);
+    if (Date.now() >= deadline) return void 0;
+    sleepSync(RETRY_MS + Math.floor(Math.random() * RETRY_MS));
+  }
+}
+function releaseClaim(lock, token) {
+  try {
+    if (import_node_fs3.default.readFileSync(lock, "utf8") === token) import_node_fs3.default.unlinkSync(lock);
+  } catch {
+  }
+}
+
+// src/limit.ts
+var CLAUDE_BUFFER = 33e3;
+var CLAUDE_PCT_BASE_OFFSET = 2e4;
+var WINDOW_1M = 1e6;
+var WINDOW_DEFAULT = 2e5;
+var NATIVE_1M_MODEL = /claude-(opus|sonnet|fable)-[5-9]/;
+var CODEX_KEY = "model_auto_compact_token_limit";
+var PS_TIMEOUT_MS = 1e3;
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var PS_LINE = /^\s*\w{3}\s+(\w{3})\s+(\d{1,2})\s+(\d{2}):(\d{2}):(\d{2})\s+(\d{4})\s+(.*)$/;
+var unavailable = (source) => ({ limit: UNAVAILABLE, source });
+function parentProcessProbe(pid = process.ppid) {
+  let cached;
+  const read = () => {
+    if (cached) return cached;
+    cached = {};
+    try {
+      const line = (0, import_node_child_process3.execFileSync)("ps", ["-o", "lstart=,args=", "-p", String(pid)], {
+        encoding: "utf8",
+        env: { ...process.env, LC_ALL: "C" },
+        timeout: PS_TIMEOUT_MS,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+      const match = line.match(PS_LINE);
+      if (match) {
+        const [, month, day, hh, mm, ss, year, args] = match;
+        const started = new Date(Number(year), MONTHS.indexOf(month), Number(day), Number(hh), Number(mm), Number(ss));
+        cached = { args, startedAt: Number.isNaN(started.getTime()) ? void 0 : started };
+      }
+    } catch {
+    }
+    return cached;
+  };
+  return { args: () => read().args, startedAt: () => read().startedAt };
+}
+function tokenCount(value) {
+  if (typeof value === "number") return Number.isFinite(value) && value > 0 ? Math.round(value) : void 0;
+  if (typeof value !== "string") return void 0;
+  const match = value.trim().match(/^(\d+(?:\.\d+)?)([kKmM]?)$/);
+  if (!match) return void 0;
+  const scale = { "": 1, k: 1e3, m: 1e6 }[match[2].toLowerCase()];
+  const count = Math.round(Number(match[1]) * scale);
+  return count > 0 ? count : void 0;
+}
+var isAuto = (value) => typeof value === "string" && value.trim().toLowerCase() === "auto";
+function lastMatch(text, pattern) {
+  let found;
+  for (const match of text.matchAll(pattern)) found = match[1];
+  return found;
+}
+function hostArgs(probe, host) {
+  const args = probe.args();
+  if (!args) return void 0;
+  return args.split(/\s+/).slice(0, 2).some((token) => token.includes(host)) ? args : void 0;
+}
+function readJson(file) {
+  let text;
+  try {
+    text = import_node_fs4.default.readFileSync(file, "utf8");
+  } catch {
+    return {};
+  }
+  try {
+    const data = JSON.parse(text);
+    if (data && typeof data === "object" && !Array.isArray(data)) return { data };
+  } catch {
+  }
+  return { unreadable: true };
+}
+function claudeSettingsLayers(input) {
+  const configDir = claudeConfigDir(input.env, input.userHome);
+  const layers = [];
+  if (input.projectDir) {
+    layers.push({ layer: "local", file: import_node_path5.default.join(input.projectDir, ".claude", "settings.local.json") });
+    layers.push({ layer: "project", file: import_node_path5.default.join(input.projectDir, ".claude", "settings.json") });
+  }
+  layers.push({ layer: "user", file: import_node_path5.default.join(configDir, "settings.json") });
+  return layers;
+}
+function writtenAfterLaunch(input, userValue) {
+  const { data: flag } = readJson(import_node_path5.default.join(input.home, HOME_SETTINGS_FLAG_FILE));
+  if (flag?.wrote !== true || typeof flag.value !== "number" || userValue !== flag.value) return false;
+  const appliedAt = Date.parse(String(flag.appliedAt));
+  const started = input.probe.startedAt();
+  return !Number.isNaN(appliedAt) && started !== void 0 && started.getTime() < appliedAt;
+}
+function claudeConfiguredWindow(input, notes) {
+  const envValue = input.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW;
+  if (envValue) return { base: "env", raw: envValue };
+  const args = hostArgs(input.probe, "claude");
+  if (args === void 0) notes.push("argv_unreadable");
+  const flagValue = args && lastMatch(args, /(?:^|\s)--autocompact(?:=|\s+)(\S+)/g);
+  if (flagValue) return { base: "argv", raw: flagValue };
+  const settings = claudeSettingsLayers(input).flatMap(({ layer, file }) => {
+    const { data, unreadable } = readJson(file);
+    if (unreadable) notes.push(`unreadable_settings:${layer}`);
+    return data ? [{ layer, data }] : [];
+  });
+  for (const { layer, data } of settings) {
+    const perModel = input.model ? data.modelSettings?.[input.model]?.autoCompactWindow : void 0;
+    if (perModel !== void 0) return { base: `model_setting:${layer}`, raw: perModel };
+  }
+  for (const { layer, data } of settings) {
+    if (data.autoCompactWindow === void 0) continue;
+    if (layer === "user" && writtenAfterLaunch(input, data.autoCompactWindow)) {
+      notes.push("unapplied_setting_ignored");
+      continue;
+    }
+    return { base: `setting:${layer}`, raw: data.autoCompactWindow };
+  }
+  return void 0;
+}
+function claudeModelWindow(model) {
+  if (!model) return void 0;
+  return NATIVE_1M_MODEL.test(model) || model.includes("[1m]") ? WINDOW_1M : WINDOW_DEFAULT;
+}
+function claudeLimit(input) {
+  const notes = [];
+  const configured = claudeConfiguredWindow(input, notes);
+  const modelWindow = claudeModelWindow(input.model);
+  let window;
+  let source;
+  if (configured && isAuto(configured.raw)) {
+    if (modelWindow === void 0) return unavailable("model_unknown");
+    window = modelWindow;
+    source = `${configured.base}:auto`;
+  } else if (configured) {
+    const count = tokenCount(configured.raw);
+    if (count === void 0) return unavailable(`invalid:${configured.base}`);
+    window = count;
+    source = configured.base;
+  } else {
+    if (modelWindow === void 0) return unavailable("model_unknown");
+    window = modelWindow;
+    source = "default";
+  }
+  if (modelWindow === void 0 && window > WINDOW_DEFAULT) return unavailable("model_unknown");
+  if (modelWindow !== void 0 && window > modelWindow) {
+    window = modelWindow;
+    source += "+cap";
+  }
+  let point = window - CLAUDE_BUFFER;
+  const pct = input.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE;
+  if (pct && /^\d+(\.\d+)?$/.test(pct) && Number(pct) > 0) {
+    point = Math.min(Number(pct) / 100 * (window - CLAUDE_PCT_BASE_OFFSET), point);
+    source += "+pct";
+  }
+  point = Math.round(point);
+  if (point <= 0) return unavailable(`invalid:${source}`);
+  return { limit: point, source: [source, ...notes].join(";") };
+}
+function tomlTopLevelLimit(file) {
+  let text;
+  try {
+    text = import_node_fs4.default.readFileSync(file, "utf8");
+  } catch {
+    return void 0;
+  }
+  for (const line of text.split("\n")) {
+    if (line.trim().startsWith("[")) return void 0;
+    const match = line.match(/^\s*"?model_auto_compact_token_limit"?\s*=\s*(.*?)\s*(?:#.*)?$/);
+    if (match) return match[1];
+  }
+  return void 0;
+}
+function tomlInteger(raw) {
+  if (!/^\+?\d[\d_]*$/.test(raw)) return void 0;
+  const value = Number(raw.replace(/[+_]/g, ""));
+  return value > 0 ? value : void 0;
+}
+function codexLimit(input) {
+  if (!input.contextWindow) return unavailable("window_unknown");
+  const derived = Math.round(0.9 * Math.round(input.contextWindow / 0.95));
+  const codexHome = input.env.CODEX_HOME || import_node_path5.default.join(input.userHome ?? import_node_os2.default.homedir(), ".codex");
+  const notes = [];
+  const args = hostArgs(input.probe, "codex");
+  if (args === void 0) notes.push("argv_unreadable");
+  const cli = args && lastMatch(args, new RegExp(`(?:^|\\s)(?:-c|--config)(?:=|\\s+)${CODEX_KEY}=(\\S+)`, "g"));
+  const profile = args && lastMatch(args, /(?:^|\s)(?:-p|--profile)(?:=|\s+)([A-Za-z0-9_.-]+)(?=\s|$)/g);
+  const layers = [
+    ["cli", () => cli || void 0],
+    ["project", () => input.projectDir ? tomlTopLevelLimit(import_node_path5.default.join(input.projectDir, ".codex", "config.toml")) : void 0],
+    ["profile", () => profile && !profile.includes("..") ? tomlTopLevelLimit(import_node_path5.default.join(codexHome, `${profile}.config.toml`)) : void 0],
+    ["global", () => tomlTopLevelLimit(import_node_path5.default.join(codexHome, "config.toml"))]
+  ];
+  for (const [base, read] of layers) {
+    const raw = read();
+    if (raw === void 0) continue;
+    const configured = tomlInteger(raw);
+    if (configured === void 0) return unavailable(`invalid:${base}`);
+    const source = configured > derived ? `${base}+cap` : base;
+    return { limit: Math.min(configured, derived), source: [source, ...notes].join(";") };
+  }
+  return { limit: derived, source: ["window", ...notes].join(";") };
+}
+
+// src/meter.ts
+var import_node_fs5 = __toESM(require("node:fs"));
+var DEFAULT_CHUNK_BYTES = 64 * 1024;
+var DEFAULT_MAX_BYTES = 16 * 1024 * 1024;
+var NEWLINE = 10;
+var OPEN_BRACE = 123;
+var CLOSE_BRACE = 125;
+var SYNTHETIC_MODEL = "<synthetic>";
+var CLAUDE_MARKERS = ['"usage"', '"compact_boundary"'];
+function claudeUsageSum(line) {
+  const message = line.message;
+  if (line.type !== "assistant" || !message?.usage || message.model === SYNTHETIC_MODEL) return "none";
+  const { input_tokens, cache_creation_input_tokens = 0, cache_read_input_tokens = 0 } = message.usage;
+  const parts = [input_tokens, cache_creation_input_tokens, cache_read_input_tokens];
+  if (!parts.every((n) => typeof n === "number")) return "unknown_shape";
+  return input_tokens + cache_creation_input_tokens + cache_read_input_tokens;
+}
+function claudeScanner() {
+  let tokens;
+  let model;
+  return {
+    candidateMarkers: CLAUDE_MARKERS,
+    take(line) {
+      if (line.isSidechain === true) return true;
+      if (line.subtype === "compact_boundary") {
+        const post = line.compactMetadata?.postTokens;
+        tokens ??= typeof post === "number" ? post : 0;
+        return true;
+      }
+      const sum = claudeUsageSum(line);
+      if (sum === "none") return true;
+      if (sum === "unknown_shape") return false;
+      tokens ??= sum;
+      if (typeof line.message.model === "string") model ??= line.message.model;
+      return true;
+    },
+    done: () => tokens !== void 0 && model !== void 0,
+    result: () => tokens === void 0 ? void 0 : { tokens, ...model ? { model } : {} }
+  };
+}
+function isCodexTurnBoundary(line) {
+  const item = line.payload;
+  if (line.type !== "response_item" || !item) return false;
+  if (item.type === "agent_message") return true;
+  if (item.type !== "message" || item.role !== "user") return false;
+  const text = item.content?.find?.((part) => typeof part?.text === "string")?.text ?? "";
+  return !text.startsWith("<") && !text.startsWith("# AGENTS.md");
+}
+function codexReasoningTokens(line) {
+  const encrypted = line.payload?.encrypted_content;
+  if (typeof encrypted !== "string") return 0;
+  const bytes = Math.floor(encrypted.length * 3 / 4) - 650;
+  return bytes > 0 ? Math.ceil(bytes / 4) : 0;
+}
+function codexScanner() {
+  let tokens;
+  let contextWindow;
+  let pastBoundary = false;
+  let reasoning = 0;
+  let compacted = false;
+  return {
+    candidateMarkers: ['"token_count"', '"compacted"', '"type":"reasoning"', '"type":"agent_message"', '"role":"user"'],
+    take(line) {
+      if (line.type === "compacted") {
+        tokens ??= 0;
+        compacted = true;
+        return true;
+      }
+      if (line.type === "response_item") {
+        if (line.payload?.type === "reasoning" && pastBoundary) reasoning += codexReasoningTokens(line);
+        else if (isCodexTurnBoundary(line)) pastBoundary = true;
+        return true;
+      }
+      if (line.type !== "event_msg" || line.payload?.type !== "token_count") return true;
+      const info = line.payload.info;
+      if (info === null) return true;
+      const input = info?.last_token_usage?.input_tokens;
+      if (typeof input !== "number") return false;
+      if (typeof info.model_context_window === "number") contextWindow ??= info.model_context_window;
+      if (input > 0) tokens ??= input;
+      return true;
+    },
+    done: () => compacted && contextWindow !== void 0,
+    result: () => tokens === void 0 ? void 0 : { tokens: tokens + reasoning, ...contextWindow ? { contextWindow } : {} }
+  };
+}
+function claudePreCompactionScanner() {
+  let reading;
+  return {
+    candidateMarkers: CLAUDE_MARKERS,
+    take(line) {
+      if (line.isSidechain === true) return true;
+      if (line.subtype === "compact_boundary") {
+        const pre = line.compactMetadata?.preTokens;
+        if (typeof pre !== "number") return false;
+        reading = { tokens: pre, tokensSource: "boundary" };
+        return true;
+      }
+      const sum = claudeUsageSum(line);
+      if (sum === "none") return true;
+      if (sum === "unknown_shape") return false;
+      reading = { tokens: sum, tokensSource: "last_usage" };
+      return true;
+    },
+    done: () => reading !== void 0,
+    result: () => reading
+  };
+}
+function codexPreCompactionScanner() {
+  let compactions = 0;
+  let tokens;
+  return {
+    candidateMarkers: ['"token_count"', '"compacted"'],
+    take(line) {
+      if (line.type === "compacted") {
+        compactions++;
+        return true;
+      }
+      if (compactions === 0 || line.type !== "event_msg" || line.payload?.type !== "token_count") return true;
+      const info = line.payload.info;
+      if (info === null) return true;
+      const input = info?.last_token_usage?.input_tokens;
+      if (typeof input !== "number") return false;
+      if (input > 0) tokens = input;
+      return true;
+    },
+    done: () => tokens !== void 0 || compactions > 1,
+    result: () => tokens === void 0 ? void 0 : { tokens }
+  };
+}
+function* linesFromEnd(fd, size, chunkBytes, maxBytes) {
+  let position = size;
+  let scanned = 0;
+  let partial = [];
+  while (position > 0 && scanned < maxBytes) {
+    const length = Math.min(chunkBytes, position);
+    position -= length;
+    scanned += length;
+    const chunk = Buffer.allocUnsafe(length);
+    import_node_fs5.default.readSync(fd, chunk, 0, length, position);
+    let end = length;
+    let newline = chunk.lastIndexOf(NEWLINE, end - 1);
+    while (newline !== -1) {
+      const head = chunk.subarray(newline + 1, end);
+      const line = partial.length ? Buffer.concat([head, ...partial]) : head;
+      partial = [];
+      if (line.length) yield line;
+      end = newline;
+      newline = end > 0 ? chunk.lastIndexOf(NEWLINE, end - 1) : -1;
+    }
+    if (end > 0) partial.unshift(chunk.subarray(0, end));
+  }
+  if (position === 0 && partial.length) yield Buffer.concat(partial);
+}
+function looksLikeObject(line) {
+  return line[0] === OPEN_BRACE && line[line.length - 1] === CLOSE_BRACE;
+}
+function parseObject(line) {
+  try {
+    const parsed = JSON.parse(line.toString("utf8"));
+    return parsed && typeof parsed === "object" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseLine(line, markers) {
+  const isCandidate = markers.some((marker) => line.includes(marker));
+  if (!looksLikeObject(line)) return isCandidate ? "broken_candidate" : "garbage";
+  if (!isCandidate) return "skip";
+  return parseObject(line) ?? "broken_candidate";
+}
+function endsWithNewline(fd, size) {
+  if (size === 0) return true;
+  const last = Buffer.alloc(1);
+  import_node_fs5.default.readSync(fd, last, 0, 1, size - 1);
+  return last[0] === NEWLINE;
+}
+function scanFile(file, scanner, chunkBytes, maxBytes) {
+  let fd;
+  try {
+    fd = import_node_fs5.default.openSync(file, "r");
+  } catch {
+    return { tokens: UNAVAILABLE, reason: "unreadable" };
+  }
+  let sawUnknownShape = false;
+  try {
+    const { size } = import_node_fs5.default.fstatSync(fd);
+    let newestInProgress = !endsWithNewline(fd, size);
+    for (const line of linesFromEnd(fd, size, chunkBytes, maxBytes)) {
+      if (newestInProgress && !parseObject(line)) return { tokens: UNAVAILABLE, reason: "no_reading" };
+      newestInProgress = false;
+      const parsed = parseLine(line, scanner.candidateMarkers);
+      if (parsed === "skip") continue;
+      if (parsed === "garbage") {
+        sawUnknownShape = true;
+        continue;
+      }
+      if (parsed === "broken_candidate") {
+        sawUnknownShape = true;
+        break;
+      }
+      if (!scanner.take(parsed)) {
+        sawUnknownShape = true;
+        break;
+      }
+      if (scanner.done()) break;
+    }
+  } catch {
+    return { tokens: UNAVAILABLE, reason: "unreadable" };
+  } finally {
+    import_node_fs5.default.closeSync(fd);
+  }
+  return scanner.result() ?? { tokens: UNAVAILABLE, reason: sawUnknownShape ? "unparsed" : "no_reading" };
+}
+function scanTranscript(transcriptPath, scanner, options) {
+  if (typeof transcriptPath !== "string" || !transcriptPath) return { tokens: UNAVAILABLE, reason: "no_transcript" };
+  const { chunkBytes = DEFAULT_CHUNK_BYTES, maxBytes = DEFAULT_MAX_BYTES } = options;
+  return scanFile(transcriptPath, scanner, chunkBytes, maxBytes);
+}
+function contextTokens(transcriptPath, tool, options = {}) {
+  return scanTranscript(transcriptPath, tool === "claude" ? claudeScanner() : codexScanner(), options);
+}
+function preCompactionTokens(transcriptPath, tool, options = {}) {
+  return scanTranscript(transcriptPath, tool === "claude" ? claudePreCompactionScanner() : codexPreCompactionScanner(), options);
+}
+function recordUnparsedOnce(home, ids, reading) {
+  if (reading.reason !== "unparsed") return false;
+  const logged = () => readEvents(home, ids.session).some((e) => e.event === "meter_unparsed");
+  if (logged()) return false;
+  prepareScope(ids.project);
+  const release = claimSession(home, ids.session, { timeoutMs: 500 });
+  if (!release) return false;
+  try {
+    if (logged()) return false;
+    appendEvent(home, { event: "meter_unparsed", ...ids, status: "warn", params: { reason: reading.reason } });
+    return true;
+  } finally {
+    release();
+  }
+}
+
+// src/prune.ts
+var import_node_fs6 = __toESM(require("node:fs"));
+var import_node_path6 = __toESM(require("node:path"));
+var SUMMARY_FILE_RE = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z\.md$/;
+var DAY_MS = 864e5;
+var LOG_RETENTION_MS = 14 * DAY_MS;
+var SUMMARY_RETENTION_MS = 30 * DAY_MS;
+var LOG_FILE_RE = /\.(jsonl|lock)$/;
+var ANY = "*";
+var SUMMARY_DIR_PATTERN = homeCompactionsDir(ANY, ANY).split("/");
+function errorReason(error) {
+  return error.code ?? String(error);
+}
+function deleteOldFiles(dir, nameRe, cutoffMs, skipped2) {
+  let names;
+  try {
+    names = import_node_fs6.default.readdirSync(dir);
+  } catch (error) {
+    skipped2.push({ path: dir, reason: errorReason(error) });
+    return 0;
+  }
+  let deleted = 0;
+  for (const name of names) {
+    if (!nameRe.test(name)) continue;
+    const file = import_node_path6.default.join(dir, name);
+    try {
+      const stat = import_node_fs6.default.lstatSync(file);
+      if (!stat.isFile() || stat.mtimeMs >= cutoffMs) continue;
+      import_node_fs6.default.unlinkSync(file);
+      deleted++;
+    } catch (error) {
+      skipped2.push({ path: file, reason: errorReason(error) });
+    }
+  }
+  return deleted;
+}
+function subdirs(dir, name, skipped2) {
+  let entries;
+  try {
+    entries = import_node_fs6.default.readdirSync(dir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code !== "ENOENT") skipped2.push({ path: dir, reason: errorReason(error) });
+    return [];
+  }
+  return entries.filter((entry) => entry.isDirectory() && (name === ANY || entry.name === name)).map((entry) => import_node_path6.default.join(dir, entry.name));
+}
+function prune(home, options = {}) {
+  const nowMs = (options.now ?? /* @__PURE__ */ new Date()).getTime();
+  const skipped2 = [];
+  let logsDeleted = 0;
+  let summariesDeleted = 0;
+  try {
+    const logs = import_node_path6.default.join(home, HOME_LOGS_DIR);
+    if (import_node_fs6.default.existsSync(logs)) logsDeleted = deleteOldFiles(logs, LOG_FILE_RE, nowMs - LOG_RETENTION_MS, skipped2);
+    const summaryDirs = SUMMARY_DIR_PATTERN.reduce((dirs, name) => dirs.flatMap((dir) => subdirs(dir, name, skipped2)), [home]);
+    for (const dir of summaryDirs) summariesDeleted += deleteOldFiles(dir, SUMMARY_FILE_RE, nowMs - SUMMARY_RETENTION_MS, skipped2);
+  } catch (error) {
+    skipped2.push({ path: home, reason: errorReason(error) });
+  }
+  return { logsDeleted, summariesDeleted, skipped: skipped2 };
+}
+
+// src/report.ts
+var import_node_fs7 = __toESM(require("node:fs"));
+var import_node_path7 = __toESM(require("node:path"));
+var DEFAULT_DAYS = 14;
+var DAY_MS2 = 864e5;
+var LOG_SUFFIX = ".jsonl";
+var LOOP_EVENTS = /* @__PURE__ */ new Set(["nudge", "warning", "compaction", "handback"]);
+var EVENT_COLUMN = 16;
+var MAX_VALUE_CHARS = 120;
+var MAX_GENERIC_PARAMS = 6;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function scalar(value) {
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (typeof value === "string") return value.split("\n")[0].slice(0, MAX_VALUE_CHARS);
+  return void 0;
+}
+function timeOf(ts) {
+  const ms = typeof ts === "string" ? Date.parse(ts) : NaN;
+  return Number.isNaN(ms) ? "unknown time".padEnd(19) : new Date(ms).toISOString().slice(0, 19).replace("T", " ");
+}
+function tokensOf(event) {
+  const tokens = event.observed_tokens;
+  if (typeof tokens === "number") return `${tokens} tokens`;
+  if (!LOOP_EVENTS.has(event.event)) return void 0;
+  return tokens === UNAVAILABLE ? `tokens ${UNAVAILABLE}` : "tokens unknown";
+}
+function labelled(params, keys) {
+  return keys.flatMap((key) => {
+    const value = scalar(params[key]);
+    return value === void 0 ? [] : [`${key} ${value}`];
+  });
+}
+function errorMessage(event, params) {
+  const result = event.result;
+  return (isRecord(result) ? scalar(result.message) : void 0) ?? scalar(params.reason) ?? scalar(event.stack) ?? "no message";
+}
+function detailsOf(event) {
+  const params = isRecord(event.params) ? event.params : {};
+  switch (event.event) {
+    case "nudge":
+    case "warning": {
+      const limit = scalar(params.limit);
+      const source = scalar(params.limit_source);
+      if (limit === void 0) return [];
+      return [source === void 0 ? `limit ${limit}` : `limit ${limit} (${source})`];
+    }
+    case "state_written":
+      return [`state file changed after ${scalar(params.after) ?? "unknown step"}`, ...labelled(params, ["bytes"])];
+    case "compaction":
+      return labelled(params, ["trigger"]);
+    case "handback":
+      return labelled(params, ["chars", "bytes", "state_bytes", "truncated"]);
+    case "summary_saved":
+      return labelled(params, ["file"]);
+    case "settings_applied":
+    case "settings_skipped":
+      return labelled(params, ["reason", "prior", "value"]);
+    case "error":
+      return [errorMessage(event, params)];
+    default:
+      return labelled(params, Object.keys(params).slice(0, MAX_GENERIC_PARAMS));
+  }
+}
+function eventLine(event) {
+  const parts = [tokensOf(event), ...detailsOf(event)].filter((part) => part !== void 0);
+  return `  ${timeOf(event.ts)}  ${String(event.event).padEnd(EVENT_COLUMN)} ${parts.join(", ")}`.trimEnd();
+}
+function newCycle() {
+  return { nudge: false, warning: false, changedAfterNudge: false, changedAfterWarning: false, compacted: false };
+}
+function verdictLine(cycle, number) {
+  const parts = [];
+  if (cycle.nudge) parts.push(`after nudge: ${cycle.changedAfterNudge ? "changed" : "not changed"}`);
+  if (cycle.warning) parts.push(`after warning: ${cycle.changedAfterWarning ? "changed" : "not changed"}`);
+  if (parts.length === 0) return void 0;
+  const open = cycle.compacted ? "" : " (no compaction yet)";
+  return `  cycle ${number} state file ${parts.join("; ")}${open}`;
+}
+function trackCycle(cycle, event) {
+  if (event.event === "nudge" || event.event === "warning") cycle[event.event] = true;
+  if (event.event === "compaction") cycle.compacted = true;
+  if (event.event !== "state_written" || cycle.compacted) return;
+  const after = isRecord(event.params) ? event.params.after : void 0;
+  if (after === "nudge") cycle.changedAfterNudge = true;
+  if (after === "warning") cycle.changedAfterWarning = true;
+}
+function renderSession(log) {
+  const first = (key) => log.events.map((event) => scalar(event[key])).find(Boolean);
+  const lines = [`session ${log.id}  ${first("tool") ?? "unknown tool"}  ${first("project") ?? ""}`.trimEnd()];
+  let cycle = newCycle();
+  let cycles = 0;
+  const closeCycle = () => {
+    const verdict = verdictLine(cycle, cycles + 1);
+    if (verdict) {
+      lines.push(verdict);
+      cycles++;
+    }
+    cycle = newCycle();
+  };
+  for (const event of log.events) {
+    lines.push(eventLine(event));
+    trackCycle(cycle, event);
+    if (event.event === "handback") closeCycle();
+  }
+  closeCycle();
+  return lines;
+}
+function loadSession(home, stem) {
+  const events = readEvents(home, stem);
+  const times = events.map((event) => Date.parse(String(event.ts))).filter((ms) => !Number.isNaN(ms));
+  let newestMs = times.length > 0 ? Math.max(...times) : NaN;
+  if (Number.isNaN(newestMs)) {
+    try {
+      newestMs = import_node_fs7.default.statSync(import_node_path7.default.join(home, HOME_LOGS_DIR, stem + LOG_SUFFIX)).mtimeMs;
+    } catch {
+      newestMs = 0;
+    }
+  }
+  const id = events.map((event) => scalar(event.session)).find(Boolean) ?? stem;
+  return { id, events, newestMs };
+}
+function listSessions(home) {
+  let names;
+  try {
+    names = import_node_fs7.default.readdirSync(import_node_path7.default.join(home, HOME_LOGS_DIR));
+  } catch {
+    return [];
+  }
+  return names.filter((name) => name.endsWith(LOG_SUFFIX)).map((name) => loadSession(home, name.slice(0, -LOG_SUFFIX.length))).filter((log) => log.events.length > 0);
+}
+function renderReport(home, options = {}) {
+  const days = options.days ?? DEFAULT_DAYS;
+  const cutoffMs = (options.now ?? /* @__PURE__ */ new Date()).getTime() - days * DAY_MS2;
+  let sessions;
+  let scope;
+  if (options.session !== void 0) {
+    const log = loadSession(home, options.session);
+    sessions = log.events.length > 0 ? [log] : [];
+    scope = `session ${options.session}`;
+  } else {
+    sessions = listSessions(home).filter((log) => log.newestMs >= cutoffMs).sort((a, b) => a.newestMs - b.newestMs);
+    scope = `the last ${days} days`;
+  }
+  if (sessions.length === 0) return `${NAME} report: no sessions for ${scope}.
+`;
+  const header = `${NAME} report for ${scope} (times UTC): ${sessions.length} session${sessions.length === 1 ? "" : "s"}`;
+  return [header, ...sessions.flatMap((log) => ["", ...renderSession(log)])].join("\n") + "\n";
+}
+
+// src/settings.ts
+var import_node_fs8 = __toESM(require("node:fs"));
+var import_node_path8 = __toESM(require("node:path"));
+var AUTO_COMPACT_WINDOW = 45e4;
+var ENV_KEY = "CLAUDE_CODE_AUTO_COMPACT_WINDOW";
+var SETTINGS_KEY = "autoCompactWindow";
+var NEW_FILE_MODE = 384;
+function ensureAutoCompactWindow(options) {
+  const { home, settingsPath, env } = options;
+  try {
+    if (import_node_fs8.default.existsSync(import_node_path8.default.join(home, HOME_SETTINGS_FLAG_FILE))) return skipped("flag_present");
+    if (!import_node_fs8.default.existsSync(import_node_path8.default.dirname(settingsPath))) return skipped("no_claude_dir");
+    const baseline = lstat(settingsPath);
+    const text = readText(settingsPath);
+    const user = findUserValue(env, text);
+    if (user) {
+      writeFlag(options, { wrote: false, prior: user.prior });
+      return { event: "settings_skipped", params: { reason: "user_value", prior: user.prior } };
+    }
+    if (baseline?.isSymbolicLink()) return skipped("symlinked_settings");
+    writeFlag(options, { wrote: true, value: AUTO_COMPACT_WINDOW });
+    return replaceSettings(options, text, baseline);
+  } catch (error) {
+    return { event: "error", params: { reason: "io_error" }, error: toError(error) };
+  }
+}
+function replaceSettings(options, text, baseline) {
+  const { settingsPath } = options;
+  let data;
+  try {
+    data = text === void 0 ? {} : parseSettings(text);
+  } catch (error) {
+    return { event: "error", params: { reason: "parse_error" }, error: toError(error) };
+  }
+  const trailingNewline = text === void 0 || text.endsWith("\n") ? "\n" : "";
+  const output = JSON.stringify({ ...data, [SETTINGS_KEY]: AUTO_COMPACT_WINDOW }, null, 2) + trailingNewline;
+  const mode = baseline ? Number(baseline.mode) & 511 : NEW_FILE_MODE;
+  const tempPath = `${settingsPath}.${NAME}.tmp`;
+  import_node_fs8.default.rmSync(tempPath, { force: true });
+  import_node_fs8.default.writeFileSync(tempPath, output, { mode });
+  import_node_fs8.default.chmodSync(tempPath, mode);
+  options.beforeRename?.();
+  if (lstat(settingsPath)?.mtimeNs !== baseline?.mtimeNs) {
+    import_node_fs8.default.rmSync(tempPath, { force: true });
+    return {
+      event: "error",
+      params: { reason: "mtime_changed" },
+      error: new Error("settings.json changed during update; left untouched")
+    };
+  }
+  import_node_fs8.default.renameSync(tempPath, settingsPath);
+  return {
+    event: "settings_applied",
+    params: { reason: text === void 0 ? "file_missing" : "key_absent", value: AUTO_COMPACT_WINDOW }
+  };
+}
+function findUserValue(env, text) {
+  if (env[ENV_KEY]) return { prior: env[ENV_KEY] };
+  if (text === void 0) return void 0;
+  let data;
+  try {
+    data = parseSettings(text);
+  } catch {
+    return void 0;
+  }
+  if (Object.hasOwn(data, SETTINGS_KEY)) return { prior: data[SETTINGS_KEY] };
+  const models = data.modelSettings;
+  if (!isObject(models)) return void 0;
+  for (const model of Object.values(models)) {
+    if (isObject(model) && Object.hasOwn(model, SETTINGS_KEY)) return { prior: model[SETTINGS_KEY] };
+  }
+  return void 0;
+}
+function parseSettings(text) {
+  const data = JSON.parse(text);
+  if (!isObject(data)) throw new SyntaxError("settings.json is not a JSON object");
+  return data;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readText(filePath) {
+  try {
+    return import_node_fs8.default.readFileSync(filePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function lstat(filePath) {
+  return import_node_fs8.default.lstatSync(filePath, { bigint: true, throwIfNoEntry: false });
+}
+function writeFlag(options, fields) {
+  const flag = { ...fields, appliedAt: options.now.toISOString(), session: options.session };
+  import_node_fs8.default.mkdirSync(options.home, { recursive: true });
+  import_node_fs8.default.writeFileSync(import_node_path8.default.join(options.home, HOME_SETTINGS_FLAG_FILE), JSON.stringify(flag) + "\n");
+}
+function skipped(reason) {
+  return { event: "settings_skipped", params: { reason } };
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+// src/state.ts
+var import_node_crypto2 = __toESM(require("node:crypto"));
+var import_node_fs9 = __toESM(require("node:fs"));
+var import_node_path9 = __toESM(require("node:path"));
+var STATE_TEMPLATE = `# State (rewrite in place, never append; keep only these sections)
+
+Keep this file under 7,000 characters and 6,000 bytes. It is handed back to you word for word after compaction.
+"Told" means the user has heard this from you in plain words. Reading it in a log does not count.
+
+## Status
+- Checkpoint done:
+- Exact next step:
+- Branch / pushed:
+- Rules in force (the user's own words):
+
+## Tests
+- Baseline (count, commit): update this whenever main moves
+- Latest run:
+- Failing now (test: cause, real or environment):
+- Now passing and what fixed it:
+
+## Findings
+- (finding: current state; told the user yes/no)
+
+## U-turns
+- (from -> to: why; told the user yes/no)
+
+## Dead ends
+- (approach: why it failed; do not retry)
+`;
+function stateHash(content) {
+  return import_node_crypto2.default.createHash("sha256").update(content).digest("hex");
+}
+function isOptedOut(projectDir) {
+  return import_node_fs9.default.existsSync(import_node_path9.default.join(projectDir, PROJECT_OFF_FILE));
+}
+function mkdirIfAbsent(dir) {
+  try {
+    import_node_fs9.default.mkdirSync(dir);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+}
+function writeIfAbsent(file, content) {
+  try {
+    import_node_fs9.default.writeFileSync(file, content, { flag: "wx" });
+    return true;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    return false;
+  }
+}
+function stateFile(projectDir, session) {
+  const relPath = `${PROJECT_STATE_DIR}/${sessionFileStem(session)}.md`;
+  return { path: import_node_path9.default.join(projectDir, relPath), relPath };
+}
+function stateFingerprint(file) {
+  let stat;
+  let content;
+  try {
+    stat = import_node_fs9.default.statSync(file);
+    content = import_node_fs9.default.readFileSync(file);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  return { bytes: content.length, mtimeMs: stat.mtimeMs, hash: stateHash(content) };
+}
+function saveSummary(home, scope, summary, now) {
+  const relPath = `${homeCompactionsDir(scope.projectKey, scope.contextKey)}/${now.toISOString().replace(/[:.]/g, "-")}.md`;
+  import_node_fs9.default.mkdirSync(import_node_path9.default.dirname(import_node_path9.default.join(home, relPath)), { recursive: true });
+  import_node_fs9.default.writeFileSync(import_node_path9.default.join(home, relPath), summary, { flag: "wx" });
+  return relPath;
+}
+function ensureStateFile(projectDir, session) {
+  const { path: file, relPath } = stateFile(projectDir, session);
+  mkdirIfAbsent(import_node_path9.default.join(projectDir, PROJECT_DIR));
+  writeIfAbsent(import_node_path9.default.join(projectDir, PROJECT_GITIGNORE_FILE), "*\n");
+  mkdirIfAbsent(import_node_path9.default.join(projectDir, PROJECT_STATE_DIR));
+  const created = writeIfAbsent(file, STATE_TEMPLATE);
+  return { path: file, relPath, ...created ? { templateHash: stateHash(STATE_TEMPLATE) } : {} };
+}
+var kTokens = (n) => `${Math.round(n / 1e3)}k`;
+function meterLine({ tokens, limit }, note) {
+  return `${NAME} context meter: ${kTokens(tokens)} of ${kTokens(limit)} tokens before compaction. ${note}`;
+}
+var NUDGE_UPDATE_NOW = "Update the state file now, before your next tool call, with where you are and your exact next step. Then keep working.";
+function rewriteNow(statePath) {
+  return `Your next action is to rewrite the state file ${statePath} in full, before any other tool call: replace the whole file in one write, not an edit. Then carry on.`;
+}
+function stateRules(statePath) {
+  return [
+    `Keep the state file ${statePath} current: it is handed back to you word for word after compaction.`,
+    "- Rewrite it in place at every checkpoint: a test run, a decision, a change of plan, a finding, a dead end. Never append.",
+    "- Record each change as a change: old, new and why. Mark whether the user has been told.",
+    "- Keep its sections and keep it under 7,000 characters and 6,000 bytes.",
+    `The user can switch ${NAME} off for this project by creating ${PROJECT_OFF_FILE}.`
+  ].join("\n");
+}
+function thresholdMessage(kind, facts) {
+  switch (kind) {
+    case "nudge":
+      return [meterLine(facts, NUDGE_UPDATE_NOW), stateRules(facts.statePath)].join("\n");
+    case "warning":
+      return meterLine(facts, `Compaction is close. ${rewriteNow(facts.statePath)}`);
+    case "both":
+      return [meterLine(facts, `Compaction is close. ${rewriteNow(facts.statePath)}`), stateRules(facts.statePath)].join("\n");
+  }
+}
+var HANDBACK_BUDGET = { claude: 9500, codex: 8e3 };
+var measure = (tool, text) => tool === "claude" ? text.length : Buffer.byteLength(text, "utf8");
+function handbackRules(statePath) {
+  return [
+    `${NAME} hand-back: this is your state file ${statePath} from before compaction.`,
+    "Trust it over the compaction summary where they differ, and carry on with its next step."
+  ].join("\n");
+}
+var isHighSurrogate = (code) => code >= 55296 && code <= 56319;
+function prefixWithin(tool, content, room) {
+  if (room <= 0) return "";
+  if (tool === "claude") {
+    let end2 = Math.min(room, content.length);
+    if (end2 < content.length && isHighSurrogate(content.charCodeAt(end2 - 1))) end2--;
+    return content.slice(0, end2);
+  }
+  const bytes = Buffer.from(content, "utf8");
+  let end = Math.min(room, bytes.length);
+  while (end > 0 && end < bytes.length && (bytes[end] & 192) === 128) end--;
+  return bytes.subarray(0, end).toString("utf8");
+}
+function handbackText(tool, statePath, content) {
+  const budget = HANDBACK_BUDGET[tool];
+  const rules = handbackRules(statePath);
+  const whole = `${rules}
+
+${content}`;
+  if (measure(tool, whole) <= budget) return { text: whole, truncated: false };
+  const head = [
+    `${NAME} hand-back: your state file was truncated to fit this message.`,
+    `Read the full file ${statePath} before your next step.`,
+    rules,
+    "",
+    ""
+  ].join("\n");
+  return { text: head + prefixWithin(tool, content, budget - measure(tool, head)), truncated: true };
+}
+
+// src/main.ts
+var UNKNOWN_SESSION = "unknown";
+var NUDGE_FRACTION = 0.75;
+var WARNING_FRACTION = 0.9;
+var TRANSCRIPT_UNREADABLE = "transcript_unreadable";
+function readStdin() {
+  try {
+    return import_node_fs10.default.readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+function stringField(record, key) {
+  if (!record || typeof record !== "object") return void 0;
+  const value = record[key];
+  return typeof value === "string" && value ? value : void 0;
+}
+function payloadIds(stdin) {
+  let payload;
+  try {
+    payload = JSON.parse(stdin);
+  } catch {
+    payload = void 0;
+  }
+  return {
+    session: stringField(payload, "session_id") ?? UNKNOWN_SESSION,
+    project: process.env.CLAUDE_PROJECT_DIR || stringField(payload, "cwd") || null,
+    hookEvent: stringField(payload, "hook_event_name")
+  };
+}
+function redacted(error, safeMessage) {
+  const err = error instanceof Error ? error : new Error(String(error));
+  if (!(err instanceof SyntaxError)) return err;
+  const safe = new SyntaxError(safeMessage);
+  safe.stack = [`SyntaxError: ${safe.message}`, ...String(err.stack).split("\n").filter((l) => /^\s+at /.test(l))].join("\n");
+  return safe;
+}
+function logError(stdin) {
+  return ({ tool, event, error }) => {
+    const err = redacted(error, "hook stdin is not valid JSON");
+    const { session, project, hookEvent } = payloadIds(stdin);
+    appendEvent(roqueHome(process.env), {
+      event: "error",
+      tool: tool ?? null,
+      session,
+      project,
+      params: { hook_event: event || hookEvent || null },
+      result: { message: err.message },
+      status: "error",
+      stack: err.stack
+    });
+  };
+}
+function sessionId(payload) {
+  const id = stringField(payload, "session_id");
+  if (!id) throw new Error("hook payload has no session_id");
+  return id;
+}
+function recordUnreadableOnce(home, ids) {
+  const logged = readEvents(home, ids.session).some((e) => e.event === "error" && e.params?.reason === TRANSCRIPT_UNREADABLE);
+  if (logged) return;
+  const error = new Error("session transcript is missing or unreadable");
+  appendEvent(home, { event: "error", ...ids, params: { reason: TRANSCRIPT_UNREADABLE }, status: "error", stack: error.stack });
+}
+function recordUnavailable(home, ids, reading) {
+  if (reading.reason === "unparsed") recordUnparsedOnce(home, ids, reading);
+  else if (reading.reason === "unreadable") recordUnreadableOnce(home, ids);
+}
+var hasMeterWarning = (home, session) => readEvents(home, session).some((e) => e.event === "meter_unparsed");
+function recordLimitWarningOnce(home, ids, tokens, reason, source) {
+  if (hasMeterWarning(home, ids.session)) return;
+  prepareScope(ids.project);
+  const release = claimSession(home, ids.session, { timeoutMs: 500 });
+  if (!release) return;
+  try {
+    if (hasMeterWarning(home, ids.session)) return;
+    const params = { reason, limit_source: source };
+    appendEvent(home, { event: "meter_unparsed", ...ids, observed_tokens: tokens, status: "warn", params });
+  } finally {
+    release();
+  }
+}
+function loggedFingerprint(hash, bytes, mtimeMs) {
+  if (typeof hash !== "string") return void 0;
+  return { hash, bytes: typeof bytes === "number" ? bytes : -1, mtimeMs: typeof mtimeMs === "number" ? mtimeMs : -1 };
+}
+function stateCycle(events) {
+  let cycle = {};
+  for (const { event, params } of events) {
+    const p = params ?? {};
+    if (event === "handback") cycle = {};
+    else if (event === "nudge" || event === "warning") {
+      cycle = { after: event, baseline: loggedFingerprint(p.state_hash, p.state_bytes, p.state_mtime_ms) };
+    } else if (event === "state_written" && cycle.after) {
+      cycle.baseline = loggedFingerprint(p.hash, p.bytes, p.mtime_ms);
+    }
+  }
+  return cycle;
+}
+var sameStat = (a, b) => a.size === b.bytes && a.mtimeMs === b.mtimeMs;
+function detectStateWrite(home, ids) {
+  const file = stateFile(ids.project, ids.session).path;
+  let stat;
+  try {
+    stat = import_node_fs10.default.statSync(file);
+  } catch {
+    return;
+  }
+  const { after, baseline } = stateCycle(readEvents(home, ids.session));
+  if (!after || !baseline || sameStat(stat, baseline)) return;
+  const current = stateFingerprint(file);
+  if (!current || current.hash === baseline.hash) return;
+  prepareScope(ids.project);
+  const release = claimSession(home, ids.session, { timeoutMs: 500 });
+  if (!release) return;
+  try {
+    const cycle = stateCycle(readEvents(home, ids.session));
+    const latest = stateFingerprint(file);
+    if (!cycle.after || !latest || latest.hash === cycle.baseline?.hash) return;
+    const params = { after: cycle.after, bytes: latest.bytes, hash: latest.hash, mtime_ms: latest.mtimeMs };
+    appendEvent(home, { event: "state_written", ...ids, params });
+  } finally {
+    release();
+  }
+}
+function dueThreshold(current, warningReached) {
+  const nudge = !current.nudge;
+  const warning = warningReached && !current.warning;
+  if (nudge && warning) return "both";
+  if (warning) return "warning";
+  return nudge ? "nudge" : void 0;
+}
+var compactedSince = (home, session, sinceMs) => readEvents(home, session).some((e) => (e.event === "compaction" || e.event === "handback") && Date.parse(e.ts) >= sinceMs);
+function effectiveLimit({ tool, projectDir, env }, home, reading) {
+  const probe = parentProcessProbe();
+  return tool === "claude" ? claudeLimit({ env, model: reading.model, projectDir, home, probe }) : codexLimit({ env, contextWindow: reading.contextWindow, projectDir, probe });
+}
+function onPostToolUse(ctx) {
+  const started = Date.now();
+  const { tool, projectDir, payload, env } = ctx;
+  if (!import_node_path10.default.isAbsolute(projectDir) || isOptedOut(projectDir)) return void 0;
+  if (payload.agent_id !== void 0) return void 0;
+  const ids = { tool, session: sessionId(payload), project: projectDir };
+  const home = roqueHome(env);
+  detectStateWrite(home, ids);
+  const reading = contextTokens(payload.transcript_path, tool);
+  if (reading.tokens === UNAVAILABLE) {
+    recordUnavailable(home, ids, reading);
+    return void 0;
+  }
+  const { limit, source } = effectiveLimit(ctx, home, reading);
+  if (limit === UNAVAILABLE) {
+    recordLimitWarningOnce(home, ids, reading.tokens, "limit_unavailable", source);
+    return void 0;
+  }
+  const fraction = reading.tokens / limit;
+  if (fraction < NUDGE_FRACTION) return void 0;
+  if (source.split(";").includes("argv_unreadable")) {
+    recordLimitWarningOnce(home, ids, reading.tokens, "argv_unreadable", source);
+  }
+  const warningReached = fraction >= WARNING_FRACTION;
+  if (!dueThreshold(marks(home, ids.session), warningReached)) return void 0;
+  prepareScope(projectDir);
+  const release = claimSession(home, ids.session);
+  if (!release) throw new Error("session claim timed out; threshold message not sent");
+  try {
+    if (compactedSince(home, ids.session, started)) return void 0;
+    const kind = dueThreshold(marks(home, ids.session), warningReached);
+    if (!kind) return void 0;
+    const state = ensureStateFile(projectDir, ids.session);
+    const baseline = stateFingerprint(state.path);
+    const params = {
+      limit,
+      limit_source: source,
+      fraction: Math.round(fraction * 1e4) / 1e4,
+      state_path: state.relPath,
+      ...state.templateHash ? { template_hash: state.templateHash } : {},
+      ...baseline ? { state_hash: baseline.hash, state_bytes: baseline.bytes, state_mtime_ms: baseline.mtimeMs } : {}
+    };
+    const events = kind === "both" ? ["nudge", "warning"] : [kind];
+    for (const event of events) {
+      appendEvent(home, { event, ...ids, observed_tokens: reading.tokens, params, latency_ms: Date.now() - started });
+    }
+    const additionalContext = thresholdMessage(kind, { statePath: state.path, tokens: reading.tokens, limit });
+    return { hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext } };
+  } finally {
+    release();
+  }
+}
+var globalEventProject = (projectDir) => import_node_path10.default.isAbsolute(projectDir) && !isOptedOut(projectDir) ? projectDir : null;
+function applyClaudeSetting({ tool, projectDir, payload, env }) {
+  const started = Date.now();
+  const home = roqueHome(env);
+  const session = stringField(payload, "session_id") ?? UNKNOWN_SESSION;
+  const settingsPath = import_node_path10.default.join(claudeConfigDir(env), "settings.json");
+  const outcome = ensureAutoCompactWindow({ home, settingsPath, env, now: /* @__PURE__ */ new Date(), session });
+  if (outcome.params.reason === "flag_present") return;
+  const error = outcome.error && redacted(outcome.error, "settings.json is not valid JSON");
+  appendEvent(home, {
+    event: outcome.event,
+    tool,
+    session,
+    project: globalEventProject(projectDir),
+    params: outcome.params,
+    status: error ? "error" : "ok",
+    latency_ms: Date.now() - started,
+    ...error ? { result: { message: error.message }, stack: error.stack } : {}
+  });
+}
+function readIfPresent(file) {
+  try {
+    return import_node_fs10.default.readFileSync(file);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function logHandbackError(home, ids, reason, error) {
+  const err = error instanceof Error ? error : new Error(String(error));
+  try {
+    appendEvent(home, { event: "error", ...ids, params: { hook_event: "SessionStart", reason }, result: { message: err.message }, status: "error", stack: err.stack });
+  } catch {
+  }
+}
+function bestEffort(home, ids, reason, step) {
+  try {
+    return step();
+  } catch (error) {
+    logHandbackError(home, ids, reason, error);
+    return void 0;
+  }
+}
+function handBack({ tool, projectDir, payload, env }) {
+  const started = Date.now();
+  if (!import_node_path10.default.isAbsolute(projectDir) || isOptedOut(projectDir)) return void 0;
+  const ids = { tool, session: sessionId(payload), project: projectDir };
+  const home = roqueHome(env);
+  prepareScope(projectDir);
+  const claim = bestEffort(home, ids, "claim_failed", () => claimSession(home, ids.session) ?? "timed_out");
+  if (claim === "timed_out") logHandbackError(home, ids, "claim_timeout", new Error("session claim timed out; hand-back sent without it"));
+  const release = typeof claim === "function" ? claim : void 0;
+  try {
+    const trigger = stringField(payload, "trigger");
+    const pre = preCompactionTokens(payload.transcript_path, tool);
+    const compactionParams = {
+      ...trigger ? { trigger } : {},
+      ...pre.reason ? { tokens_reason: pre.reason } : {},
+      ...pre.tokensSource ? { tokens_source: pre.tokensSource } : {}
+    };
+    bestEffort(home, ids, "log_failed", () => appendEvent(home, { event: "compaction", ...ids, observed_tokens: pre.tokens, params: compactionParams }));
+    const state = stateFile(projectDir, ids.session);
+    const content = readIfPresent(state.path);
+    if (!content) return void 0;
+    const { text, truncated } = handbackText(tool, state.path, content.toString("utf8"));
+    const params = { truncated, chars: text.length, bytes: Buffer.byteLength(text, "utf8"), state_bytes: content.length };
+    bestEffort(home, ids, "log_failed", () => appendEvent(home, { event: "handback", ...ids, observed_tokens: pre.tokens, params, latency_ms: Date.now() - started }));
+    return { hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: text } };
+  } finally {
+    release?.();
+  }
+}
+var pruneProblems = (result) => result.skipped.filter((skip) => skip.reason !== "ENOENT");
+var MAX_LOGGED_SKIPS = 5;
+function pruneRetention({ tool, projectDir, payload, env }) {
+  try {
+    const started = Date.now();
+    const home = roqueHome(env);
+    const result = prune(home);
+    const problems = pruneProblems(result);
+    if (result.logsDeleted === 0 && result.summariesDeleted === 0 && problems.length === 0) return;
+    appendEvent(home, {
+      event: "prune",
+      tool,
+      session: stringField(payload, "session_id") ?? UNKNOWN_SESSION,
+      project: globalEventProject(projectDir),
+      params: {
+        logs_deleted: result.logsDeleted,
+        summaries_deleted: result.summariesDeleted,
+        skipped: problems.length,
+        ...problems.length > 0 ? { skipped_paths: problems.slice(0, MAX_LOGGED_SKIPS) } : {}
+      },
+      status: problems.length > 0 ? "warn" : "ok",
+      latency_ms: Date.now() - started
+    });
+  } catch {
+  }
+}
+function onSessionStart(ctx) {
+  if (ctx.tool === "claude" && ctx.payload.source === "startup") applyClaudeSetting(ctx);
+  const result = ctx.payload.source === "compact" ? handBack(ctx) : void 0;
+  pruneRetention(ctx);
+  return result;
+}
+function onPostCompact({ tool, projectDir, payload, env }) {
+  if (tool !== "claude") return void 0;
+  const started = Date.now();
+  if (!import_node_path10.default.isAbsolute(projectDir) || isOptedOut(projectDir)) return void 0;
+  const session = sessionId(payload);
+  if (!import_node_fs10.default.existsSync(stateFile(projectDir, session).path)) return void 0;
+  const summary = payload.compact_summary;
+  if (typeof summary !== "string") throw new Error("PostCompact payload has no compact_summary string");
+  const home = roqueHome(env);
+  const scope = scopeOf(projectDir);
+  const file = saveSummary(home, scope, summary, /* @__PURE__ */ new Date());
+  const params = { file, chars: summary.length };
+  const status = scope.source === "cwd_fallback" ? "warn" : "ok";
+  appendEvent(home, { event: "summary_saved", tool, session, project: projectDir, params, status, latency_ms: Date.now() - started });
+  return void 0;
+}
+var roqueHandlers = { PostToolUse: onPostToolUse, SessionStart: onSessionStart, PostCompact: onPostCompact };
+var REPORT_USAGE = `usage: ${NAME} report [--days N] [--session id]   (node dist/${NAME}.js report ...)`;
+function parseReportArgs(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i += 2) {
+    const [flag, value] = [args[i], args[i + 1]];
+    if (value === void 0) return void 0;
+    if (flag === "--days" && /^[1-9]\d*$/.test(value)) options.days = Number(value);
+    else if (flag === "--session" && value) options.session = value;
+    else return void 0;
+  }
+  return options;
+}
+function retentionNote(result) {
+  const problems = pruneProblems(result);
+  if (result.logsDeleted === 0 && result.summariesDeleted === 0 && problems.length === 0) return "";
+  const skipped2 = problems.map((skip) => `
+  skipped ${skip.path}: ${skip.reason}`).join("");
+  return `
+retention: deleted ${result.logsDeleted} old logs and ${result.summariesDeleted} old summaries${skipped2}
+`;
+}
+function runReport(args) {
+  const options = parseReportArgs(args);
+  if (!options) {
+    process.stderr.write(REPORT_USAGE + "\n");
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const home = roqueHome(process.env);
+    const pruned = prune(home);
+    process.stdout.write(renderReport(home, options) + retentionNote(pruned));
+  } catch (error) {
+    process.stderr.write(`${NAME} report failed: ${error.message}
+`);
+    process.exitCode = 1;
+  }
+}
+function selectHandlers() {
+  const captureDir = process.env[CAPTURE_ENV];
+  return captureDir ? captureHandlers(captureDir) : roqueHandlers;
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv[0] === "report") return runReport(argv.slice(1));
+  const stdin = readStdin();
+  const out = await runHook(stdin, argv, process.env, selectHandlers(), logError(stdin));
+  if (out) process.stdout.write(out);
+}
+process.exitCode = 0;
+main().catch(() => void 0);