@hasna/economy 0.5.1 → 0.5.3

package/dist/server/index.js

@@ -1118,12 +1118,32 @@ function meteredBudgetAmounts(groups, limit, threshold) {
 function ymd(date2) {
   return date2.toISOString().substring(0, 10);
 }
-function calendarPeriodBounds(period, now = new Date) {
+function resolveReportingInterval(interval, now = new Date) {
   if (!Number.isFinite(now.getTime()))
     throw new RangeError("Invalid reporting clock");
-  const start = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+  const start = new Date(now);
+  start.setUTCHours(0, 0, 0, 0);
   const end = new Date(start);
-  switch (period) {
+  if (interval.kind === "rolling") {
+    if (!Number.isSafeInteger(interval.count) || interval.count < 1)
+      throw new RangeError("Invalid reporting window");
+    if (interval.unit === "hour") {
+      start.setTime(now.getTime() - interval.count * 3600000);
+      if (!Number.isFinite(start.getTime()))
+        throw new RangeError("Invalid reporting window");
+      return { time_zone: "UTC", start: start.toISOString(), end_exclusive: now.toISOString() };
+    }
+    if (interval.unit !== "day")
+      throw new RangeError("Invalid reporting unit");
+    start.setUTCDate(start.getUTCDate() - interval.count + 1);
+    end.setUTCDate(end.getUTCDate() + 1);
+    if (!Number.isFinite(start.getTime()) || !Number.isFinite(end.getTime()))
+      throw new RangeError("Invalid reporting window");
+    return { time_zone: "UTC", start: ymd(start), end_exclusive: ymd(end) };
+  }
+  if (interval.kind !== "calendar")
+    throw new RangeError("Invalid reporting interval");
+  switch (interval.period) {
     case "today":
       end.setUTCDate(end.getUTCDate() + 1);
       break;
@@ -1146,11 +1166,15 @@ function calendarPeriodBounds(period, now = new Date) {
       end.setUTCFullYear(end.getUTCFullYear() + 1);
       break;
     case "all":
-      return { time_zone: "UTC", start_date: null, end_date_exclusive: null };
+      return { time_zone: "UTC", start: null, end_exclusive: null };
     default:
       throw new RangeError("Invalid reporting period");
   }
-  return { time_zone: "UTC", start_date: ymd(start), end_date_exclusive: ymd(end) };
+  return { time_zone: "UTC", start: ymd(start), end_exclusive: ymd(end) };
+}
+function calendarPeriodBounds(period, now = new Date) {
+  const bounds = resolveReportingInterval({ kind: "calendar", period }, now);
+  return { time_zone: bounds.time_zone, start_date: bounds.start, end_date_exclusive: bounds.end_exclusive };
 }
 function calendarPeriodWhere(period, column, now = new Date) {
   if (!/^[a-z_][a-z0-9_]*(?:\.[a-z_][a-z0-9_]*)?$/i.test(column)) {
@@ -2209,20 +2233,22 @@ function queryAccountBreakdownSince(db, since) {
     ORDER BY api_equivalent_usd DESC
   `).all(since, since);
 }
-function queryDailyBreakdown(db, days = 30, machine) {
+function queryDailyBreakdown(db, days = 30, machine, now = new Date) {
+  const bounds = resolveReportingInterval({ kind: "rolling", unit: "day", count: days }, now);
   const machineClause = machine ? " AND machine_id = ?" : "";
-  const params = machine ? [`-${days}`, machine] : [`-${days}`];
+  const params = machine ? [bounds.start, bounds.end_exclusive, machine] : [bounds.start, bounds.end_exclusive];
   return db.prepare(`
     SELECT DATE(timestamp) as date, agent, COALESCE(SUM(cost_usd), 0) as cost_usd
     FROM economy_effective_requests
-    WHERE timestamp >= DATE('now', ? || ' days')${machineClause}
+    WHERE timestamp >= ? AND timestamp < ?${machineClause}
     GROUP BY DATE(timestamp), agent
     ORDER BY date ASC
   `).all(...params);
 }
-function queryHourlyBreakdown(db, machine, hours) {
-  const clauses = hours == null ? [`DATE(timestamp) = DATE('now')`] : [`DATETIME(timestamp) >= DATETIME('now', ?)`];
-  const params = hours == null ? [] : [`-${hours} hours`];
+function queryHourlyBreakdown(db, machine, hours, now = new Date) {
+  const bounds = resolveReportingInterval(hours == null ? { kind: "calendar", period: "today" } : { kind: "rolling", unit: "hour", count: hours }, now);
+  const clauses = hours == null ? ["timestamp >= ? AND timestamp < ?"] : ["STRFTIME('%Y-%m-%dT%H:%M:%fZ', timestamp) >= ? AND STRFTIME('%Y-%m-%dT%H:%M:%fZ', timestamp) < ?"];
+  const params = [bounds.start, bounds.end_exclusive];
   if (machine) {
     clauses.push("machine_id = ?");
     params.push(machine);
@@ -3143,15 +3169,16 @@ function translateSqliteDates(sql) {
   s = s.replace(/DATE\('now',\s*(\$\d+)\s*\|\|\s*' days'\)/gi, (_m, p) => isoDate(`now() + ((${p}) || ' days')::interval`));
   s = s.replace(/DATETIME\('now',\s*(\$\d+)\)/gi, (_m, p) => `(now() + (${p})::interval)`);
   s = s.replace(/DATETIME\('now',\s*'([^']+)'\)/gi, (_m, lit) => `(now() + interval '${lit}')`);
+  s = s.replace(/STRFTIME\('%Y-%m-%dT%H:%M:%fZ',\s*([A-Za-z_][A-Za-z0-9_]*)\)/gi, (_m, col) => `to_char(CAST("${col}" AS timestamptz) AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`);
   const strftimeMap = { "%H": "HH24", "%Y": "YYYY", "%m": "MM", "%d": "DD", "%M": "MI", "%S": "SS" };
   s = s.replace(/STRFTIME\('([^']+)',\s*([A-Za-z_][A-Za-z0-9_]*)\)/gi, (_m, fmt, col) => {
     const pgFmt = Object.entries(strftimeMap).reduce((acc, [k, v]) => acc.split(k).join(v), fmt);
-    return `to_char(CAST("${col}" AS timestamptz), '${pgFmt}')`;
+    return `to_char(CAST("${col}" AS timestamptz) AT TIME ZONE 'UTC', '${pgFmt}')`;
   });
   s = s.replace(/\bDATE\('now'\)/gi, isoDate("now()"));
   s = s.replace(/\bDATETIME\('now'\)/gi, "now()");
   s = s.replace(/\bDATETIME\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)/gi, (_m, col) => `CAST("${col}" AS timestamptz)`);
-  s = s.replace(/\bDATE\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)/gi, (_m, col) => `substr("${col}", 1, 10)`);
+  s = s.replace(/\bDATE\(\s*([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)?)\s*\)/gi, (_m, col) => `substr(${col.split(".").map((part) => `"${part}"`).join(".")}, 1, 10)`);
   return s;
 }
 function resolveWorkerPath() {
@@ -3360,6 +3387,30 @@ function resolvePgConnection(dsn) {
 }
 var init_pg_connection = () => {};
 
+// src/db/legacy-large-schema.ts
+var LEGACY_LARGE_SESSION_PG_SQL = `
+CREATE INDEX idx_legacy_targets_session_operation
+  ON legacy_reconciliation_targets(session_id,operation_key);
+CREATE OR REPLACE FUNCTION economy_legacy_target_guard() RETURNS trigger LANGUAGE plpgsql AS $body$
+BEGIN
+  IF EXISTS(
+    SELECT 1 FROM (SELECT DISTINCT session_id,operation_key FROM inserted_legacy_targets) n
+    JOIN economy_legacy_active a ON a.session_id=n.session_id AND a.operation_key<>n.operation_key
+  ) OR EXISTS(
+    SELECT 1 FROM inserted_legacy_targets n
+    JOIN economy_legacy_active a ON a.request_id=n.request_id AND a.operation_key<>n.operation_key
+  ) THEN
+    RAISE EXCEPTION 'legacy reconciliation is already active for this session' USING ERRCODE='23000';
+  END IF;
+  RETURN NULL;
+END
+$body$;
+DROP TRIGGER legacy_target_no_overlap ON legacy_reconciliation_targets;
+CREATE TRIGGER legacy_target_no_overlap AFTER INSERT ON legacy_reconciliation_targets
+  REFERENCING NEW TABLE AS inserted_legacy_targets
+  FOR EACH STATEMENT EXECUTE FUNCTION economy_legacy_target_guard();
+`;
+
 // src/db/pg-migrations.ts
 var PG_MIGRATIONS;
 var init_pg_migrations = __esm(() => {
@@ -3595,7 +3646,8 @@ var init_pg_migrations = __esm(() => {
     ...OBSERVATION_PG_MIGRATIONS,
     `ALTER TABLE budgets ADD COLUMN IF NOT EXISTS metric TEXT NOT NULL DEFAULT 'legacy_request_cost_usd'
     CHECK (metric IN ('legacy_request_cost_usd', 'metered_api_usd'))`,
-    LEGACY_PG_SQL
+    LEGACY_PG_SQL,
+    LEGACY_LARGE_SESSION_PG_SQL
   ];
 });
 
@@ -4004,12 +4056,21 @@ var init_config = __esm(() => {
 function detectCostSpikes(dailyTotals, opts) {
   const windowDays = opts?.windowDays ?? 7;
   const multiplier = opts?.multiplier ?? 2;
+  if (!Number.isSafeInteger(windowDays) || windowDays < 1)
+    throw new RangeError("Invalid spike window");
+  if (!Number.isFinite(multiplier) || multiplier <= 0)
+    throw new RangeError("Invalid spike multiplier");
   const sorted = [...dailyTotals].sort((a, b) => a.date.localeCompare(b.date));
   const spikes = [];
   for (let i = windowDays;i < sorted.length; i++) {
     const window = sorted.slice(i - windowDays, i);
-    const avg = window.reduce((s, d) => s + d.cost_usd, 0) / window.length;
     const current = sorted[i];
+    const previous = new Date(current.date + "T00:00:00.000Z");
+    previous.setUTCDate(previous.getUTCDate() - 1);
+    const bounds = resolveReportingInterval({ kind: "rolling", unit: "day", count: windowDays }, previous);
+    if (window[0].date !== bounds.start || window[window.length - 1].date !== previous.toISOString().slice(0, 10) || new Set(window.map((day) => day.date)).size !== windowDays)
+      continue;
+    const avg = window.reduce((s, d) => s + d.cost_usd, 0) / window.length;
     if (avg > 0 && current.cost_usd > avg * multiplier) {
       spikes.push({
         date: current.date,
@@ -4021,21 +4082,23 @@ function detectCostSpikes(dailyTotals, opts) {
   }
   return spikes;
 }
-function queryRecentSpikes(db, days = 14) {
+function queryRecentSpikes(db, days = 14, now = new Date) {
+  const bounds = resolveReportingInterval({ kind: "rolling", unit: "day", count: days }, now);
   const rows = db.prepare(`
     SELECT DATE(timestamp) as date, COALESCE(SUM(cost_usd), 0) as cost_usd
     FROM economy_effective_requests
-    WHERE timestamp >= DATE('now', ? || ' days')
+    WHERE timestamp >= ? AND timestamp < ?
     GROUP BY DATE(timestamp)
     ORDER BY date ASC
-  `).all(-days);
+  `).all(bounds.start, bounds.end_exclusive);
   return detectCostSpikes(rows);
 }
-function getTodaySpike(db) {
-  const today = new Date().toISOString().substring(0, 10);
-  const spikes = queryRecentSpikes(db, 14);
+function getTodaySpike(db, now = new Date) {
+  const today = resolveReportingInterval({ kind: "calendar", period: "today" }, now).start;
+  const spikes = queryRecentSpikes(db, 14, now);
   return spikes.find((s) => s.date === today) ?? null;
 }
+var init_spikes = () => {};
 
 // src/lib/webhooks.ts
 var exports_webhooks = {};
@@ -4102,6 +4165,7 @@ async function fireWebhook(url, payload) {
 var init_webhooks = __esm(() => {
   init_config();
   init_database();
+  init_spikes();
 });
 
 // src/db/pg-migrate.ts
@@ -4508,6 +4572,42 @@ var init_legacy_inventory = __esm(() => {
   allCandidates = LEGACY_FAMILIES.map((family) => `(${predicates[family]})`).join(" OR ");
 });
 
+// src/server/legacy-limits.ts
+function legacyMode(kind, schema) {
+  if (schema === LEGACY_STANDARD[kind])
+    return LEGACY_STANDARD;
+  if (schema === LEGACY_SINGLE_SESSION[kind])
+    return LEGACY_SINGLE_SESSION;
+  throw Error(`Unsupported legacy ${kind} schema`);
+}
+var LEGACY_STANDARD, LEGACY_SINGLE_SESSION;
+var init_legacy_limits = __esm(() => {
+  LEGACY_STANDARD = {
+    selection: "economy.legacy-selection.v1",
+    plan: "economy.legacy-plan.v1",
+    capsule: "economy.legacy-preservation.v1",
+    receipt: "economy.legacy-operation-receipt.v1",
+    items: 100,
+    sessions: 100,
+    members: 1e4,
+    inputBytes: 256 * 1024,
+    originalBytes: 16 * 1024 * 1024,
+    capsuleBytes: 32 * 1024 * 1024
+  };
+  LEGACY_SINGLE_SESSION = {
+    selection: "economy.legacy-session-selection.v1",
+    plan: "economy.legacy-session-plan.v1",
+    capsule: "economy.legacy-session-preservation.v1",
+    receipt: "economy.legacy-session-operation-receipt.v1",
+    items: 50000,
+    sessions: 1,
+    members: 50000,
+    inputBytes: 32 * 1024 * 1024,
+    originalBytes: 64 * 1024 * 1024,
+    capsuleBytes: 128 * 1024 * 1024
+  };
+});
+
 // src/server/legacy-plan.ts
 var exports_legacy_plan = {};
 __export(exports_legacy_plan, {
@@ -4543,10 +4643,11 @@ function digest2(value) {
 }
 function parseLegacySelection(value) {
   const input = object(value, ["schema", "items"], "selection");
-  if (input.schema !== "economy.legacy-selection.v1")
-    throw Error("schema must be economy.legacy-selection.v1");
-  if (!Array.isArray(input.items) || input.items.length < 1 || input.items.length > 100)
-    throw Error("items must contain 1-100 explicit request selections");
+  const mode = legacyMode("selection", input.schema);
+  if (!Array.isArray(input.items) || input.items.length < 1 || input.items.length > mode.items)
+    throw Error(`items must contain 1-${mode.items} explicit request selections`);
+  if (Buffer.byteLength(JSON.stringify(input)) > mode.inputBytes)
+    throw Error(`Selection exceeds its ${mode.inputBytes}-byte artifact bound`);
   const ids = new Set;
   const items = input.items.map((item) => {
     const row = object(item, ["id", "family", "original_sha256", "disposition", "reason", "evidence_ref"], "item");
@@ -4569,7 +4670,7 @@ function parseLegacySelection(value) {
       evidence_ref: text(row.evidence_ref, 512, "evidence_ref")
     };
   }).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-  return { schema: "economy.legacy-selection.v1", items };
+  return { schema: mode.selection, items };
 }
 function readLegacySelectionFile(path) {
   if (!isAbsolute(path) || path.includes("\x00"))
@@ -4582,9 +4683,10 @@ function readLegacySelectionFile(path) {
   }
   try {
     const before = fstatSync(fd);
+    const sizeError = "--input must be a regular JSON file of 1-262144 bytes for standard selection, or at most 33554432 bytes for explicit single-session selection";
     if (!before.isFile() || before.size < 1 || before.size > INPUT_MAX)
-      throw Error("--input must be a regular JSON file of 1-262144 bytes");
-    const bytes = Buffer.alloc(INPUT_MAX + 1);
+      throw Error(sizeError);
+    const bytes = Buffer.alloc(Math.min(INPUT_MAX + 1, before.size + 1));
     let offset = 0, n;
     while (offset < bytes.length && (n = readSync(fd, bytes, offset, bytes.length - offset, null)) > 0)
       offset += n;
@@ -4595,9 +4697,12 @@ function readLegacySelectionFile(path) {
     try {
       value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, offset)));
     } catch {
-      throw Error("--input must contain valid UTF-8 JSON");
+      throw Error(before.size > LEGACY_STANDARD.inputBytes ? sizeError : "--input must contain valid UTF-8 JSON");
     }
-    return parseLegacySelection(value);
+    const selection = parseLegacySelection(value);
+    if (offset > legacyMode("selection", selection.schema).inputBytes)
+      throw Error(sizeError);
+    return selection;
   } finally {
     closeSync(fd);
   }
@@ -4612,6 +4717,7 @@ async function prepareLegacyPlan(client, input) {
 }
 async function withLegacyPlanSnapshot(client, input, read) {
   const selection = parseLegacySelection(input);
+  const mode = legacyMode("selection", selection.schema);
   let began = false;
   try {
     await client.query("BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY");
@@ -4646,14 +4752,16 @@ async function withLegacyPlanSnapshot(client, input, read) {
       return { ...item, session_id: identifier2(row.session_id, "session_id") };
     });
     const sessionIds = [...new Set(items.map((x) => x.session_id))].sort();
+    if (mode.sessions === 1 && sessionIds.length !== 1)
+      throw Error("Single-session reconciliation requires exactly one session");
     const sessions = (await client.query(`SELECT id, encode(sha256(convert_to(row_to_json(sessions)::text,'UTF8')),'hex') AS original_sha256
       FROM sessions WHERE id=ANY($1::text[]) ORDER BY id`, [sessionIds])).rows;
     if (sessions.length !== sessionIds.length)
       throw Error("A selected request has no session; resolve that inconsistency before reconciliation");
     const members = (await client.query(`SELECT id, session_id, encode(sha256(convert_to(row_to_json(requests)::text,'UTF8')),'hex') AS original_sha256
-      FROM requests WHERE session_id=ANY($1::text[]) ORDER BY session_id COLLATE "C", id COLLATE "C" LIMIT ${MEMBERS_MAX + 1}`, [sessionIds])).rows;
-    if (members.length > MEMBERS_MAX)
-      throw Error("Selected sessions exceed 10000 requests; split the selection by session or use a separately reviewed large-session procedure");
+      FROM requests WHERE session_id=ANY($1::text[]) ORDER BY session_id COLLATE "C", id COLLATE "C" LIMIT ${mode.members + 1}`, [sessionIds])).rows;
+    if (members.length > mode.members)
+      throw Error(`Selected sessions exceed ${mode.members} requests; complete-session reconciliation cannot truncate membership`);
     const populations = sessions.map((session) => {
       const rows = members.filter((row) => row.session_id === session.id);
       if (!rows.length)
@@ -4663,7 +4771,7 @@ async function withLegacyPlanSnapshot(client, input, read) {
       return { id: session.id, original_sha256, request_count: rows.length, members_sha256 };
     });
     const body = {
-      schema: "economy.legacy-plan.v1",
+      schema: mode.plan,
       mode: "read-only",
       original_encoding: "postgres-row-json-text-v1",
       member_encoding: "sha256-json-id-digest-pairs-utf8-c-order-v1",
@@ -4707,10 +4815,11 @@ async function runLegacyPlan(selection) {
     await pool.end();
   }
 }
-var INPUT_MAX, MEMBERS_MAX = 1e4, sha256 = (text) => createHash6("sha256").update(text).digest("hex");
+var INPUT_MAX, sha256 = (text) => createHash6("sha256").update(text).digest("hex");
 var init_legacy_plan = __esm(() => {
   init_legacy_inventory();
-  INPUT_MAX = 256 * 1024;
+  init_legacy_limits();
+  INPUT_MAX = LEGACY_SINGLE_SESSION.inputBytes;
 });
 
 // src/server/legacy-preservation.ts
@@ -4731,15 +4840,16 @@ import { closeSync as closeSync2, constants as constants2, fstatSync as fstatSyn
 import { basename as basename4, dirname as dirname4, isAbsolute as isAbsolute2 } from "path";
 function parseLegacyPlan(value) {
   const p = record(value);
+  const mode = legacyMode("plan", p.schema);
   fields(p, ["schema", "mode", "original_encoding", "member_encoding", "snapshot", "items", "sessions", "mutations_performed", "limitations", "plan_sha256"]);
-  if (p.schema !== "economy.legacy-plan.v1" || p.mode !== "read-only" || p.original_encoding !== "postgres-row-json-text-v1" || p.member_encoding !== "sha256-json-id-digest-pairs-utf8-c-order-v1" || p.mutations_performed !== 0)
+  if (p.mode !== "read-only" || p.original_encoding !== "postgres-row-json-text-v1" || p.member_encoding !== "sha256-json-id-digest-pairs-utf8-c-order-v1" || p.mutations_performed !== 0)
     fail("Unsupported legacy plan contract");
   const { plan_sha256, ...body } = p;
   if (hash(plan_sha256) !== sha2(JSON.stringify(body)))
     fail("Legacy plan digest mismatch");
   if (!Array.isArray(p.items))
     fail("Legacy plan items must be an array");
-  const selection = parseLegacySelection({ schema: "economy.legacy-selection.v1", items: p.items.map((item) => {
+  const selection = parseLegacySelection({ schema: mode.selection, items: p.items.map((item) => {
     const row = record(item);
     fields(row, ["id", "family", "original_sha256", "disposition", "reason", "evidence_ref", "session_id"]);
     identifier3(row.session_id);
@@ -4767,7 +4877,7 @@ function parseLegacyPlan(value) {
     if (typeof t.relation_oid !== "string" || !/^[0-9]+$/.test(t.relation_oid))
       fail("Invalid relation locator");
   }
-  if (!Array.isArray(p.sessions) || p.sessions.length < 1 || p.sessions.length > 100)
+  if (!Array.isArray(p.sessions) || p.sessions.length < 1 || p.sessions.length > mode.sessions)
     fail("Invalid legacy session population");
   const ids = new Set;
   let members = 0;
@@ -4784,7 +4894,7 @@ function parseLegacyPlan(value) {
       fail("Invalid legacy member count");
     members += s.request_count;
   }
-  if (members > MAX_MEMBERS || p.items.some((x) => !ids.has(x.session_id)) || ids.size !== new Set(p.items.map((x) => x.session_id)).size)
+  if (members > mode.members || p.items.some((x) => !ids.has(x.session_id)) || ids.size !== new Set(p.items.map((x) => x.session_id)).size)
     fail("Incomplete or excessive legacy session membership");
   if (!Array.isArray(p.limitations) || p.limitations.length > 20 || p.limitations.some((x) => typeof x !== "string" || x.length > 2048))
     fail("Invalid legacy plan limitations");
@@ -4801,16 +4911,28 @@ function assertLegacyPlanCurrent(expected, current) {
 }
 function parseLegacyCapsule(value) {
   const c = record(value);
+  const mode = legacyMode("capsule", c.schema);
   fields(c, ["schema", "plan", "captured_at", "requests", "sessions", "capsule_sha256"]);
-  if (c.schema !== "economy.legacy-preservation.v1" || typeof c.captured_at !== "string" || c.captured_at.length > 100 || !c.captured_at)
+  if (typeof c.captured_at !== "string" || c.captured_at.length > 100 || !c.captured_at)
     fail("Invalid preservation capsule");
   const { capsule_sha256, ...body } = c;
   const bytes = JSON.stringify(body);
-  if (Buffer.byteLength(bytes) > MAX_BYTES || hash(capsule_sha256) !== sha2(bytes))
+  if (Buffer.byteLength(bytes) > mode.capsuleBytes || hash(capsule_sha256) !== sha2(bytes))
     fail("Preservation capsule bound or digest mismatch");
   const plan = parseLegacyPlan(c.plan);
-  if (!Array.isArray(c.requests) || c.requests.length > MAX_MEMBERS || !Array.isArray(c.sessions) || c.sessions.length !== plan.sessions.length)
+  if (plan.schema !== mode.plan)
+    fail("Preservation capsule and plan use different artifact modes");
+  if (!Array.isArray(c.requests) || c.requests.length > mode.members || !Array.isArray(c.sessions) || c.sessions.length !== plan.sessions.length)
     fail("Invalid original populations");
+  let originalBytes = 0;
+  const boundOriginal = (original) => {
+    if (typeof original !== "string")
+      fail("Invalid original row text");
+    originalBytes += Buffer.byteLength(original);
+    if (originalBytes > mode.originalBytes)
+      fail("Preserved original row text exceeds its artifact mode bound");
+    return original;
+  };
   const requests = new Map;
   for (const value2 of c.requests) {
     const row = record(value2);
@@ -4818,7 +4940,7 @@ function parseLegacyCapsule(value) {
     const id = identifier3(row.id);
     if (requests.has(id) || typeof row.original !== "string")
       fail("Invalid or duplicate request original");
-    const original = record(JSON.parse(row.original));
+    const original = record(JSON.parse(boundOriginal(row.original)));
     if (original.id !== id)
       fail("Request original identity mismatch");
     requests.set(id, { session: identifier3(original.session_id), digest: sha2(row.original) });
@@ -4832,7 +4954,7 @@ function parseLegacyCapsule(value) {
       fail("Invalid or duplicate session original");
     sessions.add(id);
     const expected = plan.sessions.find((s) => s.id === id) ?? fail("Session original does not match the plan");
-    if (record(JSON.parse(row.original)).id !== id || sha2(row.original) !== expected.original_sha256)
+    if (record(JSON.parse(boundOriginal(row.original))).id !== id || sha2(row.original) !== expected.original_sha256)
       fail("Session original does not match the plan");
     const members = [...requests].filter(([, r]) => r.session === id).sort(([a], [b]) => cOrder(a, b)).map(([rid, r]) => [rid, r.digest]);
     if (members.length !== expected.request_count || sha2(JSON.stringify(members)) !== expected.members_sha256)
@@ -4849,18 +4971,19 @@ function parseLegacyCapsule(value) {
 }
 async function preserveLegacyOriginals(client, input) {
   const expected = parseLegacyPlan(input);
-  const selection = { schema: "economy.legacy-selection.v1", items: expected.items.map(({ session_id, ...item }) => item) };
+  const mode = legacyMode("plan", expected.schema);
+  const selection = { schema: mode.selection, items: expected.items.map(({ session_id, ...item }) => item) };
   return withLegacyPlanSnapshot(client, selection, async (current) => {
     assertLegacyPlanCurrent(expected, current);
     const ids = current.sessions.map((x) => x.id);
     const sizes = (await client.query(`SELECT
       (SELECT COALESCE(SUM(octet_length(row_to_json(requests)::text)),0) FROM requests WHERE session_id=ANY($1::text[]))::text AS request_bytes,
       (SELECT COALESCE(SUM(octet_length(row_to_json(sessions)::text)),0) FROM sessions WHERE id=ANY($1::text[]))::text AS session_bytes`, [ids])).rows[0];
-    if (!sizes || !/^[0-9]+$/.test(sizes.request_bytes) || !/^[0-9]+$/.test(sizes.session_bytes) || BigInt(sizes.request_bytes) + BigInt(sizes.session_bytes) > BigInt(MAX_BYTES / 2))
-      fail("Preservation exceeds 16 MiB of original row text; split by session");
-    const requests = (await client.query('SELECT id,row_to_json(requests)::text AS original FROM requests WHERE session_id=ANY($1::text[]) ORDER BY session_id COLLATE "C",id COLLATE "C" LIMIT 10001', [ids])).rows;
-    const sessions = (await client.query('SELECT id,row_to_json(sessions)::text AS original FROM sessions WHERE id=ANY($1::text[]) ORDER BY id COLLATE "C" LIMIT 101', [ids])).rows;
-    const body = { schema: "economy.legacy-preservation.v1", plan: expected, captured_at: current.snapshot.at, requests, sessions };
+    if (!sizes || !/^[0-9]+$/.test(sizes.request_bytes) || !/^[0-9]+$/.test(sizes.session_bytes) || BigInt(sizes.request_bytes) + BigInt(sizes.session_bytes) > BigInt(mode.originalBytes))
+      fail(`Preservation exceeds ${mode.originalBytes / 1024 / 1024} MiB of original row text; complete sessions cannot be truncated`);
+    const requests = (await client.query(`SELECT id,row_to_json(requests)::text AS original FROM requests WHERE session_id=ANY($1::text[]) ORDER BY session_id COLLATE "C",id COLLATE "C" LIMIT ${mode.members + 1}`, [ids])).rows;
+    const sessions = (await client.query(`SELECT id,row_to_json(sessions)::text AS original FROM sessions WHERE id=ANY($1::text[]) ORDER BY id COLLATE "C" LIMIT ${mode.sessions + 1}`, [ids])).rows;
+    const body = { schema: mode.capsule, plan: expected, captured_at: current.snapshot.at, requests, sessions };
     return parseLegacyCapsule({ ...body, capsule_sha256: sha2(JSON.stringify(body)) });
   });
 }
@@ -4891,11 +5014,16 @@ function readLegacyBytes(path, maxBytes = MAX_BYTES) {
 }
 function readLegacyArtifact(path, maxBytes = MAX_BYTES) {
   const bytes = readLegacyBytes(path, maxBytes);
+  let value;
   try {
-    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
   } catch {
     fail("Artifact must contain valid UTF-8 JSON");
   }
+  const limit = value?.schema === LEGACY_SINGLE_SESSION.plan || value?.schema === LEGACY_SINGLE_SESSION.capsule ? LEGACY_SINGLE_SESSION.capsuleBytes : LEGACY_STANDARD.capsuleBytes;
+  if (bytes.length > limit)
+    fail("Artifact exceeds its schema file bound");
+  return value;
 }
 function writeLegacyCapsule(path, input) {
   const capsule = parseLegacyCapsule(input);
@@ -4906,7 +5034,7 @@ function writeLegacyCapsule(path, input) {
     fail("Output parent must be an owner-only directory");
   const bytes = Buffer.from(JSON.stringify(capsule) + `
 `);
-  if (bytes.length > MAX_BYTES)
+  if (bytes.length > legacyMode("capsule", capsule.schema).capsuleBytes)
     fail("Preservation capsule exceeds the file bound");
   const fd = openSync2(path, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
   try {
@@ -5037,7 +5165,7 @@ async function runLegacyPreservation(command, options) {
     await pool.end();
   }
 }
-var MAX_BYTES, MAX_MEMBERS = 1e4, sha2 = (s) => createHash7("sha256").update(s).digest("hex"), fail = (message) => {
+var MAX_BYTES, sha2 = (s) => createHash7("sha256").update(s).digest("hex"), fail = (message) => {
   throw Error(message);
 }, record = (v) => v !== null && typeof v === "object" && !Array.isArray(v) ? v : fail("Expected a JSON object"), hash = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v) ? v : fail("Expected a lowercase SHA-256 digest"), identifier3 = (v) => typeof v === "string" && v.length > 0 && v.length <= 1024 && !v.includes("\x00") ? v : fail("Expected a nonempty identifier of at most 1024 characters without NUL"), fields = (o, names) => {
   if (Object.keys(o).sort().join(",") !== [...names].sort().join(","))
@@ -5045,7 +5173,8 @@ var MAX_BYTES, MAX_MEMBERS = 1e4, sha2 = (s) => createHash7("sha256").update(s).
 }, cOrder = (a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)), same = (a, b) => JSON.stringify(a) === JSON.stringify(b), quote3 = (s) => '"' + s.replaceAll('"', '""') + '"';
 var init_legacy_preservation = __esm(() => {
   init_legacy_plan();
-  MAX_BYTES = 32 * 1024 * 1024;
+  init_legacy_limits();
+  MAX_BYTES = LEGACY_SINGLE_SESSION.capsuleBytes;
 });
 
 // src/server/legacy-operations.ts
@@ -5109,6 +5238,7 @@ function matchIntent(intent, capsule, target) {
 }
 async function verifyOriginals(client, capsule) {
   const p = capsule.plan;
+  const mode = legacyMode("capsule", capsule.schema);
   const context2 = (await client.query("SELECT current_database() AS database,(SELECT oid::text FROM pg_database WHERE datname=current_database()) AS database_oid")).rows[0];
   if (context2?.database !== p.snapshot.database || context2?.database_oid !== p.snapshot.database_oid)
     fail2("Legacy operation targets a different database");
@@ -5122,7 +5252,7 @@ async function verifyOriginals(client, capsule) {
     fail2("Legacy session originals changed; preserve later work and prepare a new review");
   const rows = (await client.query(`SELECT id,session_id,encode(sha256(convert_to(row_to_json(requests)::text,'UTF8')),'hex') AS original_sha256,
     CASE ${LEGACY_FAMILIES.map((f) => "WHEN " + LEGACY_PREDICATES[f] + " THEN '" + f + "'").join(" ")} END AS family
-    FROM requests WHERE session_id=ANY($1::text[]) ORDER BY session_id COLLATE "C",id COLLATE "C" LIMIT 10001`, [ids])).rows;
+    FROM requests WHERE session_id=ANY($1::text[]) ORDER BY session_id COLLATE "C",id COLLATE "C" LIMIT ${mode.members + 1}`, [ids])).rows;
   if (rows.length !== capsule.requests.length)
     fail2("Legacy request membership changed; preserve later work and prepare a new review");
   const originals = new Map(capsule.requests.map((r) => [r.id, sha3(r.original)]));
@@ -5176,13 +5306,14 @@ async function observed(client, run) {
 }
 function validateReceipt(value) {
   const v = value;
-  if (!v || v.schema !== "economy.legacy-operation-receipt.v1" || !["apply", "rollback"].includes(v.action))
+  if (!v || !["apply", "rollback"].includes(v.action))
     fail2("Invalid stored legacy receipt");
+  const mode = legacyMode("receipt", v.schema);
   key(v.operation_key);
   key(v.apply_key);
   digest3(v.plan_sha256);
   digest3(v.capsule_sha256);
-  if (v.source_rows_changed !== 0 || ![v.target_requests, v.preserved_requests, v.sessions].every((n) => Number.isSafeInteger(n) && n > 0 && n <= 1e4) || v.target_requests > 100 || v.sessions > 100 || typeof v.created_at !== "string" || !Number.isFinite(Date.parse(v.created_at)))
+  if (v.source_rows_changed !== 0 || ![v.target_requests, v.preserved_requests, v.sessions].every((n) => Number.isSafeInteger(n) && n > 0 && n <= mode.members) || v.target_requests > mode.items || v.sessions > mode.sessions || typeof v.created_at !== "string" || !Number.isFinite(Date.parse(v.created_at)))
     fail2("Invalid stored legacy receipt fields");
   const names = ["schema", "action", "operation_key", "apply_key", "plan_sha256", "capsule_sha256", "target_requests", "preserved_requests", "sessions", "source_rows_changed", "created_at"];
   if (Object.keys(v).sort().join(",") !== names.sort().join(","))
@@ -5207,7 +5338,7 @@ async function reply(client, row, expectedHash) {
 }
 function receipt(action, intent, capsule) {
   return {
-    schema: "economy.legacy-operation-receipt.v1",
+    schema: legacyMode("capsule", capsule.schema).receipt,
     action,
     operation_key: intent.operation_key,
     apply_key: action === "apply" ? intent.operation_key : intent.apply_key,
@@ -5247,8 +5378,9 @@ async function applyLegacyReconciliation(client, input, preserved, target) {
     const saved = (await client.query("SELECT capsule_json,capsule_sha256 FROM legacy_reconciliations WHERE operation_key=$1", [intent.operation_key])).rows[0];
     if (saved?.capsule_json !== json3 || saved?.capsule_sha256 !== capsule.capsule_sha256 || parseLegacyCapsule(JSON.parse(saved.capsule_json)).capsule_sha256 !== capsule.capsule_sha256)
       fail2("Durable preservation readback failed");
-    for (const item of capsule.plan.items)
-      await client.query("INSERT INTO legacy_reconciliation_targets VALUES($1,$2,$3,$4,$5)", [intent.operation_key, item.id, item.session_id, item.disposition, item.original_sha256]);
+    await client.query(`INSERT INTO legacy_reconciliation_targets(operation_key,request_id,session_id,disposition,original_sha256)
+      SELECT $1, x.id, x.session_id, x.disposition, x.original_sha256
+      FROM jsonb_to_recordset($2::jsonb) AS x(id text,session_id text,disposition text,original_sha256 text)`, [intent.operation_key, JSON.stringify(capsule.plan.items.map(({ id, session_id, disposition, original_sha256 }) => ({ id, session_id, disposition, original_sha256 })))]);
     const stored = await lookup(client, "apply", intent.operation_key) ?? fail2("Legacy receipt readback failed");
     if (stored.response_json !== responseJson)
       fail2("Legacy receipt readback failed");
@@ -5360,6 +5492,7 @@ var sha3 = (s) => createHash8("sha256").update(s).digest("hex"), fail2 = (s) =>
   WHERE c.oid IN ('requests'::regclass,'sessions'::regclass) AND a.attnum>0 AND NOT a.attisdropped
   GROUP BY c.oid,c.relname,n.nspname ORDER BY c.relname`, same2 = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 var init_legacy_operations = __esm(() => {
+  init_legacy_limits();
   init_pg_connection();
   init_legacy_inventory();
   init_legacy_preservation();
@@ -5396,7 +5529,7 @@ function isAuthorizedRequest(req, path) {
 // package.json
 var package_default = {
   name: "@hasna/economy",
-  version: "0.5.1",
+  version: "0.5.3",
   description: "AI coding cost tracker \u2014 CLI + MCP server + REST API for Claude Code, Codex, OpenCode, Cursor, Pi, and Hermes, with legacy Gemini CLI session and Gemini API billing ingestion",
   repository: {
     type: "git",
@@ -11535,7 +11668,8 @@ function buildBrief(db, opts = {}) {
 }
 
 // src/lib/analytics.ts
-function queryProjectDetail(db, nameOrPath) {
+function queryProjectDetail(db, nameOrPath, now = new Date) {
+  const dailyBounds = resolveReportingInterval({ kind: "rolling", unit: "day", count: 14 }, now);
   const like = `%${nameOrPath}%`;
   const sessions = db.prepare(`SELECT id, project_name, project_path, total_cost_usd, total_tokens, started_at
      FROM economy_effective_sessions
@@ -11549,8 +11683,8 @@ function queryProjectDetail(db, nameOrPath) {
   const daily = db.prepare(`SELECT DATE(r.timestamp) as date, COALESCE(SUM(r.cost_usd), 0) as cost_usd
      FROM economy_effective_requests r JOIN economy_effective_sessions s ON r.session_id = s.id
      WHERE (s.project_name LIKE ? OR s.project_path LIKE ?)
-       AND r.timestamp >= DATE('now', '-14 days')
-     GROUP BY date ORDER BY date ASC`).all(like, like);
+       AND r.timestamp >= ? AND r.timestamp < ?
+     GROUP BY date ORDER BY date ASC`).all(like, like, dailyBounds.start, dailyBounds.end_exclusive);
   const models = db.prepare(`SELECT r.model as model, COUNT(*) as requests, COALESCE(SUM(r.cost_usd), 0) as cost_usd
      FROM economy_effective_requests r JOIN economy_effective_sessions s ON r.session_id = s.id
      WHERE s.project_name LIKE ? OR s.project_path LIKE ?
@@ -11589,18 +11723,17 @@ function queryRangeStats(db, from, to) {
   return { cost: r.cost, requests: r.requests, tokens: r.tokens, sessions: s.sessions };
 }
 function queryForecast(db, now = new Date) {
-  const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
-  const dayOfMonth = now.getDate();
-  const monthStart = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-01`;
-  const monthSoFar = db.prepare(`SELECT COALESCE(SUM(cost_usd),0) as cost FROM economy_effective_requests WHERE DATE(timestamp) >= ?`).get(monthStart);
+  const month = resolveReportingInterval({ kind: "calendar", period: "month" }, now);
+  const recent = resolveReportingInterval({ kind: "rolling", unit: "day", count: 7 }, now);
+  const daysInMonth = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 0)).getUTCDate();
+  const dayOfMonth = now.getUTCDate();
+  const monthSoFar = db.prepare(`SELECT COALESCE(SUM(cost_usd),0) as cost FROM economy_effective_requests WHERE timestamp >= ? AND timestamp < ?`).get(month.start, recent.end_exclusive);
   const dailyAvg = dayOfMonth > 0 ? monthSoFar.cost / dayOfMonth : 0;
   const projected = dailyAvg * daysInMonth;
-  const sevenDaysAgo = new Date(now);
-  sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
-  const last7 = db.prepare(`SELECT COALESCE(SUM(cost_usd),0) as cost FROM economy_effective_requests WHERE DATE(timestamp) >= ?`).get(sevenDaysAgo.toISOString().substring(0, 10));
+  const last7 = db.prepare(`SELECT COALESCE(SUM(cost_usd),0) as cost FROM economy_effective_requests WHERE timestamp >= ? AND timestamp < ?`).get(recent.start, recent.end_exclusive);
   const last7DailyAvg = last7.cost / 7;
   const dailyCosts = db.prepare(`SELECT DATE(timestamp) as date, COALESCE(SUM(cost_usd),0) as cost_usd
-     FROM economy_effective_requests WHERE DATE(timestamp) >= ? GROUP BY date ORDER BY cost_usd ASC`).all(monthStart);
+     FROM economy_effective_requests WHERE timestamp >= ? AND timestamp < ? GROUP BY date ORDER BY cost_usd ASC`).all(month.start, recent.end_exclusive);
   return {
     day_of_month: dayOfMonth,
     days_in_month: daysInMonth,
@@ -11777,7 +11910,13 @@ function createDataHandler(db, actorId) {
     if (path === "/api/daily" && method === "GET") {
       const days = Number(url.searchParams.get("days") ?? 30);
       const machine = url.searchParams.get("machine") ?? undefined;
-      return ok(queryDailyBreakdown(db, days, machine));
+      const now = new Date;
+      try {
+        resolveReportingInterval({ kind: "rolling", unit: "day", count: days }, now);
+      } catch {
+        return err("days must be a positive integer within the supported UTC date range");
+      }
+      return ok(queryDailyBreakdown(db, days, machine, now));
     }
     if (path === "/api/hourly" && method === "GET") {
       const machine = url.searchParams.get("machine") ?? undefined;