@omnicross/daemon 0.1.8 → 0.1.10

package/dist/index.cjs

@@ -53,7 +53,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/bootstrap.ts
-var import_node_fs23 = require("fs");
+var import_node_fs26 = require("fs");
 var import_audit_types = require("@omnicross/contracts/audit-types");
 var import_billing_types = require("@omnicross/contracts/billing-types");
 var import_GeminiCodeAssistProjectResolver = require("@omnicross/core/auth/GeminiCodeAssistProjectResolver");
@@ -69,7 +69,7 @@ var import_gemini_code_assist_resolver = require("@omnicross/core/ports/gemini-c
 var import_provider_proxy4 = require("@omnicross/core/provider-proxy");
 var import_cli_launcher2 = require("@omnicross/cli-launcher");
 var import_outbound_api5 = require("@omnicross/core/outbound-api");
-var import_usage = require("@omnicross/core/usage");
+var import_usage2 = require("@omnicross/core/usage");
 var import_subscriptions4 = require("@omnicross/subscriptions");
 
 // src/admin/accountsCodexOAuth.ts
@@ -650,6 +650,37 @@ function handleAuditQuery(req, res, reader) {
   res.writeHead(200, { "Content-Type": "application/json" });
   res.end(JSON.stringify({ records }));
 }
+function handleAuditBodyQuery(req, res, reader) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const id = url.searchParams.get("id")?.trim();
+  const sessionKey = url.searchParams.get("session")?.trim();
+  if (!id || !sessionKey) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "id and session are required" }));
+    return;
+  }
+  const query2 = { id, sessionKey };
+  const ts = intParam(url.searchParams.get("ts"));
+  if (ts !== void 0) query2.ts = ts;
+  const body = reader ? reader(query2) : {};
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function handleAuditCompact(res, compact) {
+  if (!compact) {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ days: 0, shards: 0, savedBytes: 0 }));
+    return;
+  }
+  try {
+    const result = compact();
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(result));
+  } catch (error) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: error instanceof Error ? error.message : "compaction failed" }));
+  }
+}
 async function handleAuditStatsQuery(req, res, reader) {
   const url = new URL(req.url ?? "/", "http://localhost");
   const query2 = {};
@@ -1264,6 +1295,35 @@ function validateApiKeys(raw) {
   }
   return out.length > 0 ? out : void 0;
 }
