@omnicross/daemon 0.1.9 → 0.1.10

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/bootstrap.ts
-import { accessSync, constants as fsConstants, existsSync as existsSync19 } from "fs";
+import { accessSync, constants as fsConstants, existsSync as existsSync21 } from "fs";
 import { DEFAULT_AUDIT_CONFIG } from "@omnicross/contracts/audit-types";
 import { DEFAULT_BILLING_CONFIG } from "@omnicross/contracts/billing-types";
 import { getGeminiCodeAssistProjectResolver } from "@omnicross/core/auth/GeminiCodeAssistProjectResolver";
@@ -33,7 +33,12 @@ import {
 } from "@omnicross/core/provider-proxy";
 import { routeLeaseDescriptorPort } from "@omnicross/cli-launcher";
 import { KeySpendTracker } from "@omnicross/core/outbound-api";
-import { PricingEngine, UsageRecorder } from "@omnicross/core/usage";
+import {
+  __resetSharedUsageThroughputTrackerForTests,
+  getSharedUsageThroughputTracker as getSharedUsageThroughputTracker2,
+  PricingEngine,
+  UsageRecorder
+} from "@omnicross/core/usage";
 import {
   setSubscriptionAccountService,
   setSubscriptionProviderRegistry,
@@ -637,6 +642,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 = {};
@@ -3646,6 +3682,7 @@ function applyAuditConfig(config) {
   } else {
     setAuditCaptureConfig(null);
     setAuditSink(null);
+    writer?.reset();
     if (sweeper) {
       if (config) sweeper.configure(config);
       sweeper.dispose();
@@ -3656,6 +3693,7 @@ function resetAuditRuntimeForTests() {
   setAuditCaptureConfig(null);
   setAuditSink(null);
   setUpstreamTracePath(null);
+  writer?.reset();
   if (sweeper) sweeper.dispose();
   writer = null;
   sweeper = null;
@@ -4247,6 +4285,7 @@ async function handleImport(body, deps) {
 }
 
 // src/admin/usagePricing.ts
+import { getSharedUsageThroughputTracker } from "@omnicross/core/usage";
 var err4 = (status, message) => ({
   status,
   body: { error: { type: "admin_api_error", message } }
@@ -4272,6 +4311,9 @@ var BUCKET_SPAN_MS = {
 };
 var MAX_TIMESERIES_BUCKETS = 2e3;
 async function handleUsageGet(view, query2, deps) {
+  if (view === "throughput") {
+    return { status: 200, body: getSharedUsageThroughputTracker().snapshot() };
+  }
   const range = parseRange(query2);
   if (!isRange(range)) return range;
   switch (view) {
@@ -6003,7 +6045,7 @@ async function handleUiStatic(req, res, urlPath, uiDist) {
 }
 
 // src/admin/version.ts
-var DAEMON_VERSION = true ? "0.1.9" : "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";
@@ -6115,6 +6157,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;
@@ -8866,18 +8916,214 @@ var AccountHealthSweeper = class {
 };
 
 // src/audit/AuditPruneSweeper.ts
-import { existsSync as existsSync15, readdirSync as readdirSync2, unlinkSync as unlinkSync3 } from "fs";
-import { join as join7 } from "path";
+import { createReadStream as createReadStream2, createWriteStream as createWriteStream2, existsSync as existsSync16, readdirSync as readdirSync3, rmSync as rmSync4, unlinkSync as unlinkSync4 } from "fs";
+import { join as join8 } from "path";
+import { pipeline } from "stream/promises";
+import { createGzip } from "zlib";
+
+// src/audit/auditDictionary.ts
+import { existsSync as existsSync14, readdirSync, readFileSync as readFileSync14, renameSync as renameSync5, unlinkSync as unlinkSync3, writeFileSync as writeFileSync12 } from "fs";
+import { join as join6 } from "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 auditFileDateMs(fileName) {
-  const m = AUDIT_FILE_RE.exec(fileName);
+function auditBodyFileName(sessionKey) {
+  return `${sessionKey}.jsonl`;
+}
+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]);
@@ -8889,16 +9135,153 @@ 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 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 = join6(dayPath, AUDIT_BODIES_DIR);
+  if (!existsSync14(bodiesPath)) return EMPTY;
+  const dictPath = join6(bodiesPath, AUDIT_DICT_FILE);
+  if (existsSync14(dictPath) || existsSync14(`${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(readFileSync14(join6(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 }
+  };
+  writeFileSync12(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 = join6(bodiesPath, file);
+    const temp = `${target}.compacting`;
+    try {
+      writeFileSync12(temp, rewritten.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf8");
+      renameSync5(temp, target);
+    } catch {
+      try {
+        if (existsSync14(temp)) unlinkSync3(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 {
+      unlinkSync3(dictPath);
+    } catch {
+    }
+  }
+  return result;
+}
+function compactAllClosedAuditDays(auditDir, now = Date.now) {
+  const run = { days: 0, shards: 0, savedBytes: 0 };
+  if (!existsSync14(auditDir)) return run;
+  const today = auditDayDirName(now());
+  let names;
+  try {
+    names = readdirSync(auditDir).filter(isAuditDayDir).sort();
+  } catch {
+    return run;
+  }
+  for (const name of names) {
+    if (name === today) continue;
+    try {
+      const result = compactAuditDay(join6(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
 import {
   createReadStream,
-  existsSync as existsSync14,
-  readFileSync as readFileSync14,
-  readdirSync,
+  existsSync as existsSync15,
+  readFileSync as readFileSync15,
+  readdirSync as readdirSync2,
   statSync as statSync3,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync13
 } from "fs";
-import { basename, dirname as dirname7, join as join6 } from "path";
+import { basename, dirname as dirname7, join as join7 } from "path";
 var SIDECAR_VERSION = 1;
 var META_PREFIX_BYTES = 64 * 1024;
 var READ_CHUNK_BYTES = 4 * 1024 * 1024;
@@ -8906,9 +9289,9 @@ function auditStatsFileName(auditFile) {
   return auditFile.replace(/\.jsonl$/, ".stats.json");
 }
 function readPersisted(path2) {
-  if (!existsSync14(path2)) return null;
+  if (!existsSync15(path2)) return null;
   try {
-    const value = JSON.parse(readFileSync14(path2, "utf8"));
+    const value = JSON.parse(readFileSync15(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;
     }
@@ -8918,7 +9301,7 @@ function readPersisted(path2) {
   }
 }
 function updateAuditStatsAfterAppend(auditPath, auditBytesBefore, auditBytesAfter, record) {
-  const statsPath = join6(dirname7(auditPath), auditStatsFileName(basename(auditPath)));
+  const statsPath = join7(dirname7(auditPath), auditStatsFileName(basename(auditPath)));
   const previous = auditBytesBefore === 0 ? {
     version: SIDECAR_VERSION,
     auditBytes: 0,
@@ -8938,13 +9321,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)
   };
-  writeFileSync12(statsPath, JSON.stringify(next), "utf8");
+  writeFileSync13(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();
@@ -9049,21 +9432,27 @@ function mergePersistedStats(previous, appended) {
   };
 }
 async function readAuditStats(auditDir, query2 = {}) {
-  if (!existsSync14(auditDir)) return { requestCount: 0, errorCount: 0, complete: true };
+  if (!existsSync15(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 = readdirSync(auditDir).filter((file) => AUDIT_FILE_RE.test(file) && fileOverlaps(file, from, to)).sort();
+    sources = readdirSync2(auditDir).filter((name) => fileOverlaps(name, from, to)).sort().map(
+      (name) => AUDIT_DAY_DIR_RE.test(name) ? {
+        auditPath: join7(auditDir, name, AUDIT_META_FILE),
+        statsPath: join7(auditDir, name, auditStatsFileName(AUDIT_META_FILE))
+      } : {
+        auditPath: join7(auditDir, name),
+        statsPath: join7(auditDir, auditStatsFileName(name))
+      }
+    ).filter((source) => existsSync15(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 = join6(auditDir, file);
+  for (const { auditPath, statsPath } of sources) {
     try {
       const auditBytes = statSync3(auditPath).size;
-      const statsPath = join6(auditDir, auditStatsFileName(file));
       const persisted = readPersisted(statsPath);
       if (persisted && persisted.complete && persisted.auditBytes === auditBytes && queryCovers(persisted, from, to)) {
         total.requestCount += persisted.requestCount;
@@ -9082,7 +9471,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) writeFileSync12(statsPath, JSON.stringify(current), "utf8");
+      if (current.complete) writeFileSync13(statsPath, JSON.stringify(current), "utf8");
     } catch {
       total.complete = false;
     }
@@ -9093,6 +9482,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;
@@ -9108,6 +9498,7 @@ var AuditPruneSweeper = class {
   now;
   timer = null;
   sweeping = false;
+  archiving = false;
   /** Whether pruning is active (audit enabled). */
   get enabled() {
     return this.config.enabled;
@@ -9117,13 +9508,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. */
@@ -9133,31 +9524,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 (!existsSync15(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 (!existsSync16(this.auditDir)) return 0;
+      const cutoff = this.todayMidnight() - (this.config.retentionDays - 1) * DAY_MS;
       let removed = 0;
-      for (const file of readdirSync2(this.auditDir)) {
-        const dateMs = auditFileDateMs(file);
+      for (const name of readdirSync3(this.auditDir)) {
+        const dateMs = auditFileDateMs(name);
         if (dateMs === null || dateMs >= cutoff) continue;
         try {
-          unlinkSync3(join7(this.auditDir, file));
+          if (isAuditDayDir(name)) {
+            rmSync4(join8(this.auditDir, name), { recursive: true, force: true });
+          } else {
+            unlinkSync4(join8(this.auditDir, name));
+            const statsPath = join8(this.auditDir, auditStatsFileName(name));
+            if (existsSync16(statsPath)) unlinkSync4(statsPath);
+          }
           removed += 1;
-          const statsPath = join7(this.auditDir, auditStatsFileName(file));
-          if (existsSync15(statsPath)) unlinkSync3(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)
           });
         }
@@ -9173,59 +9576,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 (!existsSync16(this.auditDir)) return 0;
+      const today = this.todayMidnight();
+      let compressed = 0;
+      for (const name of readdirSync3(this.auditDir)) {
+        if (compressed >= ARCHIVE_BATCH) break;
+        const dateMs = auditFileDateMs(name);
+        if (dateMs === null || dateMs >= today || !isAuditDayDir(name)) continue;
+        const dayPath = join8(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(
+          join8(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 = readdirSync3(bodiesPath).filter((file) => file.endsWith(".jsonl"));
+    } catch {
+      return 0;
+    }
+    let compressed = 0;
+    for (const shard of shards) {
+      if (compressed >= budget) break;
+      const source = join8(bodiesPath, shard);
+      const target = `${source}.gz`;
+      try {
+        if (existsSync16(target)) {
+          unlinkSync4(source);
+          continue;
+        }
+        await pipeline(createReadStream2(source), createGzip(), createWriteStream2(target));
+        unlinkSync4(source);
+        compressed += 1;
+      } catch (error) {
+        try {
+          if (existsSync16(target)) unlinkSync4(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
-import { existsSync as existsSync16, readdirSync as readdirSync3, readFileSync as readFileSync15 } from "fs";
-import { join as join8 } from "path";
-var DEFAULT_LIMIT = 200;
-var MAX_LIMIT = 2e3;
-function readAuditRecords(auditDir, query2 = {}) {
-  if (!existsSync16(auditDir)) return [];
-  let files;
+// src/audit/auditBodyReader.ts
+import { existsSync as existsSync17, readdirSync as readdirSync4, readFileSync as readFileSync16, statSync as statSync5 } from "fs";
+import { join as join9 } from "path";
+import { gunzipSync } from "zlib";
+
+// src/audit/auditJsonl.ts
+import { closeSync, openSync, readSync, statSync as statSync4 } from "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 {
+    end = statSync4(path2).size;
+    if (end === 0) return;
+    fd = 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 = 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 {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+
+// src/audit/auditBodyReader.ts
+function candidateDays(auditDir, ts) {
+  if (typeof ts === "number" && Number.isFinite(ts)) {
+    const named = auditDayDirName(ts);
+    if (existsSync17(join9(auditDir, named))) return [named];
+  }
   try {
-    files = readdirSync3(auditDir).filter((f) => AUDIT_FILE_RE.test(f));
+    return readdirSync4(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 = join9(auditDir, day, AUDIT_BODIES_DIR, auditBodyFileName(sessionKey));
+  try {
+    if (existsSync17(base)) return readFileSync16(base, "utf8");
+    const gz = `${base}.gz`;
+    if (existsSync17(gz)) return gunzipSync(readFileSync16(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 = readFileSync15(join8(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 = join9(auditDir, day, AUDIT_BODIES_DIR, AUDIT_DICT_FILE);
+  let raw = null;
+  try {
+    if (existsSync17(base)) raw = readFileSync16(base, "utf8");
+    else if (existsSync17(`${base}.gz`)) raw = gunzipSync(readFileSync16(`${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 (!existsSync17(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 = readdirSync4(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(join9(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
+import { existsSync as existsSync18, readdirSync as readdirSync5 } from "fs";
+import { join as join10 } from "path";
+var DEFAULT_LIMIT = 200;
+var MAX_LIMIT = 2e3;
+var OVERSCAN = 256;
+function daySources(auditDir) {
+  let names;
+  try {
+    names = readdirSync5(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 = join10(auditDir, name, AUDIT_META_FILE);
+      if (existsSync18(path2)) sources.push({ path: path2, dateMs });
+    } else if (AUDIT_FILE_RE.test(name)) {
+      sources.push({ path: join10(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 (!existsSync18(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
-import { appendFileSync as appendFileSync2, existsSync as existsSync17, mkdirSync as mkdirSync5, statSync as statSync4 } from "fs";
-import { join as join9 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync19, mkdirSync as mkdirSync5, statSync as statSync6 } from "fs";
+import { join as join11 } from "path";
 var AuditWriter = class {
   constructor(auditDir, logger, defer = (fn) => setTimeout(fn, 0)) {
     this.auditDir = auditDir;
@@ -9235,10 +9928,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(() => {
@@ -9251,25 +9947,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) {
-      mkdirSync5(this.auditDir, { recursive: true });
-      this.dirEnsured = true;
-    }
-    const file = join9(this.auditDir, auditFileName(record.ts));
-    const line = JSON.stringify(record) + "\n";
-    const auditBytesBefore = existsSync17(file) ? statSync4(file).size : 0;
+    const dayDir = auditDayDirName(record.ts);
+    const dayPath = this.ensureDir(join11(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)) {
+      mkdirSync5(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 = join11(dayPath, AUDIT_META_FILE);
+    const line = JSON.stringify(meta) + "\n";
+    const bytesBefore = existsSync19(file) ? statSync6(file).size : 0;
     appendFileSync2(file, line, "utf8");
     try {
       updateAuditStatsAfterAppend(
         file,
-        auditBytesBefore,
-        auditBytesBefore + Buffer.byteLength(line, "utf8"),
+        bytesBefore,
+        bytesBefore + Buffer.byteLength(line, "utf8"),
         record
       );
     } catch (error) {
@@ -9278,12 +9990,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(join11(dayPath, AUDIT_BODIES_DIR));
+      appendFileSync2(join11(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
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync6 } from "fs";
 import { createHmac } from "crypto";
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 import { fetchUpstream as fetchUpstream5 } from "@omnicross/core/pipeline/upstreamFetch";
 
 // src/billing/billingFiles.ts
@@ -9354,7 +10093,7 @@ var BillingPublisher = class {
    */
   appendNow(event) {
     this.ensureDir();
-    const file = join10(this.billingDir, billingFileName(event.ts));
+    const file = join12(this.billingDir, billingFileName(event.ts));
     appendFileSync3(file, JSON.stringify(event) + "\n", "utf8");
   }
   /**
@@ -9404,7 +10143,7 @@ var BillingPublisher = class {
   markDelivered(event) {
     try {
       this.ensureDir();
-      const file = join10(this.billingDir, deliveredFileName(event.ts));
+      const file = join12(this.billingDir, deliveredFileName(event.ts));
       appendFileSync3(file, JSON.stringify({ id: event.id, deliveredAt: this.now() }) + "\n", "utf8");
     } catch (error) {
       this.logger.warn("[BillingPublisher] failed to append delivery marker", {
@@ -9420,14 +10159,14 @@ var BillingPublisher = class {
 };
 
 // src/billing/billingReader.ts
-import { existsSync as existsSync18, readdirSync as readdirSync4, readFileSync as readFileSync16 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync20, readdirSync as readdirSync6, readFileSync as readFileSync17 } from "fs";
+import { join as join13 } from "path";
 function readBillingLedger(billingDir) {
   const view = { events: [], deliveredIds: /* @__PURE__ */ new Set() };
-  if (!existsSync18(billingDir)) return view;
+  if (!existsSync20(billingDir)) return view;
   let files;
   try {
-    files = readdirSync4(billingDir);
+    files = readdirSync6(billingDir);
   } catch {
     return view;
   }
@@ -9458,7 +10197,7 @@ function readBillingStatus(billingDir) {
 function parseLines(dir, file) {
   let raw;
   try {
-    raw = readFileSync16(join11(dir, file), "utf8");
+    raw = readFileSync17(join13(dir, file), "utf8");
   } catch {
     return [];
   }
@@ -9962,8 +10701,10 @@ function buildDaemon(config, paths) {
     async (providerId, model) => await pricingEngine.getEntry(providerId, model) !== null
   );
   const keySpendTracker = new KeySpendTracker(usageEventStore);
+  const usageThroughput = getSharedUsageThroughputTracker2();
   const usageRecorder = new UsageRecorder(usageEventStore, pricingEngine, logger, {
-    onRecord: (apiKeyId, costUsd, at) => keySpendTracker.add(apiKeyId, costUsd, at)
+    onRecord: (apiKeyId, costUsd, at) => keySpendTracker.add(apiKeyId, costUsd, at),
+    onEvent: (row, at) => usageThroughput.record(row, at)
   });
   const providerProxy = getProviderProxy({ llmConfig, apiKeyPool, usageRecorder });
   const routeLeaseManager = new RouteLeaseManager(
@@ -10112,6 +10853,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)
@@ -10185,10 +10931,11 @@ function resetDaemonSingletonsForTests() {
   __resetSharedIdentityStoreForTests();
   __resetSharedAccountAllowanceStoreForTests();
   __resetSharedAccountAllowanceSchedulingForTests();
+  __resetSharedUsageThroughputTrackerForTests();
 }
 function isTokensStoreReadable(tokensPath) {
   try {
-    if (!existsSync19(tokensPath)) return true;
+    if (!existsSync21(tokensPath)) return true;
     accessSync(tokensPath, fsConstants.R_OK);
     return true;
   } catch {