+var THINK_LEVELS = /* @__PURE__ */ new Set([
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+]);
+function validateThinkingLevels(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  if (!raw.every((level) => typeof level === "string" && THINK_LEVELS.has(level))) {
+    return void 0;
+  }
+  return [...raw];
+}
+function validateThinkingTokenLimit(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const bounds = raw;
+  const min = bounds["min"];
+  const max = bounds["max"];
+  if (typeof min !== "number" || !Number.isFinite(min) || !Number.isInteger(min) || min < 0) {
+    return void 0;
+  }
+  if (typeof max !== "number" || !Number.isFinite(max) || !Number.isInteger(max) || max < min) {
+    return void 0;
+  }
+  return { min, max };
+}
 function validateModelConfigs(raw) {
   if (!Array.isArray(raw)) return void 0;
   const out = [];
@@ -1278,6 +1338,10 @@ function validateModelConfigs(raw) {
     if (typeof m["enabled"] === "boolean") entry.enabled = m["enabled"];
     if (typeof m["vision"] === "boolean") entry.vision = m["vision"];
     if (typeof m["reasoning"] === "boolean") entry.reasoning = m["reasoning"];
+    const thinkingLevels = validateThinkingLevels(m["thinkingLevels"]);
+    if (thinkingLevels) entry.thinkingLevels = thinkingLevels;
+    const thinkingTokenLimit = validateThinkingTokenLimit(m["thinkingTokenLimit"]);
+    if (thinkingTokenLimit) entry.thinkingTokenLimit = thinkingTokenLimit;
     out.push(entry);
   }
   return out.length > 0 ? out : void 0;
@@ -3585,6 +3649,7 @@ function applyAuditConfig(config) {
   } else {
     (0, import_auditSink.setAuditCaptureConfig)(null);
     (0, import_auditSink.setAuditSink)(null);
+    writer?.reset();
     if (sweeper) {
       if (config) sweeper.configure(config);
       sweeper.dispose();
@@ -3595,6 +3660,7 @@ function resetAuditRuntimeForTests() {
   (0, import_auditSink.setAuditCaptureConfig)(null);
   (0, import_auditSink.setAuditSink)(null);
   (0, import_upstreamTrace.setUpstreamTracePath)(null);
+  writer?.reset();
   if (sweeper) sweeper.dispose();
   writer = null;
   sweeper = null;
@@ -4186,6 +4252,7 @@ async function handleImport(body, deps) {
 }
 
 // src/admin/usagePricing.ts
+var import_usage = require("@omnicross/core/usage");
 var err4 = (status, message) => ({
   status,
   body: { error: { type: "admin_api_error", message } }
@@ -4211,6 +4278,9 @@ var BUCKET_SPAN_MS = {
 };
 var MAX_TIMESERIES_BUCKETS = 2e3;
 async function handleUsageGet(view, query2, deps) {
+  if (view === "throughput") {
+    return { status: 200, body: (0, import_usage.getSharedUsageThroughputTracker)().snapshot() };
+  }
   const range = parseRange(query2);
   if (!isRange(range)) return range;
   switch (view) {
@@ -5013,6 +5083,12 @@ function parseModelConfigsInput(raw, existing) {
     else if (typeof prior?.vision === "boolean") entry.vision = prior.vision;
     if (typeof m["reasoning"] === "boolean") entry.reasoning = m["reasoning"];
     else if (typeof prior?.reasoning === "boolean") entry.reasoning = prior.reasoning;
+    const thinkingLevels = validateThinkingLevels(m["thinkingLevels"]);
+    if (thinkingLevels) entry.thinkingLevels = thinkingLevels;
+    else if (prior?.thinkingLevels) entry.thinkingLevels = prior.thinkingLevels;
+    const thinkingTokenLimit = validateThinkingTokenLimit(m["thinkingTokenLimit"]);
+    if (thinkingTokenLimit) entry.thinkingTokenLimit = thinkingTokenLimit;
+    else if (prior?.thinkingTokenLimit) entry.thinkingTokenLimit = prior.thinkingTokenLimit;
     out.push(entry);
   }
   return out.length > 0 ? out : void 0;
@@ -5934,7 +6010,7 @@ async function handleUiStatic(req, res, urlPath, uiDist) {
 }
 
 // src/admin/version.ts
-var DAEMON_VERSION = true ? "0.1.8" : "0.0.0-dev";
+var DAEMON_VERSION = true ? "0.1.10" : "0.0.0-dev";
 
 // src/admin/AdminServer.ts
 var LOOPBACK_ADDR = "127.0.0.1";
@@ -6046,6 +6122,14 @@ var AdminServer = class {
       await handleAuditStatsQuery(req, res, this.deps.auditStatsReader);
       return;
     }
+    if (path2 === "/admin/api/audit/body" && (req.method === "GET" || req.method === "HEAD")) {
+      handleAuditBodyQuery(req, res, this.deps.auditBodyReader);
+      return;
+    }
+    if (path2 === "/admin/api/audit/compact" && req.method === "POST") {
+      handleAuditCompact(res, this.deps.auditCompactor);
+      return;
+    }
     if (path2 === "/admin/api/billing-status" && (req.method === "GET" || req.method === "HEAD")) {
       handleBillingStatus(res, this.deps.billingStatusReader);
       return;
@@ -6502,6 +6586,15 @@ function toLLMProvider(row) {
     api_base_url: row.baseUrl,
     api_key: resolvePreferredApiKey(row),
     models,
+    modelConfigs: row.modelConfigs?.map((config) => ({
+      id: config.id,
+      name: config.name ?? config.id,
+      enabled: config.enabled ?? true,
+      vision: config.vision,
+      reasoning: config.reasoning,
+      thinkingLevels: config.thinkingLevels,
+      thinkingTokenLimit: config.thinkingTokenLimit
+    })),
     enabled: true,
     transformer,
     // app-parity-2 child 3: POPULATE the coding-plan endpoint onto the core
@@ -8778,18 +8871,214 @@ var AccountHealthSweeper = class {
 };
 
 // src/audit/AuditPruneSweeper.ts
-var import_node_fs18 = require("fs");
-var import_node_path11 = require("path");
+var import_node_fs19 = require("fs");
+var import_node_path12 = require("path");
+var import_promises2 = require("stream/promises");
+var import_node_zlib = require("zlib");
+
+// src/audit/auditDictionary.ts
+var import_node_fs17 = require("fs");
+var import_node_path10 = require("path");
+
+// src/audit/auditBodyStore.ts
+var ANCHOR_EVERY = 64;
+var ANCHOR_DELTA_RATIO = 0.75;
+var DIVERGED_PREFIX_RATIO = 0.25;
+var MAX_BASE_CHARS = 4e6;
+var CACHE_BUDGET_CHARS = 16e6;
+var CACHE_MAX_SESSIONS = 32;
+var MAX_BASES_PER_SESSION = 4;
+var isHighSurrogate = (code) => code >= 55296 && code <= 56319;
+var isLowSurrogate = (code) => code >= 56320 && code <= 57343;
+function computeBodyDelta(prev, next) {
+  const shortest = Math.min(prev.length, next.length);
+  let pre = 0;
+  while (pre < shortest && prev.charCodeAt(pre) === next.charCodeAt(pre)) pre += 1;
+  if (pre > 0 && isHighSurrogate(prev.charCodeAt(pre - 1))) pre -= 1;
+  const maxSuf = shortest - pre;
+  let suf = 0;
+  while (suf < maxSuf && prev.charCodeAt(prev.length - 1 - suf) === next.charCodeAt(next.length - 1 - suf)) {
+    suf += 1;
+  }
+  if (suf > 0 && isLowSurrogate(prev.charCodeAt(prev.length - suf))) suf -= 1;
+  return { pre, suf, ins: next.slice(pre, next.length - suf) };
+}
+function applyBodyDelta(prev, delta) {
+  const head = delta.pre > 0 ? prev.slice(0, delta.pre) : "";
+  const tail = delta.suf > 0 ? prev.slice(prev.length - delta.suf) : "";
+  return head + delta.ins + tail;
+}
+var SessionBaseCache = class {
+  constructor(maxSessions = CACHE_MAX_SESSIONS, budgetChars = CACHE_BUDGET_CHARS, maxBaseChars = MAX_BASE_CHARS, maxHeads = MAX_BASES_PER_SESSION) {
+    this.maxSessions = maxSessions;
+    this.budgetChars = budgetChars;
+    this.maxBaseChars = maxBaseChars;
+    this.maxHeads = maxHeads;
+  }
+  maxSessions;
+  budgetChars;
+  maxBaseChars;
+  maxHeads;
+  /** Session key to its retained heads, most-recent first. */
+  entries = /* @__PURE__ */ new Map();
+  chars = 0;
+  /** Retained sessions (tests + diagnostics). */
+  get size() {
+    return this.entries.size;
+  }
+  /** A session's retained heads, most-recent first. Refreshes LRU recency. */
+  get(sessionKey) {
+    const found = this.entries.get(sessionKey);
+    if (!found) return [];
+    this.entries.delete(sessionKey);
+    this.entries.set(sessionKey, found);
+    return found;
+  }
+  /**
+   * Retain `base` as a head of `sessionKey`.
+   *
+   * `replacesId` is the head this turn CONTINUES (its body was preserved whole
+   * inside the new one), which is swapped out so a linear conversation keeps
+   * exactly one head. Omit it when the turn started a distinct stream %s that
+   * head is added alongside, which is what keeps a fork's branches apart.
+   *
+   * A body larger than `maxBaseChars` is not retained: the next turn anchors
+   * rather than letting one oversized session monopolize the budget.
+   */
+  remember(sessionKey, base, replacesId) {
+    const heads = this.entries.get(sessionKey) ?? [];
+    if (replacesId !== void 0) {
+      const at = heads.findIndex((head) => head.lastId === replacesId);
+      if (at >= 0) {
+        this.chars -= heads[at].text.length;
+        heads.splice(at, 1);
+      }
+    }
+    if (base.text.length <= this.maxBaseChars) {
+      heads.unshift(base);
+      this.chars += base.text.length;
+    }
+    while (heads.length > this.maxHeads) {
+      const dropped = heads.pop();
+      if (dropped) this.chars -= dropped.text.length;
+    }
+    this.entries.delete(sessionKey);
+    if (heads.length > 0) this.entries.set(sessionKey, heads);
+    this.evict();
+  }
+  /** Drop a session's heads (eviction, or a write failure invalidating them). */
+  forget(sessionKey) {
+    const heads = this.entries.get(sessionKey);
+    if (!heads) return;
+    for (const head of heads) this.chars -= head.text.length;
+    this.entries.delete(sessionKey);
+  }
+  /** Drop everything (writer disposal / test teardown). */
+  clear() {
+    this.entries.clear();
+    this.chars = 0;
+  }
+  /** Evict least-recently-used sessions until both bounds hold. */
+  evict() {
+    while (this.entries.size > this.maxSessions || this.chars > this.budgetChars && this.entries.size > 1) {
+      const oldest = this.entries.keys().next();
+      if (oldest.done) break;
+      this.forget(oldest.value);
+    }
+  }
+};
+function anchorReason(base, dayDir, delta, nextLength) {
+  if (!base || !delta) return "new";
+  if (base.dayDir !== dayDir) return "day";
+  if (base.chainLen >= ANCHOR_EVERY) return "chain";
+  if (delta.pre < base.text.length * DIVERGED_PREFIX_RATIO) return "diverged";
+  if (delta.ins.length > nextLength * ANCHOR_DELTA_RATIO) return "costly";
+  return null;
+}
+function pickBase(heads, next) {
+  let best = null;
+  for (const base of heads) {
+    const delta = computeBodyDelta(base.text, next);
+    if (best !== null && delta.ins.length >= best.delta.ins.length) continue;
+    best = { base, delta, continues: delta.pre + delta.suf >= base.text.length };
+  }
+  return best;
+}
+function encodeBodyEntry(record, sessionKey, dayDir, cache) {
+  const requestBody = record.requestBody;
+  const responseBody = record.responseBody;
+  if (requestBody === void 0 && responseBody === void 0) return null;
+  const entry = { id: record.id, ts: record.ts };
+  if (requestBody !== void 0) {
+    const heads = cache.get(sessionKey);
+    const sameDay = heads.filter((head) => head.dayDir === dayDir);
+    const chosen = pickBase(sameDay, requestBody);
+    const reason = heads.length > 0 && sameDay.length === 0 ? "day" : anchorReason(chosen?.base, dayDir, chosen?.delta ?? null, requestBody.length);
+    if (reason !== null) {
+      entry.req = { base: null, anchor: reason, pre: 0, suf: 0, ins: requestBody };
+      cache.remember(
+        sessionKey,
+        { dayDir, lastId: record.id, text: requestBody, chainLen: 0 },
+        chosen?.continues === true ? chosen.base.lastId : void 0
+      );
+    } else {
+      const picked = chosen;
+      entry.req = {
+        base: picked.base.lastId,
+        ...picked.continues ? { cont: true } : {},
+        pre: picked.delta.pre,
+        suf: picked.delta.suf,
+        ins: picked.delta.ins
+      };
+      cache.remember(
+        sessionKey,
+        { dayDir, lastId: record.id, text: requestBody, chainLen: picked.base.chainLen + 1 },
+        picked.continues ? picked.base.lastId : void 0
+      );
+    }
+  }
+  if (responseBody !== void 0) entry.res = responseBody;
+  return JSON.stringify(entry);
+}
+function isAuditBodyEntry(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const entry = value;
+  if (typeof entry["id"] !== "string" || typeof entry["ts"] !== "number") return false;
+  if (entry["res"] !== void 0 && typeof entry["res"] !== "string") return false;
+  const req = entry["req"];
+  if (req === void 0) return true;
+  if (!req || typeof req !== "object" || Array.isArray(req)) return false;
+  const delta = req;
+  if (delta["anchor"] !== void 0 && typeof delta["anchor"] !== "string") return false;
+  if (delta["cont"] !== void 0 && typeof delta["cont"] !== "boolean") return false;
+  return (delta["base"] === null || typeof delta["base"] === "string") && Number.isSafeInteger(delta["pre"]) && delta["pre"] >= 0 && Number.isSafeInteger(delta["suf"]) && delta["suf"] >= 0 && typeof delta["ins"] === "string";
+}
 
 // src/audit/auditFiles.ts
 var AUDIT_FILE_RE = /^audit-(\d{4})-(\d{2})-(\d{2})\.jsonl$/;
+var AUDIT_DAY_DIR_RE = /^audit-(\d{4})-(\d{2})-(\d{2})$/;
+var AUDIT_META_FILE = "meta.jsonl";
+var AUDIT_BODIES_DIR = "bodies";
+var AUDIT_SESSION_KEY_RE = /^[0-9a-f]{8,64}$/;
 var pad22 = (n) => String(n).padStart(2, "0");
-function auditFileName(ts) {
+var localDateStamp = (ts) => {
   const d = new Date(ts);
-  return `audit-${d.getFullYear()}-${pad22(d.getMonth() + 1)}-${pad22(d.getDate())}.jsonl`;
+  return `${d.getFullYear()}-${pad22(d.getMonth() + 1)}-${pad22(d.getDate())}`;
+};
+function auditDayDirName(ts) {
+  return `audit-${localDateStamp(ts)}`;
+}
+function isAuditDayDir(name) {
+  return AUDIT_DAY_DIR_RE.test(name);
+}
+function isSafeSessionKey(key) {
+  return typeof key === "string" && AUDIT_SESSION_KEY_RE.test(key);
+}
+function auditBodyFileName(sessionKey) {
+  return `${sessionKey}.jsonl`;
 }
-function auditFileDateMs(fileName) {
-  const m = AUDIT_FILE_RE.exec(fileName);
+function auditFileDateMs(name) {
+  const m = AUDIT_FILE_RE.exec(name) ?? AUDIT_DAY_DIR_RE.exec(name);
   if (!m) return null;
   const year = Number(m[1]);
   const month = Number(m[2]);
@@ -8801,9 +9090,146 @@ function auditFileDateMs(fileName) {
   return d.getTime();
 }
 
+// src/audit/auditDictionary.ts
+var AUDIT_DICT_FILE = "_dict.jsonl";
+var DICT_BASE_PREFIX = "dict:";
+var DICT_CANDIDATES = 3;
+var MIN_SAVING_RATIO = 0.2;
+function parseEntries(raw) {
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (isAuditBodyEntry(parsed)) entries.push(parsed);
+    } catch {
+    }
+  }
+  return entries;
+}
+function plainShards(bodiesPath) {
+  try {
+    return (0, import_node_fs17.readdirSync)(bodiesPath).filter(
+      (file) => file.endsWith(".jsonl") && isSafeSessionKey(file.slice(0, -".jsonl".length))
+    );
+  } catch {
+    return [];
+  }
+}
+function chooseDictionary(anchors) {
+  if (anchors.length < 2) return null;
+  const total = anchors.reduce((sum, body) => sum + body.length, 0);
+  const candidates = [...anchors].sort((a, b) => b.length - a.length).slice(0, DICT_CANDIDATES);
+  let best = null;
+  for (const candidate of candidates) {
+    let cost = candidate.length;
+    for (const body of anchors) {
+      cost += body === candidate ? 0 : computeBodyDelta(candidate, body).ins.length;
+    }
+    if (best === null || cost < best.cost) best = { body: candidate, cost };
+  }
+  if (best === null) return null;
+  return total - best.cost >= total * MIN_SAVING_RATIO ? best.body : null;
+}
+var EMPTY = { shards: 0, anchors: 0, savedBytes: 0 };
+function compactAuditDay(dayPath) {
+  const bodiesPath = (0, import_node_path10.join)(dayPath, AUDIT_BODIES_DIR);
+  if (!(0, import_node_fs17.existsSync)(bodiesPath)) return EMPTY;
+  const dictPath = (0, import_node_path10.join)(bodiesPath, AUDIT_DICT_FILE);
+  if ((0, import_node_fs17.existsSync)(dictPath) || (0, import_node_fs17.existsSync)(`${dictPath}.gz`)) return EMPTY;
+  const shardFiles = plainShards(bodiesPath);
+  if (shardFiles.length < 2) return EMPTY;
+  const loaded = /* @__PURE__ */ new Map();
+  const anchors = [];
+  for (const file of shardFiles) {
+    let entries;
+    try {
+      entries = parseEntries((0, import_node_fs17.readFileSync)((0, import_node_path10.join)(bodiesPath, file), "utf8"));
+    } catch {
+      continue;
+    }
+    loaded.set(file, entries);
+    for (const entry of entries) {
+      if (entry.req && entry.req.base === null) anchors.push(entry.req.ins);
+    }
+  }
+  if (anchors.length < 2) return EMPTY;
+  const dictionary = chooseDictionary(anchors);
+  if (dictionary === null) return EMPTY;
+  const dictEntry = {
+    id: `${DICT_BASE_PREFIX}0`,
+    ts: 0,
+    req: { base: null, anchor: "dict", pre: 0, suf: 0, ins: dictionary }
+  };
+  (0, import_node_fs17.writeFileSync)(dictPath, JSON.stringify(dictEntry) + "\n", "utf8");
+  const result = { shards: 0, anchors: 0, savedBytes: 0 };
+  for (const [file, entries] of loaded) {
+    let changed = false;
+    let saved = 0;
+    const rewritten = entries.map((entry) => {
+      if (!entry.req || entry.req.base !== null || entry.req.ins === dictionary) return entry;
+      const delta = computeBodyDelta(dictionary, entry.req.ins);
+      if (delta.ins.length >= entry.req.ins.length) return entry;
+      changed = true;
+      saved += entry.req.ins.length - delta.ins.length;
+      return {
+        ...entry,
+        req: { base: dictEntry.id, pre: delta.pre, suf: delta.suf, ins: delta.ins }
+      };
+    });
+    if (!changed) continue;
+    const target = (0, import_node_path10.join)(bodiesPath, file);
+    const temp = `${target}.compacting`;
+    try {
+      (0, import_node_fs17.writeFileSync)(temp, rewritten.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf8");
+      (0, import_node_fs17.renameSync)(temp, target);
+    } catch {
+      try {
+        if ((0, import_node_fs17.existsSync)(temp)) (0, import_node_fs17.unlinkSync)(temp);
+      } catch {
+      }
+      continue;
+    }
+    result.shards += 1;
+    result.anchors += rewritten.filter((e) => e.req?.base === dictEntry.id).length;
+    result.savedBytes += saved;
+  }
+  if (result.shards === 0) {
+    try {
+      (0, import_node_fs17.unlinkSync)(dictPath);
+    } catch {
+    }
+  }
+  return result;
+}
+function compactAllClosedAuditDays(auditDir, now = Date.now) {
+  const run = { days: 0, shards: 0, savedBytes: 0 };
+  if (!(0, import_node_fs17.existsSync)(auditDir)) return run;
+  const today = auditDayDirName(now());
+  let names;
+  try {
+    names = (0, import_node_fs17.readdirSync)(auditDir).filter(isAuditDayDir).sort();
+  } catch {
+    return run;
+  }
+  for (const name of names) {
+    if (name === today) continue;
+    try {
+      const result = compactAuditDay((0, import_node_path10.join)(auditDir, name));
+      if (result.shards === 0) continue;
+      run.days += 1;
+      run.shards += result.shards;
+      run.savedBytes += result.savedBytes;
+    } catch {
+    }
+  }
+  return run;
+}
+
 // src/audit/auditStats.ts
-var import_node_fs17 = require("fs");
-var import_node_path10 = require("path");
+var import_node_fs18 = require("fs");
+var import_node_path11 = require("path");
 var SIDECAR_VERSION = 1;
 var META_PREFIX_BYTES = 64 * 1024;
 var READ_CHUNK_BYTES = 4 * 1024 * 1024;
@@ -8811,9 +9237,9 @@ function auditStatsFileName(auditFile) {
   return auditFile.replace(/\.jsonl$/, ".stats.json");
 }
 function readPersisted(path2) {
-  if (!(0, import_node_fs17.existsSync)(path2)) return null;
+  if (!(0, import_node_fs18.existsSync)(path2)) return null;
   try {
-    const value = JSON.parse((0, import_node_fs17.readFileSync)(path2, "utf8"));
+    const value = JSON.parse((0, import_node_fs18.readFileSync)(path2, "utf8"));
     if (value.version !== SIDECAR_VERSION || !Number.isSafeInteger(value.auditBytes) || (value.auditBytes ?? -1) < 0 || !Number.isSafeInteger(value.requestCount) || (value.requestCount ?? -1) < 0 || !Number.isSafeInteger(value.errorCount) || (value.errorCount ?? -1) < 0 || (value.errorCount ?? 0) > (value.requestCount ?? -1) || typeof value.complete !== "boolean" || value.minTs !== null && !Number.isFinite(value.minTs) || value.maxTs !== null && !Number.isFinite(value.maxTs)) {
       return null;
     }
@@ -8823,7 +9249,7 @@ function readPersisted(path2) {
   }
 }
 function updateAuditStatsAfterAppend(auditPath, auditBytesBefore, auditBytesAfter, record) {
-  const statsPath = (0, import_node_path10.join)((0, import_node_path10.dirname)(auditPath), auditStatsFileName((0, import_node_path10.basename)(auditPath)));
+  const statsPath = (0, import_node_path11.join)((0, import_node_path11.dirname)(auditPath), auditStatsFileName((0, import_node_path11.basename)(auditPath)));
   const previous = auditBytesBefore === 0 ? {
     version: SIDECAR_VERSION,
     auditBytes: 0,
@@ -8843,13 +9269,13 @@ function updateAuditStatsAfterAppend(auditPath, auditBytesBefore, auditBytesAfte
     minTs: previous.minTs === null ? record.ts : Math.min(previous.minTs, record.ts),
     maxTs: previous.maxTs === null ? record.ts : Math.max(previous.maxTs, record.ts)
   };
-  (0, import_node_fs17.writeFileSync)(statsPath, JSON.stringify(next), "utf8");
+  (0, import_node_fs18.writeFileSync)(statsPath, JSON.stringify(next), "utf8");
 }
 function queryCovers(stats, from, to) {
   return stats.requestCount === 0 || stats.minTs !== null && stats.maxTs !== null && from <= stats.minTs && to >= stats.maxTs;
 }
-function fileOverlaps(file, from, to) {
-  const start = auditFileDateMs(file);
+function fileOverlaps(name, from, to) {
+  const start = auditFileDateMs(name);
   if (start === null) return false;
   const date = new Date(start);
   const end = new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1).getTime();
@@ -8901,7 +9327,7 @@ async function scanAuditFile(auditPath, startByte, auditBytes, from, to) {
     prefixTruncated = false;
   };
   if (auditBytes > startByte) {
-    const stream = (0, import_node_fs17.createReadStream)(auditPath, {
+    const stream = (0, import_node_fs18.createReadStream)(auditPath, {
       start: startByte,
       end: auditBytes - 1,
       highWaterMark: READ_CHUNK_BYTES
@@ -8954,21 +9380,27 @@ function mergePersistedStats(previous, appended) {
   };
 }
 async function readAuditStats(auditDir, query2 = {}) {
-  if (!(0, import_node_fs17.existsSync)(auditDir)) return { requestCount: 0, errorCount: 0, complete: true };
+  if (!(0, import_node_fs18.existsSync)(auditDir)) return { requestCount: 0, errorCount: 0, complete: true };
   const from = typeof query2.from === "number" ? query2.from : -Infinity;
   const to = typeof query2.to === "number" ? query2.to : Infinity;
-  let files;
+  let sources;
   try {
-    files = (0, import_node_fs17.readdirSync)(auditDir).filter((file) => AUDIT_FILE_RE.test(file) && fileOverlaps(file, from, to)).sort();
+    sources = (0, import_node_fs18.readdirSync)(auditDir).filter((name) => fileOverlaps(name, from, to)).sort().map(
+      (name) => AUDIT_DAY_DIR_RE.test(name) ? {
+        auditPath: (0, import_node_path11.join)(auditDir, name, AUDIT_META_FILE),
+        statsPath: (0, import_node_path11.join)(auditDir, name, auditStatsFileName(AUDIT_META_FILE))
+      } : {
+        auditPath: (0, import_node_path11.join)(auditDir, name),
+        statsPath: (0, import_node_path11.join)(auditDir, auditStatsFileName(name))
+      }
+    ).filter((source) => (0, import_node_fs18.existsSync)(source.auditPath));
   } catch {
     return { requestCount: 0, errorCount: 0, complete: false };
   }
   const total = { requestCount: 0, errorCount: 0, complete: true };
-  for (const file of files) {
-    const auditPath = (0, import_node_path10.join)(auditDir, file);
+  for (const { auditPath, statsPath } of sources) {
     try {
-      const auditBytes = (0, import_node_fs17.statSync)(auditPath).size;
-      const statsPath = (0, import_node_path10.join)(auditDir, auditStatsFileName(file));
+      const auditBytes = (0, import_node_fs18.statSync)(auditPath).size;
       const persisted = readPersisted(statsPath);
       if (persisted && persisted.complete && persisted.auditBytes === auditBytes && queryCovers(persisted, from, to)) {
         total.requestCount += persisted.requestCount;
@@ -8987,7 +9419,7 @@ async function readAuditStats(auditDir, query2 = {}) {
       total.errorCount += scanned.filtered.errorCount + (resumable?.errorCount ?? 0);
       total.complete = total.complete && scanned.filtered.complete;
       const current = resumable ? mergePersistedStats(resumable, scanned.all) : scanned.all;
-      if (current.complete) (0, import_node_fs17.writeFileSync)(statsPath, JSON.stringify(current), "utf8");
+      if (current.complete) (0, import_node_fs18.writeFileSync)(statsPath, JSON.stringify(current), "utf8");
     } catch {
       total.complete = false;
     }
@@ -8998,6 +9430,7 @@ async function readAuditStats(auditDir, query2 = {}) {
 // src/audit/AuditPruneSweeper.ts
 var DAY_MS = 24 * 60 * 6e4;
 var SWEEP_INTERVAL_MS2 = 60 * 6e4;
+var ARCHIVE_BATCH = 64;
 var AuditPruneSweeper = class {
   constructor(auditDir, logger, config, intervalMs = SWEEP_INTERVAL_MS2, now = Date.now) {
     this.auditDir = auditDir;
@@ -9013,6 +9446,7 @@ var AuditPruneSweeper = class {
   now;
   timer = null;
   sweeping = false;
+  archiving = false;
   /** Whether pruning is active (audit enabled). */
   get enabled() {
     return this.config.enabled;
@@ -9022,13 +9456,13 @@ var AuditPruneSweeper = class {
     this.config = config;
   }
   /**
-   * Arm the prune interval AND run one prune immediately (boot cleanup). No-op
-   * when audit is disabled (zero regression). Idempotent.
+   * Arm the interval AND run one pass immediately (boot cleanup). No-op when
+   * audit is disabled (zero regression). Idempotent.
    */
   start() {
     if (this.timer || !this.config.enabled) return;
-    void this.sweep();
-    this.timer = setInterval(() => void this.sweep(), this.intervalMs);
+    void this.runOnce();
+    this.timer = setInterval(() => void this.runOnce(), this.intervalMs);
     this.timer.unref?.();
   }
   /** Clear the interval (daemon shutdown / test teardown). Idempotent. */
@@ -9038,31 +9472,43 @@ var AuditPruneSweeper = class {
       this.timer = null;
     }
   }
+  /** Prune first, then archive — never spend CPU compressing a day about to go. */
+  async runOnce() {
+    await this.sweep();
+    await this.archive();
+  }
+  /** The LOCAL-midnight epoch ms of the current day. */
+  todayMidnight() {
+    const today = new Date(this.now());
+    return new Date(today.getFullYear(), today.getMonth(), today.getDate()).getTime();
+  }
   /**
-   * One prune: unlink every audit date file strictly OLDER than the retention
-   * cutoff (`now - retentionDays` days, at local-midnight granularity). Exposed
-   * for tests; never throws. Returns the number of files removed.
+   * One prune: remove every audit day strictly OLDER than the retention cutoff
+   * (`now - retentionDays` days, at local-midnight granularity). Exposed for
+   * tests; never throws. Returns the number of days removed.
    */
   async sweep() {
     if (!this.config.enabled || this.sweeping) return 0;
     this.sweeping = true;
     try {
-      if (!(0, import_node_fs18.existsSync)(this.auditDir)) return 0;
-      const today = new Date(this.now());
-      const todayMidnight = new Date(today.getFullYear(), today.getMonth(), today.getDate()).getTime();
-      const cutoff = todayMidnight - (this.config.retentionDays - 1) * DAY_MS;
+      if (!(0, import_node_fs19.existsSync)(this.auditDir)) return 0;
+      const cutoff = this.todayMidnight() - (this.config.retentionDays - 1) * DAY_MS;
       let removed = 0;
-      for (const file of (0, import_node_fs18.readdirSync)(this.auditDir)) {
-        const dateMs = auditFileDateMs(file);
+      for (const name of (0, import_node_fs19.readdirSync)(this.auditDir)) {
+        const dateMs = auditFileDateMs(name);
         if (dateMs === null || dateMs >= cutoff) continue;
         try {
-          (0, import_node_fs18.unlinkSync)((0, import_node_path11.join)(this.auditDir, file));
+          if (isAuditDayDir(name)) {
+            (0, import_node_fs19.rmSync)((0, import_node_path12.join)(this.auditDir, name), { recursive: true, force: true });
+          } else {
+            (0, import_node_fs19.unlinkSync)((0, import_node_path12.join)(this.auditDir, name));
+            const statsPath = (0, import_node_path12.join)(this.auditDir, auditStatsFileName(name));
+            if ((0, import_node_fs19.existsSync)(statsPath)) (0, import_node_fs19.unlinkSync)(statsPath);
+          }
           removed += 1;
-          const statsPath = (0, import_node_path11.join)(this.auditDir, auditStatsFileName(file));
-          if ((0, import_node_fs18.existsSync)(statsPath)) (0, import_node_fs18.unlinkSync)(statsPath);
         } catch (error) {
-          this.logger.warn("[AuditPruneSweeper] failed to unlink expired audit file", {
-            file,
+          this.logger.warn("[AuditPruneSweeper] failed to remove expired audit day", {
+            name,
             error: error instanceof Error ? error.message : String(error)
           });
         }
@@ -9078,59 +9524,349 @@ var AuditPruneSweeper = class {
       this.sweeping = false;
     }
   }
+  /**
+   * Gzip the body shards of every CLOSED day (anything before today). Today is
+   * deliberately left as plain text so it stays greppable while it is the day you
+   * are debugging. Exposed for tests; never throws. Returns shards compressed.
+   */
+  async archive() {
+    if (!this.config.enabled || this.archiving) return 0;
+    this.archiving = true;
+    try {
+      if (!(0, import_node_fs19.existsSync)(this.auditDir)) return 0;
+      const today = this.todayMidnight();
+      let compressed = 0;
+      for (const name of (0, import_node_fs19.readdirSync)(this.auditDir)) {
+        if (compressed >= ARCHIVE_BATCH) break;
+        const dateMs = auditFileDateMs(name);
+        if (dateMs === null || dateMs >= today || !isAuditDayDir(name)) continue;
+        const dayPath = (0, import_node_path12.join)(this.auditDir, name);
+        try {
+          const compaction = compactAuditDay(dayPath);
+          if (compaction.shards > 0) {
+            this.logger.debug("audit cross-session compaction complete", {
+              day: name,
+              shards: compaction.shards,
+              anchors: compaction.anchors,
+              savedBytes: compaction.savedBytes
+            });
+          }
+        } catch (error) {
+          this.logger.warn("[AuditPruneSweeper] cross-session compaction failed", {
+            day: name,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+        compressed += await this.archiveDay(
+          (0, import_node_path12.join)(dayPath, AUDIT_BODIES_DIR),
+          ARCHIVE_BATCH - compressed
+        );
+      }
+      if (compressed > 0) this.logger.debug("audit archive complete", { compressed });
+      return compressed;
+    } catch (error) {
+      this.logger.warn("audit archive pass failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return 0;
+    } finally {
+      this.archiving = false;
+    }
+  }
+  /** Gzip up to `budget` plain shards in one day's `bodies/` directory. */
+  async archiveDay(bodiesPath, budget) {
+    let shards;
+    try {
+      shards = (0, import_node_fs19.readdirSync)(bodiesPath).filter((file) => file.endsWith(".jsonl"));
+    } catch {
+      return 0;
+    }
+    let compressed = 0;
+    for (const shard of shards) {
+      if (compressed >= budget) break;
+      const source = (0, import_node_path12.join)(bodiesPath, shard);
+      const target = `${source}.gz`;
+      try {
+        if ((0, import_node_fs19.existsSync)(target)) {
+          (0, import_node_fs19.unlinkSync)(source);
+          continue;
+        }
+        await (0, import_promises2.pipeline)((0, import_node_fs19.createReadStream)(source), (0, import_node_zlib.createGzip)(), (0, import_node_fs19.createWriteStream)(target));
+        (0, import_node_fs19.unlinkSync)(source);
+        compressed += 1;
+      } catch (error) {
+        try {
+          if ((0, import_node_fs19.existsSync)(target)) (0, import_node_fs19.unlinkSync)(target);
+        } catch {
+        }
+        this.logger.warn("[AuditPruneSweeper] failed to archive audit body shard", {
+          shard,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return compressed;
+  }
 };
 
-// src/audit/auditReader.ts
-var import_node_fs19 = require("fs");
-var import_node_path12 = require("path");
-var DEFAULT_LIMIT = 200;
-var MAX_LIMIT = 2e3;
-function readAuditRecords(auditDir, query2 = {}) {
-  if (!(0, import_node_fs19.existsSync)(auditDir)) return [];
-  let files;
+// src/audit/auditBodyReader.ts
+var import_node_fs21 = require("fs");
+var import_node_path13 = require("path");
+var import_node_zlib2 = require("zlib");
+
+// src/audit/auditJsonl.ts
+var import_node_fs20 = require("fs");
+var WINDOW_BYTES = 1 << 20;
+var MAX_LINE_BYTES = 32 * 1024 * 1024;
+var NEWLINE = 10;
+function forEachLineFromTail(path2, onLine) {
+  let fd;
+  let end;
   try {
-    files = (0, import_node_fs19.readdirSync)(auditDir).filter((f) => AUDIT_FILE_RE.test(f));
+    end = (0, import_node_fs20.statSync)(path2).size;
+    if (end === 0) return;
+    fd = (0, import_node_fs20.openSync)(path2, "r");
+  } catch {
+    return;
+  }
+  try {
+    let carry = Buffer.alloc(0);
+    while (end > 0) {
+      const start = Math.max(0, end - WINDOW_BYTES);
+      const window = Buffer.allocUnsafe(end - start);
+      let read;
+      try {
+        read = (0, import_node_fs20.readSync)(fd, window, 0, end - start, start);
+      } catch {
+        return;
+      }
+      const chunk = carry.length > 0 ? Buffer.concat([window.subarray(0, read), carry]) : window.subarray(0, read);
+      let lineEnd = chunk.length;
+      let nl = lineEnd > 0 ? chunk.lastIndexOf(NEWLINE, lineEnd - 1) : -1;
+      while (nl >= 0) {
+        if (nl + 1 < lineEnd) {
+          const line = chunk.subarray(nl + 1, lineEnd).toString("utf8").trim();
+          if (line && onLine(line)) return;
+        }
+        lineEnd = nl;
+        nl = lineEnd > 0 ? chunk.lastIndexOf(NEWLINE, lineEnd - 1) : -1;
+      }
+      if (start === 0) {
+        if (lineEnd > 0) {
+          const line = chunk.subarray(0, lineEnd).toString("utf8").trim();
+          if (line) onLine(line);
+        }
+        return;
+      }
+      if (lineEnd > MAX_LINE_BYTES) return;
+      carry = Buffer.from(chunk.subarray(0, lineEnd));
+      end = start;
+    }
+  } finally {
+    try {
+      (0, import_node_fs20.closeSync)(fd);
+    } catch {
+    }
+  }
+}
+
+// src/audit/auditBodyReader.ts
+function candidateDays(auditDir, ts) {
+  if (typeof ts === "number" && Number.isFinite(ts)) {
+    const named = auditDayDirName(ts);
+    if ((0, import_node_fs21.existsSync)((0, import_node_path13.join)(auditDir, named))) return [named];
+  }
+  try {
+    return (0, import_node_fs21.readdirSync)(auditDir).filter(isAuditDayDir).sort().reverse();
   } catch {
     return [];
   }
-  const from = typeof query2.from === "number" ? query2.from : -Infinity;
-  const to = typeof query2.to === "number" ? query2.to : Infinity;
-  const limit = Math.min(MAX_LIMIT, Math.max(1, Math.trunc(query2.limit ?? DEFAULT_LIMIT)));
-  const matched = [];
-  for (const file of files.sort().reverse()) {
-    let raw;
+}
+function readShard(auditDir, day, sessionKey) {
+  const base = (0, import_node_path13.join)(auditDir, day, AUDIT_BODIES_DIR, auditBodyFileName(sessionKey));
+  try {
+    if ((0, import_node_fs21.existsSync)(base)) return (0, import_node_fs21.readFileSync)(base, "utf8");
+    const gz = `${base}.gz`;
+    if ((0, import_node_fs21.existsSync)(gz)) return (0, import_node_zlib2.gunzipSync)((0, import_node_fs21.readFileSync)(gz)).toString("utf8");
+  } catch {
+    return null;
+  }
+  return null;
+}
+function parseShard(raw) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let parsed;
     try {
-      raw = (0, import_node_fs19.readFileSync)((0, import_node_path12.join)(auditDir, file), "utf8");
+      parsed = JSON.parse(trimmed);
     } catch {
       continue;
     }
-    for (const line of raw.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      let rec;
+    if (isAuditBodyEntry(parsed)) entries.set(parsed.id, parsed);
+  }
+  return entries;
+}
+function withDictionary(auditDir, day, entries) {
+  let needed = false;
+  for (const entry of entries.values()) {
+    if (entry.req?.base?.startsWith(DICT_BASE_PREFIX)) {
+      needed = true;
+      break;
+    }
+  }
+  if (!needed) return entries;
+  const base = (0, import_node_path13.join)(auditDir, day, AUDIT_BODIES_DIR, AUDIT_DICT_FILE);
+  let raw = null;
+  try {
+    if ((0, import_node_fs21.existsSync)(base)) raw = (0, import_node_fs21.readFileSync)(base, "utf8");
+    else if ((0, import_node_fs21.existsSync)(`${base}.gz`)) raw = (0, import_node_zlib2.gunzipSync)((0, import_node_fs21.readFileSync)(`${base}.gz`)).toString("utf8");
+  } catch {
+    return entries;
+  }
+  if (raw === null) return entries;
+  for (const [id, entry] of parseShard(raw)) entries.set(id, entry);
+  return entries;
+}
+function reconstructRequest(entries, entry) {
+  if (!entry.req) return void 0;
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  let cursor = entry;
+  while (cursor?.req) {
+    if (visited.has(cursor.id)) return void 0;
+    visited.add(cursor.id);
+    chain.push(cursor);
+    if (cursor.req.base === null) break;
+    cursor = entries.get(cursor.req.base);
+  }
+  const anchor = chain[chain.length - 1];
+  if (!anchor?.req || anchor.req.base !== null) return void 0;
+  let text = anchor.req.ins;
+  for (let i = chain.length - 2; i >= 0; i -= 1) {
+    const delta = chain[i]?.req;
+    if (!delta) return void 0;
+    if (delta.pre > text.length || delta.suf > text.length - delta.pre) return void 0;
+    text = applyBodyDelta(text, delta);
+  }
+  return text;
+}
+function readAuditBody(auditDir, query2) {
+  if (!isSafeSessionKey(query2.sessionKey) || !query2.id) return {};
+  if (!(0, import_node_fs21.existsSync)(auditDir)) return {};
+  for (const day of candidateDays(auditDir, query2.ts)) {
+    const raw = readShard(auditDir, day, query2.sessionKey);
+    if (raw === null) continue;
+    const entries = withDictionary(auditDir, day, parseShard(raw));
+    const entry = entries.get(query2.id);
+    if (!entry) continue;
+    const result = {};
+    const requestBody = reconstructRequest(entries, entry);
+    if (requestBody !== void 0) result.requestBody = requestBody;
+    if (entry.res !== void 0) result.responseBody = entry.res;
+    return result;
+  }
+  return readLegacyInlineBody(auditDir, query2.id);
+}
+function readLegacyInlineBody(auditDir, id) {
+  let names;
+  try {
+    names = (0, import_node_fs21.readdirSync)(auditDir).filter((name) => AUDIT_FILE_RE.test(name)).sort().reverse();
+  } catch {
+    return {};
+  }
+  const needle = JSON.stringify(id);
+  let found = {};
+  for (const name of names) {
+    forEachLineFromTail((0, import_node_path13.join)(auditDir, name), (line) => {
+      if (!line.includes(needle)) return false;
+      let parsed;
       try {
-        rec = JSON.parse(trimmed);
+        parsed = JSON.parse(line);
       } catch {
-        continue;
+        return false;
       }
-      if (!isAuditRecord(rec)) continue;
-      if (query2.keyId !== void 0 && rec.keyId !== query2.keyId) continue;
-      if (rec.ts < from || rec.ts > to) continue;
-      matched.push(rec);
+      const record = parsed;
+      if (record.id !== id) return false;
+      const result = {};
+      if (typeof record.requestBody === "string") result.requestBody = record.requestBody;
+      if (typeof record.responseBody === "string") result.responseBody = record.responseBody;
+      found = result;
+      return true;
+    });
+    if (found.requestBody !== void 0 || found.responseBody !== void 0) break;
+  }
+  return found;
+}
+
+// src/audit/auditReader.ts
+var import_node_fs22 = require("fs");
+var import_node_path14 = require("path");
+var DEFAULT_LIMIT = 200;
+var MAX_LIMIT = 2e3;
+var OVERSCAN = 256;
+function daySources(auditDir) {
+  let names;
+  try {
+    names = (0, import_node_fs22.readdirSync)(auditDir);
+  } catch {
+    return [];
+  }
+  const sources = [];
+  for (const name of names) {
+    const dateMs = auditFileDateMs(name);
+    if (dateMs === null) continue;
+    if (AUDIT_DAY_DIR_RE.test(name)) {
+      const path2 = (0, import_node_path14.join)(auditDir, name, AUDIT_META_FILE);
+      if ((0, import_node_fs22.existsSync)(path2)) sources.push({ path: path2, dateMs });
+    } else if (AUDIT_FILE_RE.test(name)) {
+      sources.push({ path: (0, import_node_path14.join)(auditDir, name), dateMs });
     }
   }
-  matched.sort((a, b) => b.ts - a.ts);
-  return matched.slice(0, limit);
+  return sources.sort((a, b) => b.dateMs - a.dateMs);
 }
 function isAuditRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
   const r = value;
   return typeof r["id"] === "string" && typeof r["ts"] === "number" && typeof r["method"] === "string" && typeof r["path"] === "string" && typeof r["status"] === "number";
 }
+function toMetaRecord(record) {
+  if (record.requestBody === void 0 && record.responseBody === void 0) return record;
+  const { requestBody: _req, responseBody: _res, ...meta } = record;
+  return { ...meta, hasBody: true };
+}
+function readAuditRecords(auditDir, query2 = {}) {
+  if (!(0, import_node_fs22.existsSync)(auditDir)) return [];
+  const from = typeof query2.from === "number" ? query2.from : -Infinity;
+  const to = typeof query2.to === "number" ? query2.to : Infinity;
+  const limit = Math.min(MAX_LIMIT, Math.max(1, Math.trunc(query2.limit ?? DEFAULT_LIMIT)));
+  const matched = [];
+  for (const source of daySources(auditDir)) {
+    const before = matched.length;
+    forEachLineFromTail(source.path, (line) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        return false;
+      }
+      if (!isAuditRecord(parsed)) return false;
+      if (query2.keyId !== void 0 && parsed.keyId !== query2.keyId) return false;
+      if (query2.sessionKey !== void 0 && parsed.sessionKey !== query2.sessionKey) return false;
+      if (parsed.ts < from || parsed.ts > to) return false;
+      matched.push(toMetaRecord(parsed));
+      return matched.length - before >= limit + OVERSCAN;
+    });
+    if (matched.length >= limit) break;
+  }
+  matched.sort((a, b) => b.ts - a.ts);
+  return matched.slice(0, limit);
+}
 
 // src/audit/AuditWriter.ts
-var import_node_fs20 = require("fs");
-var import_node_path13 = require("path");
+var import_node_fs23 = require("fs");
+var import_node_path15 = require("path");
 var AuditWriter = class {
   constructor(auditDir, logger, defer = (fn) => setTimeout(fn, 0)) {
     this.auditDir = auditDir;
@@ -9140,10 +9876,13 @@ var AuditWriter = class {
   auditDir;
   logger;
   defer;
-  dirEnsured = false;
+  /** Day directories already created this process (avoids an mkdir per record). */
+  ensuredDirs = /* @__PURE__ */ new Set();
+  /** Per-session encoding bases. Memory-only; a miss simply writes a full snapshot. */
+  bases = new SessionBaseCache();
   /**
-   * Enqueue one record for append. Returns IMMEDIATELY (fire-and-forget); the fs
-   * write happens on the deferred tick. A failure is logged, never thrown.
+   * Enqueue one record. Returns IMMEDIATELY (fire-and-forget); every fs write and
+   * the delta encoding happen on the deferred tick. A failure is logged, never thrown.
    */
   record(record) {
     this.defer(() => {
@@ -9156,25 +9895,41 @@ var AuditWriter = class {
       }
     });
   }
+  /** Drop all retained encoding bases (config reload / shutdown / test teardown). */
+  reset() {
+    this.bases.clear();
+    this.ensuredDirs.clear();
+  }
   /**
-   * Append synchronously — the awaitable form tests use to assert the line landed.
-   * Ensures the `audit/` directory exists on first write (lazy, like the usage
-   * store's lazy file creation).
+   * Append synchronously — the awaitable form tests use to assert a line landed.
+   * Writes the metadata line first (canonical), then the body shard.
    */
   appendNow(record) {
-    if (!this.dirEnsured) {
-      (0, import_node_fs20.mkdirSync)(this.auditDir, { recursive: true });
-      this.dirEnsured = true;
-    }
-    const file = (0, import_node_path13.join)(this.auditDir, auditFileName(record.ts));
-    const line = JSON.stringify(record) + "\n";
-    const auditBytesBefore = (0, import_node_fs20.existsSync)(file) ? (0, import_node_fs20.statSync)(file).size : 0;
-    (0, import_node_fs20.appendFileSync)(file, line, "utf8");
+    const dayDir = auditDayDirName(record.ts);
+    const dayPath = this.ensureDir((0, import_node_path15.join)(this.auditDir, dayDir));
+    this.appendMeta(dayPath, record);
+    this.appendBody(dayPath, dayDir, record);
+  }
+  /** Create a directory once per process and remember it. */
+  ensureDir(path2) {
+    if (!this.ensuredDirs.has(path2)) {
+      (0, import_node_fs23.mkdirSync)(path2, { recursive: true });
+      this.ensuredDirs.add(path2);
+    }
+    return path2;
+  }
+  /** Write the body-free metadata line + refresh the exact-count sidecar. */
+  appendMeta(dayPath, record) {
+    const { requestBody: _req, responseBody: _res, ...meta } = record;
+    const file = (0, import_node_path15.join)(dayPath, AUDIT_META_FILE);
+    const line = JSON.stringify(meta) + "\n";
+    const bytesBefore = (0, import_node_fs23.existsSync)(file) ? (0, import_node_fs23.statSync)(file).size : 0;
+    (0, import_node_fs23.appendFileSync)(file, line, "utf8");
     try {
       updateAuditStatsAfterAppend(
         file,
-        auditBytesBefore,
-        auditBytesBefore + Buffer.byteLength(line, "utf8"),
+        bytesBefore,
+        bytesBefore + Buffer.byteLength(line, "utf8"),
         record
       );
     } catch (error) {
@@ -9183,12 +9938,39 @@ var AuditWriter = class {
       });
     }
   }
+  /**
+   * Write the delta-encoded body shard for one record. A no-op when nothing was
+   * captured or when the session key is missing/unsafe — in which case the body
+   * is dropped rather than written to an unvalidated path.
+   */
+  appendBody(dayPath, dayDir, record) {
+    if (record.requestBody === void 0 && record.responseBody === void 0) return;
+    const sessionKey = record.sessionKey;
+    if (!isSafeSessionKey(sessionKey)) {
+      this.logger.warn("[AuditWriter] dropping audit body with no usable session key", {
+        id: record.id
+      });
+      return;
+    }
+    try {
+      const line = encodeBodyEntry(record, sessionKey, dayDir, this.bases);
+      if (line === null) return;
+      const bodiesPath = this.ensureDir((0, import_node_path15.join)(dayPath, AUDIT_BODIES_DIR));
+      (0, import_node_fs23.appendFileSync)((0, import_node_path15.join)(bodiesPath, auditBodyFileName(sessionKey)), line + "\n", "utf8");
+    } catch (error) {
+      this.bases.forget(sessionKey);
+      this.logger.warn("[AuditWriter] failed to append audit body shard", {
+        id: record.id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
 };
 
 // src/billing/BillingPublisher.ts
-var import_node_fs21 = require("fs");
+var import_node_fs24 = require("fs");
 var import_node_crypto13 = require("crypto");
-var import_node_path14 = require("path");
+var import_node_path16 = require("path");
 var import_upstreamFetch6 = require("@omnicross/core/pipeline/upstreamFetch");
 
 // src/billing/billingFiles.ts
@@ -9259,8 +10041,8 @@ var BillingPublisher = class {
    */
   appendNow(event) {
     this.ensureDir();
-    const file = (0, import_node_path14.join)(this.billingDir, billingFileName(event.ts));
-    (0, import_node_fs21.appendFileSync)(file, JSON.stringify(event) + "\n", "utf8");
+    const file = (0, import_node_path16.join)(this.billingDir, billingFileName(event.ts));
+    (0, import_node_fs24.appendFileSync)(file, JSON.stringify(event) + "\n", "utf8");
   }
   /**
    * One best-effort delivery attempt for an event ALREADY in the ledger. POSTs the
@@ -9309,8 +10091,8 @@ var BillingPublisher = class {
   markDelivered(event) {
     try {
       this.ensureDir();
-      const file = (0, import_node_path14.join)(this.billingDir, deliveredFileName(event.ts));
-      (0, import_node_fs21.appendFileSync)(file, JSON.stringify({ id: event.id, deliveredAt: this.now() }) + "\n", "utf8");
+      const file = (0, import_node_path16.join)(this.billingDir, deliveredFileName(event.ts));
+      (0, import_node_fs24.appendFileSync)(file, JSON.stringify({ id: event.id, deliveredAt: this.now() }) + "\n", "utf8");
     } catch (error) {
       this.logger.warn("[BillingPublisher] failed to append delivery marker", {
         error: error instanceof Error ? error.message : String(error)
@@ -9319,20 +10101,20 @@ var BillingPublisher = class {
   }
   ensureDir() {
     if (this.dirEnsured) return;
-    (0, import_node_fs21.mkdirSync)(this.billingDir, { recursive: true });
+    (0, import_node_fs24.mkdirSync)(this.billingDir, { recursive: true });
     this.dirEnsured = true;
   }
 };
 
 // src/billing/billingReader.ts
-var import_node_fs22 = require("fs");
-var import_node_path15 = require("path");
+var import_node_fs25 = require("fs");
+var import_node_path17 = require("path");
 function readBillingLedger(billingDir) {
   const view = { events: [], deliveredIds: /* @__PURE__ */ new Set() };
-  if (!(0, import_node_fs22.existsSync)(billingDir)) return view;
+  if (!(0, import_node_fs25.existsSync)(billingDir)) return view;
   let files;
   try {
-    files = (0, import_node_fs22.readdirSync)(billingDir);
+    files = (0, import_node_fs25.readdirSync)(billingDir);
   } catch {
     return view;
   }
@@ -9363,7 +10145,7 @@ function readBillingStatus(billingDir) {
 function parseLines(dir, file) {
   let raw;
   try {
-    raw = (0, import_node_fs22.readFileSync)((0, import_node_path15.join)(dir, file), "utf8");
+    raw = (0, import_node_fs25.readFileSync)((0, import_node_path17.join)(dir, file), "utf8");
   } catch {
     return [];
   }
@@ -9849,7 +10631,7 @@ function buildDaemon(config, paths) {
     }
   );
   const pricingStore = new JsonPricingStore(defaultPricingPath(paths.configPath));
-  const pricingEngine = new import_usage.PricingEngine(pricingStore, logger, {
+  const pricingEngine = new import_usage2.PricingEngine(pricingStore, logger, {
     // Catalog egress follows the same global/env proxy policy as every other
     // daemon upstream call; no provider/account override applies here.
     fetchImpl: ((input, init) => (0, import_upstreamFetch8.fetchUpstream)(String(input), init ?? {}))
@@ -9865,8 +10647,10 @@ function buildDaemon(config, paths) {
     async (providerId, model) => await pricingEngine.getEntry(providerId, model) !== null
   );
   const keySpendTracker = new import_outbound_api5.KeySpendTracker(usageEventStore);
-  const usageRecorder = new import_usage.UsageRecorder(usageEventStore, pricingEngine, logger, {
-    onRecord: (apiKeyId, costUsd, at) => keySpendTracker.add(apiKeyId, costUsd, at)
+  const usageThroughput = (0, import_usage2.getSharedUsageThroughputTracker)();
+  const usageRecorder = new import_usage2.UsageRecorder(usageEventStore, pricingEngine, logger, {
+    onRecord: (apiKeyId, costUsd, at) => keySpendTracker.add(apiKeyId, costUsd, at),
+    onEvent: (row, at) => usageThroughput.record(row, at)
   });
   const providerProxy = (0, import_provider_proxy4.getProviderProxy)({ llmConfig, apiKeyPool, usageRecorder });
   const routeLeaseManager = new import_provider_proxy4.RouteLeaseManager(
@@ -10015,6 +10799,11 @@ function buildDaemon(config, paths) {
     // NEVER unauth, NEVER on `/health`. Routed in `AdminServer` (not `adminApi.ts`).
     auditReader: (query2) => readAuditRecords(auditDir, query2),
     auditStatsReader: (query2) => readAuditStats(auditDir, query2),
+    // audit-store-sharding: bodies live in per-session shards, so opening ONE
+    // record's payload is a separate authed call that replays its delta chain.
+    auditBodyReader: (query2) => readAuditBody(auditDir, query2),
+    // audit-store-sharding D8: the manual counterpart to the daily pass.
+    auditCompactor: () => compactAllClosedAuditDays(auditDir),
     // billing-event-stream: the AUTHED `GET /admin/api/billing-status` returns the
     // secret-free total/delivered/pending counts of the durable ledger.
     billingStatusReader: () => readBillingStatus(billingDir)
@@ -10088,11 +10877,12 @@ function resetDaemonSingletonsForTests() {
   (0, import_SubscriptionIdentityStore3.__resetSharedIdentityStoreForTests)();
   (0, import_AccountAllowanceStore4.__resetSharedAccountAllowanceStoreForTests)();
   (0, import_AccountAllowanceScheduling5.__resetSharedAccountAllowanceSchedulingForTests)();
+  (0, import_usage2.__resetSharedUsageThroughputTrackerForTests)();
 }
 function isTokensStoreReadable(tokensPath) {
   try {
-    if (!(0, import_node_fs23.existsSync)(tokensPath)) return true;
-    (0, import_node_fs23.accessSync)(tokensPath, import_node_fs23.constants.R_OK);
+    if (!(0, import_node_fs26.existsSync)(tokensPath)) return true;
+    (0, import_node_fs26.accessSync)(tokensPath, import_node_fs26.constants.R_OK);
     return true;
   } catch {
     return false;