omnigateway 0.10.3 → 0.11.0

package/bin/omni.js

@@ -19238,13 +19238,13 @@ function prepareArtifact(input2) {
     error: error61.value
   };
   const json2 = JSON.stringify(bounded);
-  const size = encoder2.encode(json2).length;
+  const size = Buffer.byteLength(json2);
   if (size <= MAX_ARTIFACT_BYTES)
     return { artifact: bounded, json: json2 };
   const marker = omission(size);
   const omitted = omitBodies(bounded, marker);
   const omittedJson = JSON.stringify(omitted);
-  if (encoder2.encode(omittedJson).length <= MAX_ARTIFACT_BYTES) {
+  if (Buffer.byteLength(omittedJson) <= MAX_ARTIFACT_BYTES) {
     return { artifact: omitted, json: omittedJson };
   }
   const stripped = { ...omitted, error: marker };
@@ -19504,6 +19504,261 @@ function estimateCachedInputTokens(request) {
   }
   return cached2;
 }
+// packages/store/src/sqlite/rollup.ts
+var HOUR_MS = 3600000;
+function hourOf(at) {
+  return Math.floor(at / HOUR_MS);
+}
+var DAY_MS = 86400000;
+function hostDayOffsetMinutes() {
+  return -new Date().getTimezoneOffset() || 0;
+}
+function startOfDay(at, offsetMinutes) {
+  const offsetMs = offsetMinutes * 60000;
+  return Math.floor((at + offsetMs) / DAY_MS) * DAY_MS - offsetMs;
+}
+var UPSERT = `
+  INSERT INTO usage_daily
+    (day, provider, credential_id, requested_model, resolved_model, api_key_id,
+     requests, errors, input_tokens, output_tokens, cache_read_tokens,
+     cache_write_tokens, rtk_saved_tokens, rtk_applied_requests, cost_usd, duration_ms_sum)
+  VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+  ON CONFLICT (day, provider, credential_id, requested_model, resolved_model, api_key_id)
+  DO UPDATE SET
+    requests           = requests + excluded.requests,
+    errors             = errors + excluded.errors,
+    input_tokens       = input_tokens + excluded.input_tokens,
+    output_tokens      = output_tokens + excluded.output_tokens,
+    cache_read_tokens  = cache_read_tokens + excluded.cache_read_tokens,
+    cache_write_tokens    = cache_write_tokens + excluded.cache_write_tokens,
+    rtk_saved_tokens      = rtk_saved_tokens + excluded.rtk_saved_tokens,
+    rtk_applied_requests  = rtk_applied_requests + excluded.rtk_applied_requests,
+    cost_usd              = cost_usd + excluded.cost_usd,
+    duration_ms_sum    = duration_ms_sum + excluded.duration_ms_sum`;
+function keyOf(log, dayOffsetMinutes) {
+  return [
+    startOfDay(log.at, dayOffsetMinutes),
+    log.resolvedProvider ?? "",
+    log.credentialId ?? "",
+    log.requestedModel,
+    log.resolvedModel ?? "",
+    log.apiKeyId ?? ""
+  ];
+}
+function countersOf(log) {
+  return {
+    requests: 1,
+    errors: log.status >= 400 ? 1 : 0,
+    inputTokens: log.inputTokens,
+    outputTokens: log.outputTokens,
+    cacheReadTokens: log.cacheReadTokens,
+    cacheWriteTokens: log.cacheWriteTokens,
+    rtkSavedTokens: log.rtkEstimatedTokensSaved,
+    rtkAppliedRequests: log.rtkApplied ? 1 : 0,
+    costUsd: log.costUsd,
+    durationMsSum: log.durationMs
+  };
+}
+var BACKFILL_UPSERT = `
+  INSERT INTO usage_daily
+    (day, provider, credential_id, requested_model, resolved_model, api_key_id,
+     requests, errors, input_tokens, output_tokens, cache_read_tokens,
+     cache_write_tokens, cost_usd, duration_ms_sum)
+  VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+  ON CONFLICT (day, provider, credential_id, requested_model, resolved_model, api_key_id)
+  DO UPDATE SET
+    requests           = requests + excluded.requests,
+    errors             = errors + excluded.errors,
+    input_tokens       = input_tokens + excluded.input_tokens,
+    output_tokens      = output_tokens + excluded.output_tokens,
+    cache_read_tokens  = cache_read_tokens + excluded.cache_read_tokens,
+    cache_write_tokens = cache_write_tokens + excluded.cache_write_tokens,
+    cost_usd           = cost_usd + excluded.cost_usd,
+    duration_ms_sum    = duration_ms_sum + excluded.duration_ms_sum`;
+function upsertPreRtk(db, key, c) {
+  db.run(BACKFILL_UPSERT, [
+    ...key,
+    c.requests,
+    c.errors,
+    c.inputTokens,
+    c.outputTokens,
+    c.cacheReadTokens,
+    c.cacheWriteTokens,
+    c.costUsd,
+    c.durationMsSum
+  ]);
+}
+function upsert(db, key, c) {
+  db.run(UPSERT, [
+    ...key,
+    c.requests,
+    c.errors,
+    c.inputTokens,
+    c.outputTokens,
+    c.cacheReadTokens,
+    c.cacheWriteTokens,
+    c.rtkSavedTokens,
+    c.rtkAppliedRequests,
+    c.costUsd,
+    c.durationMsSum
+  ]);
+}
+function rollupLog(db, log, dayOffsetMinutes) {
+  upsert(db, keyOf(log, dayOffsetMinutes), countersOf(log));
+}
+function backfillDaily(db, dayOffsetMinutes) {
+  const groups = new Map;
+  for (const row of db.query(`SELECT at, api_key_id, requested_model, resolved_provider, resolved_model, credential_id,
+              status, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
+              duration_ms, cost_usd
+         FROM request_logs`).all()) {
+    const key = [
+      startOfDay(row.at, dayOffsetMinutes),
+      row.resolved_provider ?? "",
+      row.credential_id ?? "",
+      row.requested_model,
+      row.resolved_model ?? "",
+      row.api_key_id ?? ""
+    ];
+    const id = key.join("\x00");
+    const seen = groups.get(id);
+    const counters = seen?.counters ?? {
+      requests: 0,
+      errors: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      rtkSavedTokens: 0,
+      rtkAppliedRequests: 0,
+      costUsd: 0,
+      durationMsSum: 0
+    };
+    counters.requests += 1;
+    counters.errors += row.status >= 400 ? 1 : 0;
+    counters.inputTokens += row.input_tokens;
+    counters.outputTokens += row.output_tokens;
+    counters.cacheReadTokens += row.cache_read_tokens;
+    counters.cacheWriteTokens += row.cache_write_tokens;
+    counters.costUsd += row.cost_usd;
+    counters.durationMsSum += row.duration_ms;
+    if (seen === undefined)
+      groups.set(id, { key, counters });
+  }
+  for (const group of groups.values())
+    upsertPreRtk(db, group.key, group.counters);
+  return groups.size;
+}
+var HOURLY_UPSERT = `
+  INSERT INTO usage_rollup
+    (api_key_id, hour, requests, input_tokens, output_tokens,
+     cache_read_tokens, cache_write_tokens, cost_usd)
+  VALUES (?,?,?,?,?,?,?,?)
+  ON CONFLICT (api_key_id, hour)
+  DO UPDATE SET
+    requests           = requests + excluded.requests,
+    input_tokens       = input_tokens + excluded.input_tokens,
+    output_tokens      = output_tokens + excluded.output_tokens,
+    cache_read_tokens  = cache_read_tokens + excluded.cache_read_tokens,
+    cache_write_tokens = cache_write_tokens + excluded.cache_write_tokens,
+    cost_usd           = cost_usd + excluded.cost_usd`;
+function rollupHour(db, log) {
+  const apiKeyId = log.apiKeyId;
+  if (apiKeyId === null)
+    return;
+  db.run(HOURLY_UPSERT, [
+    apiKeyId,
+    hourOf(log.at),
+    1,
+    log.inputTokens,
+    log.outputTokens,
+    log.cacheReadTokens,
+    log.cacheWriteTokens,
+    log.costUsd
+  ]);
+}
+var REBUILD = `
+  INSERT INTO usage_rollup
+    (api_key_id, hour, requests, input_tokens, output_tokens,
+     cache_read_tokens, cache_write_tokens, cost_usd)
+  SELECT api_key_id,
+         CAST(at / 3600000 AS INTEGER),
+         COUNT(*),
+         COALESCE(SUM(input_tokens), 0),
+         COALESCE(SUM(output_tokens), 0),
+         COALESCE(SUM(cache_read_tokens), 0),
+         COALESCE(SUM(cache_write_tokens), 0),
+         COALESCE(SUM(cost_usd), 0)
+    FROM request_logs
+   WHERE state = 'done' AND api_key_id IS NOT NULL
+   GROUP BY api_key_id, CAST(at / 3600000 AS INTEGER)`;
+function rebuildRollup(db) {
+  db.run("DELETE FROM usage_rollup");
+  db.run(REBUILD);
+}
+function auditRollup(db) {
+  const row = db.query(`WITH truth AS (
+         SELECT api_key_id AS k,
+                CAST(at / 3600000 AS INTEGER) AS h,
+                COUNT(*) AS requests,
+                COALESCE(SUM(input_tokens), 0) AS input_tokens,
+                COALESCE(SUM(output_tokens), 0) AS output_tokens,
+                COALESCE(SUM(cache_read_tokens), 0) AS cache_read_tokens,
+                COALESCE(SUM(cache_write_tokens), 0) AS cache_write_tokens,
+                COALESCE(SUM(cost_usd), 0) AS cost_usd
+           FROM request_logs
+          WHERE state = 'done' AND api_key_id IS NOT NULL
+          GROUP BY k, h
+       )
+       SELECT (SELECT COUNT(*) FROM truth) AS buckets,
+              (SELECT COUNT(*)
+                 FROM truth
+                 LEFT JOIN usage_rollup r ON r.api_key_id = truth.k AND r.hour = truth.h
+                WHERE r.api_key_id IS NULL
+                   OR r.requests <> truth.requests
+                   OR r.input_tokens <> truth.input_tokens
+                   OR r.output_tokens <> truth.output_tokens
+                   OR r.cache_read_tokens <> truth.cache_read_tokens
+                   OR r.cache_write_tokens <> truth.cache_write_tokens
+                   OR ABS(r.cost_usd - truth.cost_usd) > 1e-9 + ABS(truth.cost_usd) * 1e-9
+              ) AS mismatched,
+              (SELECT COUNT(*)
+                 FROM usage_rollup r
+                 LEFT JOIN truth ON r.api_key_id = truth.k AND r.hour = truth.h
+                WHERE truth.k IS NULL
+              ) AS orphans`).get();
+  const buckets = row?.buckets ?? 0;
+  const mismatched = (row?.mismatched ?? 0) + (row?.orphans ?? 0);
+  return { buckets, mismatched, ok: mismatched === 0 };
+}
+function backfillRtkUsage(db, dayOffsetMinutes) {
+  const groups = new Map;
+  for (const row of db.query(`SELECT at, api_key_id, requested_model, resolved_provider, resolved_model, credential_id,
+              rtk_applied, rtk_estimated_tokens_saved
+         FROM request_logs
+        WHERE state = 'done'`).all()) {
+    const key = [
+      startOfDay(row.at, dayOffsetMinutes),
+      row.resolved_provider ?? "",
+      row.credential_id ?? "",
+      row.requested_model,
+      row.resolved_model ?? "",
+      row.api_key_id ?? ""
+    ];
+    const id = key.join("\x00");
+    const group = groups.get(id) ?? { key, saved: 0, applied: 0 };
+    group.saved += row.rtk_estimated_tokens_saved;
+    group.applied += row.rtk_applied === 1 ? 1 : 0;
+    groups.set(id, group);
+  }
+  for (const { key, saved, applied } of groups.values()) {
+    db.run(`UPDATE usage_daily
+          SET rtk_saved_tokens = ?, rtk_applied_requests = ?
+        WHERE day = ? AND provider = ? AND credential_id = ? AND requested_model = ?
+          AND resolved_model = ? AND api_key_id = ?`, [saved, applied, ...key]);
+  }
+}
+
 // packages/store/src/postgres/db.ts
 var {SQL } = globalThis.Bun;
 
@@ -19809,11 +20064,74 @@ CREATE TRIGGER api_keys_config_version
   FOR EACH STATEMENT EXECUTE FUNCTION bump_config_version();
 `;
 
+// packages/store/src/postgres/migrations/002_health_measurements.sql
+var _002_health_measurements_default = `-- DEPLOY HAZARD \u2014 read before applying to a fleet.
+--
+-- This migration drops two columns that every gateway before it writes on
+-- the success path (\`UPSERT_HEALTH\` names \`ewma_ttft_ms\` and \`last_used_at\`).
+-- The first new replica to boot applies it under the migration lock; from that
+-- moment every OLD replica still running throws on every successful request:
+-- the upstream call has completed and been billed, the client has received its
+-- content frames, and then the connection aborts with no terminal frame. The
+-- \`RollingUpdate\` in \`k8s/deployment.yaml\` does not protect against this \u2014 the
+-- "surviving" replica is the one that breaks.
+--
+-- Required: scale to ONE replica before deploying this release, or accept that
+-- every old replica fails every successful request until it is replaced.
+-- Rollback is unsafe: an old image cannot re-add the columns, and running it
+-- against this schema fails the same way. The only way back is a snapshot
+-- restore taken before the deploy. Deliberate: kept as a drop, not
+-- expand/contract, on the operator's decision \u2014 see the write-path spec.
+--
+-- \`credential_health\` keeps decisions, not measurements.
+--
+-- \`ewma_ttft_ms\` and \`last_used_at\` were written on every successful request,
+-- and a success that changes nothing else now writes nothing. Both live in the
+-- gateway's process-local \`loadRegistry\` instead. The console's "last used"
+-- reads \`request_logs\` through \`usage.lastUsedByCredential\`, served by
+-- \`idx_request_logs_cred\`.
+ALTER TABLE credential_health DROP COLUMN ewma_ttft_ms;
+ALTER TABLE credential_health DROP COLUMN last_used_at;
+
+-- The statement-level trigger bumped \`config_version\` \u2014 one row, locked until
+-- commit, by every writer on every replica \u2014 on every health write, and every
+-- bump makes every replica rebuild its routing snapshot. Only a change to a
+-- column routing *decides* on needs that; a bare \`consecutive_failures\`
+-- increment is patched into the held snapshot from the \`healthSaved\` change.
+--
+-- The INSERT arm must stay \`FOR EACH ROW\`. The write is an upsert, and a
+-- statement-level INSERT trigger fires on an upsert whichever path each row
+-- took, which would bump on every write and make the WHEN clause below moot.
+-- Row-level \`AFTER INSERT\` fires only for rows actually inserted.
+DROP TRIGGER credential_health_config_version ON credential_health;
+
+CREATE TRIGGER credential_health_config_version_upd
+  AFTER UPDATE ON credential_health
+  FOR EACH ROW
+  WHEN (OLD.breaker_state      IS DISTINCT FROM NEW.breaker_state
+     OR OLD.rate_limited_until IS DISTINCT FROM NEW.rate_limited_until
+     OR OLD.opened_at          IS DISTINCT FROM NEW.opened_at)
+  EXECUTE FUNCTION bump_config_version();
+
+CREATE TRIGGER credential_health_config_version_ins
+  AFTER INSERT ON credential_health
+  FOR EACH ROW EXECUTE FUNCTION bump_config_version();
+
+-- DELETE needs no WHEN, so it stays statement-level as in 001: a credential
+-- with M model rows bumps once, not M times.
+CREATE TRIGGER credential_health_config_version_del
+  AFTER DELETE ON credential_health
+  FOR EACH STATEMENT EXECUTE FUNCTION bump_config_version();
+`;
+
 // packages/store/src/postgres/db.ts
 var num = (v) => Number(v);
 var numOrNull = (v) => v === null ? null : Number(v);
 var MIGRATION_LOCK = 7140641;
-var MIGRATIONS = [{ id: 1, sql: _001_init_default }];
+var MIGRATIONS = [
+  { id: 1, sql: _001_init_default },
+  { id: 2, sql: _002_health_measurements_default }
+];
 async function openPg(url2) {
   const sql = new SQL({ url: url2 });
   const conn = await sql.reserve();
@@ -20137,31 +20455,25 @@ function toHealth(r) {
     breakerState: r.breaker_state,
     consecutiveFailures: r.consecutive_failures,
     openedAt: numOrNull(r.opened_at),
-    rateLimitedUntil: numOrNull(r.rate_limited_until),
-    ewmaTtftMs: r.ewma_ttft_ms,
-    lastUsedAt: numOrNull(r.last_used_at)
+    rateLimitedUntil: numOrNull(r.rate_limited_until)
   };
 }
 var UPSERT_HEALTH = `INSERT INTO credential_health
    (credential_id, model, breaker_state, consecutive_failures, opened_at,
-    rate_limited_until, ewma_ttft_ms, last_used_at)
- VALUES ($1,$2,$3,$4,$5,$6,$7,$8)
+    rate_limited_until)
+ VALUES ($1,$2,$3,$4,$5,$6)
  ON CONFLICT (credential_id, model) DO UPDATE SET
    breaker_state = EXCLUDED.breaker_state,
    consecutive_failures = EXCLUDED.consecutive_failures,
    opened_at = EXCLUDED.opened_at,
-   rate_limited_until = EXCLUDED.rate_limited_until,
-   ewma_ttft_ms = EXCLUDED.ewma_ttft_ms,
-   last_used_at = EXCLUDED.last_used_at`;
+   rate_limited_until = EXCLUDED.rate_limited_until`;
 var healthValues = (r) => [
   r.credentialId,
   r.model,
   r.breakerState,
   r.consecutiveFailures,
   r.openedAt,
-  r.rateLimitedUntil,
-  r.ewmaTtftMs,
-  r.lastUsedAt
+  r.rateLimitedUntil
 ];
 function createCredentialRepo(sql, key, emit2) {
   const open2 = async (v) => v === null ? null : decrypt(key, v);
@@ -20354,13 +20666,6 @@ function createCredentialRepo(sql, key, emit2) {
       const rows = await sql.unsafe("SELECT * FROM credential_health");
       return rows.map(toHealth);
     },
-    async saveHealth(rows) {
-      await sql.begin(async (tx) => {
-        for (const r of rows)
-          await tx.unsafe(UPSERT_HEALTH, healthValues(r));
-      });
-      emit2({ type: "healthSaved", rows });
-    },
     async updateHealth(credentialId, model, apply) {
       const written = await sql.begin(async (tx) => {
         await tx.unsafe("SELECT pg_advisory_xact_lock(hashtext($1))", [`${credentialId}|${model}`]);
@@ -20860,229 +21165,6 @@ function isRtkFilterId(value) {
   return FILTER_IDS.has(value);
 }
 
-// packages/store/src/sqlite/rollup.ts
-var HOUR_MS = 3600000;
-function hourOf(at) {
-  return Math.floor(at / HOUR_MS);
-}
-function startOfLocalDay(at) {
-  const day = new Date(at);
-  day.setHours(0, 0, 0, 0);
-  return day.getTime();
-}
-var UPSERT = `
-  INSERT INTO usage_daily
-    (day, provider, credential_id, requested_model, resolved_model, api_key_id,
-     requests, errors, input_tokens, output_tokens, cache_read_tokens,
-     cache_write_tokens, rtk_saved_tokens, rtk_applied_requests, cost_usd, duration_ms_sum)
-  VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
-  ON CONFLICT (day, provider, credential_id, requested_model, resolved_model, api_key_id)
-  DO UPDATE SET
-    requests           = requests + excluded.requests,
-    errors             = errors + excluded.errors,
-    input_tokens       = input_tokens + excluded.input_tokens,
-    output_tokens      = output_tokens + excluded.output_tokens,
-    cache_read_tokens  = cache_read_tokens + excluded.cache_read_tokens,
-    cache_write_tokens    = cache_write_tokens + excluded.cache_write_tokens,
-    rtk_saved_tokens      = rtk_saved_tokens + excluded.rtk_saved_tokens,
-    rtk_applied_requests  = rtk_applied_requests + excluded.rtk_applied_requests,
-    cost_usd              = cost_usd + excluded.cost_usd,
-    duration_ms_sum    = duration_ms_sum + excluded.duration_ms_sum`;
-function keyOf(log) {
-  return [
-    startOfLocalDay(log.at),
-    log.resolvedProvider ?? "",
-    log.credentialId ?? "",
-    log.requestedModel,
-    log.resolvedModel ?? "",
-    log.apiKeyId ?? ""
-  ];
-}
-function countersOf(log) {
-  return {
-    requests: 1,
-    errors: log.status >= 400 ? 1 : 0,
-    inputTokens: log.inputTokens,
-    outputTokens: log.outputTokens,
-    cacheReadTokens: log.cacheReadTokens,
-    cacheWriteTokens: log.cacheWriteTokens,
-    rtkSavedTokens: log.rtkEstimatedTokensSaved,
-    rtkAppliedRequests: log.rtkApplied ? 1 : 0,
-    costUsd: log.costUsd,
-    durationMsSum: log.durationMs
-  };
-}
-function upsert(db, key, c) {
-  db.run(UPSERT, [
-    ...key,
-    c.requests,
-    c.errors,
-    c.inputTokens,
-    c.outputTokens,
-    c.cacheReadTokens,
-    c.cacheWriteTokens,
-    c.rtkSavedTokens,
-    c.rtkAppliedRequests,
-    c.costUsd,
-    c.durationMsSum
-  ]);
-}
-function rollupLog(db, log) {
-  upsert(db, keyOf(log), countersOf(log));
-}
-function backfillDaily(db) {
-  const groups = new Map;
-  for (const row of db.query(`SELECT at, api_key_id, requested_model, resolved_provider, resolved_model, credential_id,
-              status, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
-              duration_ms, cost_usd
-         FROM request_logs`).all()) {
-    const key = [
-      startOfLocalDay(row.at),
-      row.resolved_provider ?? "",
-      row.credential_id ?? "",
-      row.requested_model,
-      row.resolved_model ?? "",
-      row.api_key_id ?? ""
-    ];
-    const id = key.join("\x00");
-    const seen = groups.get(id);
-    const counters = seen?.counters ?? {
-      requests: 0,
-      errors: 0,
-      inputTokens: 0,
-      outputTokens: 0,
-      cacheReadTokens: 0,
-      cacheWriteTokens: 0,
-      rtkSavedTokens: 0,
-      rtkAppliedRequests: 0,
-      costUsd: 0,
-      durationMsSum: 0
-    };
-    counters.requests += 1;
-    counters.errors += row.status >= 400 ? 1 : 0;
-    counters.inputTokens += row.input_tokens;
-    counters.outputTokens += row.output_tokens;
-    counters.cacheReadTokens += row.cache_read_tokens;
-    counters.cacheWriteTokens += row.cache_write_tokens;
-    counters.costUsd += row.cost_usd;
-    counters.durationMsSum += row.duration_ms;
-    if (seen === undefined)
-      groups.set(id, { key, counters });
-  }
-  for (const group of groups.values())
-    upsert(db, group.key, group.counters);
-  return groups.size;
-}
-var HOURLY_UPSERT = `
-  INSERT INTO usage_rollup
-    (api_key_id, hour, requests, input_tokens, output_tokens,
-     cache_read_tokens, cache_write_tokens, cost_usd)
-  VALUES (?,?,?,?,?,?,?,?)
-  ON CONFLICT (api_key_id, hour)
-  DO UPDATE SET
-    requests           = requests + excluded.requests,
-    input_tokens       = input_tokens + excluded.input_tokens,
-    output_tokens      = output_tokens + excluded.output_tokens,
-    cache_read_tokens  = cache_read_tokens + excluded.cache_read_tokens,
-    cache_write_tokens = cache_write_tokens + excluded.cache_write_tokens,
-    cost_usd           = cost_usd + excluded.cost_usd`;
-function rollupHour(db, log) {
-  const apiKeyId = log.apiKeyId;
-  if (apiKeyId === null)
-    return;
-  db.run(HOURLY_UPSERT, [
-    apiKeyId,
-    hourOf(log.at),
-    1,
-    log.inputTokens,
-    log.outputTokens,
-    log.cacheReadTokens,
-    log.cacheWriteTokens,
-    log.costUsd
-  ]);
-}
-var REBUILD = `
-  INSERT INTO usage_rollup
-    (api_key_id, hour, requests, input_tokens, output_tokens,
-     cache_read_tokens, cache_write_tokens, cost_usd)
-  SELECT api_key_id,
-         CAST(at / 3600000 AS INTEGER),
-         COUNT(*),
-         COALESCE(SUM(input_tokens), 0),
-         COALESCE(SUM(output_tokens), 0),
-         COALESCE(SUM(cache_read_tokens), 0),
-         COALESCE(SUM(cache_write_tokens), 0),
-         COALESCE(SUM(cost_usd), 0)
-    FROM request_logs
-   WHERE state = 'done' AND api_key_id IS NOT NULL
-   GROUP BY api_key_id, CAST(at / 3600000 AS INTEGER)`;
-function rebuildRollup(db) {
-  db.run("DELETE FROM usage_rollup");
-  db.run(REBUILD);
-}
-function auditRollup(db) {
-  const row = db.query(`WITH truth AS (
-         SELECT api_key_id AS k,
-                CAST(at / 3600000 AS INTEGER) AS h,
-                COUNT(*) AS requests,
-                COALESCE(SUM(input_tokens), 0) AS input_tokens,
-                COALESCE(SUM(output_tokens), 0) AS output_tokens,
-                COALESCE(SUM(cache_read_tokens), 0) AS cache_read_tokens,
-                COALESCE(SUM(cache_write_tokens), 0) AS cache_write_tokens,
-                COALESCE(SUM(cost_usd), 0) AS cost_usd
-           FROM request_logs
-          WHERE state = 'done' AND api_key_id IS NOT NULL
-          GROUP BY k, h
-       )
-       SELECT (SELECT COUNT(*) FROM truth) AS buckets,
-              (SELECT COUNT(*)
-                 FROM truth
-                 LEFT JOIN usage_rollup r ON r.api_key_id = truth.k AND r.hour = truth.h
-                WHERE r.api_key_id IS NULL
-                   OR r.requests <> truth.requests
-                   OR r.input_tokens <> truth.input_tokens
-                   OR r.output_tokens <> truth.output_tokens
-                   OR r.cache_read_tokens <> truth.cache_read_tokens
-                   OR r.cache_write_tokens <> truth.cache_write_tokens
-                   OR ABS(r.cost_usd - truth.cost_usd) > 1e-9 + ABS(truth.cost_usd) * 1e-9
-              ) AS mismatched,
-              (SELECT COUNT(*)
-                 FROM usage_rollup r
-                 LEFT JOIN truth ON r.api_key_id = truth.k AND r.hour = truth.h
-                WHERE truth.k IS NULL
-              ) AS orphans`).get();
-  const buckets = row?.buckets ?? 0;
-  const mismatched = (row?.mismatched ?? 0) + (row?.orphans ?? 0);
-  return { buckets, mismatched, ok: mismatched === 0 };
-}
-function backfillRtkUsage(db) {
-  const groups = new Map;
-  for (const row of db.query(`SELECT at, api_key_id, requested_model, resolved_provider, resolved_model, credential_id,
-              rtk_applied, rtk_estimated_tokens_saved
-         FROM request_logs
-        WHERE state = 'done'`).all()) {
-    const key = [
-      startOfLocalDay(row.at),
-      row.resolved_provider ?? "",
-      row.credential_id ?? "",
-      row.requested_model,
-      row.resolved_model ?? "",
-      row.api_key_id ?? ""
-    ];
-    const id = key.join("\x00");
-    const group = groups.get(id) ?? { key, saved: 0, applied: 0 };
-    group.saved += row.rtk_estimated_tokens_saved;
-    group.applied += row.rtk_applied === 1 ? 1 : 0;
-    groups.set(id, group);
-  }
-  for (const { key, saved, applied } of groups.values()) {
-    db.run(`UPDATE usage_daily
-          SET rtk_saved_tokens = ?, rtk_applied_requests = ?
-        WHERE day = ? AND provider = ? AND credential_id = ? AND requested_model = ?
-          AND resolved_model = ? AND api_key_id = ?`, [saved, applied, ...key]);
-  }
-}
-
 // packages/store/src/postgres/rollup.ts
 var DAILY_UPSERT = `
   INSERT INTO usage_daily
@@ -21102,9 +21184,9 @@ var DAILY_UPSERT = `
     rtk_applied_requests = usage_daily.rtk_applied_requests + EXCLUDED.rtk_applied_requests,
     cost_usd             = usage_daily.cost_usd + EXCLUDED.cost_usd,
     duration_ms_sum      = usage_daily.duration_ms_sum + EXCLUDED.duration_ms_sum`;
-async function rollupLog2(conn, log) {
+async function rollupLog2(conn, log, dayOffsetMinutes) {
   await conn.unsafe(DAILY_UPSERT, [
-    startOfLocalDay(log.at),
+    startOfDay(log.at, dayOffsetMinutes),
     log.resolvedProvider ?? "",
     log.credentialId ?? "",
     log.requestedModel,
@@ -21348,7 +21430,7 @@ var sum = (row) => ({
   tokens: row === undefined ? 0 : num(row.tokens),
   costUsd: row === undefined ? 0 : row.cost_usd
 });
-function createUsageRepo(sql, nodeId) {
+function createUsageRepo(sql, nodeId, dayOffsetMinutes) {
   const complete = async (conn, log) => {
     const written = (await conn.unsafe(COMPLETE, values(log, "done", nodeId))).count;
     if (written === 0)
@@ -21356,7 +21438,7 @@ function createUsageRepo(sql, nodeId) {
     const stored = (await conn.unsafe("SELECT * FROM request_logs WHERE id = $1", [log.id]))[0];
     if (stored !== undefined) {
       const restored = toLog(stored);
-      await rollupLog2(conn, restored);
+      await rollupLog2(conn, restored, dayOffsetMinutes);
       await rollupHour2(conn, restored);
     }
   };
@@ -21387,6 +21469,10 @@ function createUsageRepo(sql, nodeId) {
       ]) : await sql.unsafe("SELECT * FROM request_logs WHERE api_key_id = $1 ORDER BY at DESC LIMIT $2", [apiKeyId, limit]);
       return rows.map(toLog);
     },
+    async lastUsedByCredential(credentialId) {
+      const rows = await sql.unsafe("SELECT MAX(at) AS at FROM request_logs WHERE credential_id = $1", [credentialId]);
+      return numOrNull(rows[0]?.at ?? null);
+    },
     async scan(cursor, limit) {
       const rows = cursor === null ? await sql.unsafe("SELECT * FROM request_logs ORDER BY at, id LIMIT $1", [
         limit
@@ -21449,7 +21535,7 @@ function createUsageRepo(sql, nodeId) {
       const daily = grain === "daily";
       const key = columnFor(grain, q.groupBy);
       const split = q.splitBy === undefined ? null : columnFor(grain, q.splitBy);
-      const since = daily ? startOfLocalDay(q.since) : q.since;
+      const since = daily ? startOfDay(q.since, dayOffsetMinutes) : q.since;
       const until = q.until ?? Number.MAX_SAFE_INTEGER;
       const timeColumn = daily ? "day" : "at";
       const scope = q.apiKeyId;
@@ -21525,6 +21611,7 @@ function redacted(url2) {
 async function createPostgresStore(opts) {
   const logger2 = opts.logger ?? noopLogger;
   const nodeId = opts.nodeId ?? crypto.randomUUID();
+  const dayOffsetMinutes = opts.dayOffsetMinutes ?? hostDayOffsetMinutes();
   const listeners = new Set;
   const emit2 = (change) => {
     for (const listener of listeners) {
@@ -21556,7 +21643,7 @@ async function createPostgresStore(opts) {
     credentials: createCredentialRepo(sql, opts.encryptionKey, emit2),
     config: createConfigRepo(sql, emit2),
     keys: createKeyRepo(sql, logger2),
-    usage: createUsageRepo(sql, nodeId),
+    usage: createUsageRepo(sql, nodeId, dayOffsetMinutes),
     bodies: createBodyRepo(sql, opts.encryptionKey),
     maintenance: createMaintenanceRepo(sql, nodeId),
     plugins: createPluginRepo(sql),
@@ -21793,22 +21880,18 @@ function toHealth2(r) {
     breakerState: r.breaker_state,
     consecutiveFailures: r.consecutive_failures,
     openedAt: r.opened_at,
-    rateLimitedUntil: r.rate_limited_until,
-    ewmaTtftMs: r.ewma_ttft_ms,
-    lastUsedAt: r.last_used_at
+    rateLimitedUntil: r.rate_limited_until
   };
 }
 var UPSERT_HEALTH2 = `INSERT INTO credential_health
    (credential_id, model, breaker_state, consecutive_failures, opened_at,
-    rate_limited_until, ewma_ttft_ms, last_used_at)
- VALUES (?,?,?,?,?,?,?,?)
+    rate_limited_until)
+ VALUES (?,?,?,?,?,?)
  ON CONFLICT (credential_id, model) DO UPDATE SET
    breaker_state = excluded.breaker_state,
    consecutive_failures = excluded.consecutive_failures,
    opened_at = excluded.opened_at,
-   rate_limited_until = excluded.rate_limited_until,
-   ewma_ttft_ms = excluded.ewma_ttft_ms,
-   last_used_at = excluded.last_used_at`;
+   rate_limited_until = excluded.rate_limited_until`;
 function createCredentialRepo2(db, key, emit2 = () => {}) {
   const open2 = async (v) => v === null ? null : decrypt(key, v);
   const secretsFrom = async (row) => ({
@@ -21991,22 +22074,13 @@ function createCredentialRepo2(db, key, emit2 = () => {}) {
     async listHealth() {
       return db.query("SELECT * FROM credential_health").all().map(toHealth2);
     },
-    async saveHealth(rows) {
-      const stmt = db.prepare(UPSERT_HEALTH2);
-      db.transaction(() => {
-        for (const r of rows) {
-          stmt.run(r.credentialId, r.model, r.breakerState, r.consecutiveFailures, r.openedAt, r.rateLimitedUntil, r.ewmaTtftMs, r.lastUsedAt);
-        }
-      })();
-      emit2({ type: "healthSaved", rows });
-    },
     async updateHealth(credentialId, model, apply) {
       const current = db.prepare("SELECT * FROM credential_health WHERE credential_id = ? AND model = ?");
       const stmt = db.prepare(UPSERT_HEALTH2);
       const written = db.transaction(() => {
         const row = current.get(credentialId, model);
         const next = apply(row === null ? null : toHealth2(row));
-        stmt.run(next.credentialId, next.model, next.breakerState, next.consecutiveFailures, next.openedAt, next.rateLimitedUntil, next.ewmaTtftMs, next.lastUsedAt);
+        stmt.run(next.credentialId, next.model, next.breakerState, next.consecutiveFailures, next.openedAt, next.rateLimitedUntil);
         return next;
       })();
       emit2({ type: "healthSaved", rows: [written] });
@@ -22569,6 +22643,34 @@ CREATE TABLE nodes (
 ALTER TABLE credentials ADD COLUMN token_version INTEGER NOT NULL DEFAULT 0;
 `;
 
+// packages/store/src/sqlite/migrations/013_health_measurements.sql
+var _013_health_measurements_default = `-- DEPLOY HAZARD \u2014 read before upgrading an install that is still serving.
+--
+-- This migration drops two columns that every gateway before it writes on
+-- the success path (\`UPSERT_HEALTH\` names \`ewma_ttft_ms\` and \`last_used_at\`).
+-- SQLite is single-process, so the hazard is the rollback, not the rollout: an
+-- older gateway started against this database fails every successful request
+-- after the upstream call has completed and been billed \u2014 content frames out,
+-- then an aborted connection with no terminal frame. Rolling back the binary
+-- does not roll back the schema. The only way back is a snapshot taken before
+-- the upgrade. Deliberate: kept as a drop, not expand/contract, on the
+-- operator's decision \u2014 see the write-path spec.
+--
+-- \`credential_health\` keeps decisions, not measurements.
+--
+-- \`ewma_ttft_ms\` and \`last_used_at\` were written on every successful request,
+-- and a success that changes nothing else now writes nothing. Both live in the
+-- gateway's process-local \`loadRegistry\` instead: latency is a property of
+-- *this* process's path to the provider, and the round-robin tiebreak reads
+-- the value the process holds. The console's "last used" reads
+-- \`request_logs\` through \`usage.lastUsedByCredential\`, served by
+-- \`idx_request_logs_cred\`.
+--
+-- Neither column is indexed or constrained, so \`DROP COLUMN\` is permitted.
+ALTER TABLE credential_health DROP COLUMN ewma_ttft_ms;
+ALTER TABLE credential_health DROP COLUMN last_used_at;
+`;
+
 // packages/store/src/sqlite/db.ts
 var MIGRATIONS2 = [
   { id: 1, sql: _001_init_default2 },
@@ -22582,9 +22684,15 @@ var MIGRATIONS2 = [
   { id: 9, sql: _009_key_limits_default },
   { id: 10, sql: _010_usage_rollup_default, after: rebuildRollup },
   { id: 11, sql: _011_plugin_migrations_default },
-  { id: 12, sql: _012_nodes_default }
+  { id: 12, sql: _012_nodes_default },
+  { id: 13, sql: _013_health_measurements_default }
 ];
-function openDb(path) {
+function statements(sql) {
+  return sql.split(`
+`).filter((line) => !line.trimStart().startsWith("--")).join(`
+`).split(/;[ \t]*(?:\n|$)/).map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function openDb(path, dayOffsetMinutes = hostDayOffsetMinutes()) {
   const db = new Database(path, { create: true });
   db.run("PRAGMA journal_mode = WAL");
   db.run("PRAGMA synchronous = NORMAL");
@@ -22596,8 +22704,9 @@ function openDb(path) {
     if (done.has(m.id))
       continue;
     db.transaction(() => {
-      db.run(m.sql);
-      m.after?.(db);
+      for (const statement of statements(m.sql))
+        db.run(statement);
+      m.after?.(db, dayOffsetMinutes);
       db.run("INSERT INTO migrations (id, applied_at) VALUES (?, ?)", [m.id, Date.now()]);
     })();
   }
@@ -23014,14 +23123,14 @@ var COMPLETE2 = `INSERT INTO request_logs ${COLUMNS2} VALUES ${PLACEHOLDERS2}
     rtk_estimated_tokens_saved = excluded.rtk_estimated_tokens_saved,
     rtk_filters = excluded.rtk_filters
   WHERE request_logs.state = 'pending'`;
-function createUsageRepo2(db, nodeId) {
+function createUsageRepo2(db, nodeId, dayOffsetMinutes = hostDayOffsetMinutes()) {
   const complete = db.transaction((log) => {
     if (db.run(COMPLETE2, values2(log, "done", nodeId)).changes === 0)
       return;
     const stored = db.query("SELECT * FROM request_logs WHERE id = ?").get(log.id);
     if (stored !== null) {
       const restored = toLog2(stored);
-      rollupLog(db, restored);
+      rollupLog(db, restored, dayOffsetMinutes);
       rollupHour(db, restored);
     }
   });
@@ -23071,6 +23180,10 @@ function createUsageRepo2(db, nodeId) {
       }
       return db.query("SELECT * FROM request_logs WHERE api_key_id = ? ORDER BY at DESC LIMIT ?").all(apiKeyId, limit).map(toLog2);
     },
+    async lastUsedByCredential(credentialId) {
+      const row = db.query("SELECT MAX(at) AS at FROM request_logs WHERE credential_id = ?").get(credentialId);
+      return row?.at ?? null;
+    },
     async scan(cursor, limit) {
       const rows = cursor === null ? db.query("SELECT * FROM request_logs ORDER BY at, id LIMIT ?").all(limit) : db.query(`SELECT * FROM request_logs
                   WHERE at > ? OR (at = ? AND id > ?)
@@ -23132,7 +23245,7 @@ function createUsageRepo2(db, nodeId) {
       const daily = grain === "daily";
       const key = columnFor2(grain, q.groupBy);
       const split = q.splitBy === undefined ? null : columnFor2(grain, q.splitBy);
-      const since = daily ? startOfLocalDay(q.since) : q.since;
+      const since = daily ? startOfDay(q.since, dayOffsetMinutes) : q.since;
       const until = q.until ?? Number.MAX_SAFE_INTEGER;
       const timeColumn = daily ? "day" : "at";
       const scope = q.apiKeyId;
@@ -23183,6 +23296,7 @@ function createUsageRepo2(db, nodeId) {
 async function createStore(opts) {
   const logger2 = opts.logger ?? noopLogger;
   const nodeId = opts.nodeId ?? crypto.randomUUID();
+  const dayOffsetMinutes = opts.dayOffsetMinutes ?? hostDayOffsetMinutes();
   const listeners = new Set;
   const emit2 = (change) => {
     for (const listener of listeners) {
@@ -23192,14 +23306,14 @@ async function createStore(opts) {
     }
   };
   const open2 = () => {
-    const db = openDb(opts.path);
+    const db = openDb(opts.path, dayOffsetMinutes);
     logger2.debug("store opened", { path: opts.path });
     return {
       db,
       credentials: createCredentialRepo2(db, opts.encryptionKey, emit2),
       config: createConfigRepo2(db, emit2),
       keys: createKeyRepo2(db, logger2),
-      usage: createUsageRepo2(db, nodeId),
+      usage: createUsageRepo2(db, nodeId, dayOffsetMinutes),
       bodies: createBodyRepo2(db, opts.encryptionKey, bodiesDirFor(opts.path)),
       maintenance: createMaintenanceRepo2(db, nodeId),
       plugins: createPluginRepo2(db)
@@ -23225,7 +23339,6 @@ async function createStore(opts) {
       updateSecrets: (id, secrets, expiresAt, expectedVersion) => handle.credentials.updateSecrets(id, secrets, expiresAt, expectedVersion),
       remove: (id) => handle.credentials.remove(id),
       listHealth: () => handle.credentials.listHealth(),
-      saveHealth: (rows) => handle.credentials.saveHealth(rows),
       updateHealth: (id, model, apply) => handle.credentials.updateHealth(id, model, apply),
       listQuota: () => handle.credentials.listQuota(),
       saveQuota: (rows) => handle.credentials.saveQuota(rows),
@@ -23260,6 +23373,7 @@ async function createStore(opts) {
       append: (log) => handle.usage.append(log),
       sweepPending: (now) => handle.usage.sweepPending(now),
       recent: (limit, apiKeyId) => handle.usage.recent(limit, apiKeyId),
+      lastUsedByCredential: (credentialId) => handle.usage.lastUsedByCredential(credentialId),
       scan: (cursor, limit) => handle.usage.scan(cursor, limit),
       aggregate: (q) => handle.usage.aggregate(q),
       sumSince: (apiKeyId, sinceMs) => handle.usage.sumSince(apiKeyId, sinceMs),
@@ -24138,6 +24252,7 @@ var PROVIDER_IDS = Object.keys(PROVIDER_DESCRIPTORS);
 var MIN_KEY_LENGTH = 16;
 var TRUTHY = new Set(["1", "true", "yes", "on"]);
 var DECIMAL_INTEGER = /^\d+$/;
+var SIGNED_INTEGER = /^-?\d+$/;
 function optionalText(value, fallback) {
   return value?.trim() || fallback;
 }
@@ -24168,6 +24283,11 @@ function loadConfig(env) {
   } else if (databaseUrl !== undefined || redisUrl !== undefined) {
     throw new Error("OMNI_DATABASE_URL and OMNI_REDIS_URL are cluster-mode settings; set OMNI_CLUSTER_MODE=true or unset them");
   }
+  const rawDayOffset = env.OMNI_DAY_OFFSET_MINUTES?.trim();
+  const parsedDayOffset = rawDayOffset === undefined ? NaN : Number(rawDayOffset);
+  const validDayOffset = rawDayOffset !== undefined && SIGNED_INTEGER.test(rawDayOffset) && Number.isInteger(parsedDayOffset) && parsedDayOffset >= -1440 && parsedDayOffset <= 1440;
+  const dayOffsetMinutes = validDayOffset ? parsedDayOffset : hostDayOffsetMinutes();
+  const dayOffsetFallbackFrom = rawDayOffset !== undefined && !validDayOffset ? rawDayOffset : null;
   const bodyLoggingAllowed = TRUTHY.has((env.OMNI_BODY_LOGGING_ALLOWED ?? "").trim().toLowerCase());
   const rawLogLevel = env.OMNI_LOG_LEVEL?.trim();
   const logLevel = parseLogLevel(rawLogLevel);
@@ -24198,6 +24318,8 @@ function loadConfig(env) {
     clusterMode,
     databaseUrl: clusterMode ? databaseUrl ?? null : null,
     redisUrl: clusterMode ? redisUrl ?? null : null,
+    dayOffsetMinutes,
+    dayOffsetFallbackFrom,
     metricsToken,
     metricsMaxSeries,
     otlpEndpoint,
@@ -31185,6 +31307,7 @@ function eligible(input2) {
         drop("expired");
         continue;
       }
+      let probe = false;
       const h = snapshot.health.get(healthKey(credential.id, target.model));
       if (h !== undefined) {
         if (h.rateLimitedUntil !== null && h.rateLimitedUntil > now) {
@@ -31197,6 +31320,9 @@ function eligible(input2) {
             drop("breaker:open");
             continue;
           }
+          probe = true;
+        } else if (h.breakerState === "halfOpen") {
+          probe = true;
         }
       }
       const spent = (snapshot.quota.get(credential.id) ?? []).find((w) => w.limit !== null && w.used >= w.limit && (w.resetsAt === null || w.resetsAt > now));
@@ -31204,7 +31330,7 @@ function eligible(input2) {
         drop(`quota:${spent.windowType}`);
         continue;
       }
-      pairs.push({ credential, target });
+      pairs.push({ credential, target, probe });
     }
     if (target.credentialId === undefined && providerSeen && !servedAny) {
       excluded.push({
@@ -31281,7 +31407,7 @@ function healthScore(h) {
   return h?.breakerState === "open" || h?.breakerState === "halfOpen" ? base * 0.5 : base;
 }
 function score(pairs, input2) {
-  const { snapshot, now, load } = input2;
+  const { snapshot, now, load, recent } = input2;
   const w = snapshot.settings.weights;
   const tiers = pairs.map((p) => p.target.tier);
   const minTier = Math.min(...tiers);
@@ -31289,9 +31415,10 @@ function score(pairs, input2) {
   const tokens2 = estimateTokens(input2.request);
   const costs = pairs.map((p) => requestCost(p.target, tokens2));
   const bestCost = bestPositive(costs);
+  const ewmaOf = (key) => recent?.get(key)?.ewmaTtftMs ?? null;
   const bestLatency = bestPositive(pairs.flatMap((p) => {
-    const h = snapshot.health.get(healthKey(p.credential.id, p.target.model));
-    return h?.ewmaTtftMs != null ? [h.ewmaTtftMs] : [];
+    const ewma = ewmaOf(healthKey(p.credential.id, p.target.model));
+    return ewma === null ? [] : [ewma];
   }));
   return pairs.map((pair, i) => {
     const key = healthKey(pair.credential.id, pair.target.model);
@@ -31303,12 +31430,14 @@ function score(pairs, input2) {
     const quota = quotaHeadroom(pair.credential, snapshot.quota.get(pair.credential.id) ?? [], now, snapshot.settings.quotaPollIntervalMs);
     const ownCost = costs[i];
     const cost = ownCost <= 0 || bestCost === null ? UNKNOWN : ratio(ownCost, bestCost);
-    const latency = h?.ewmaTtftMs == null || h.ewmaTtftMs <= 0 || bestLatency === null ? UNKNOWN : ratio(h.ewmaTtftMs, bestLatency);
+    const ewma = ewmaOf(key);
+    const latency = ewma === null || ewma <= 0 || bestLatency === null ? UNKNOWN : ratio(ewma, bestLatency);
     const reasons = { tier, health, quota, cost, latency, load: loadTerm };
     const base = tier * w.tier + health * w.health + quota * w.quota + cost * w.cost + latency * w.latency + loadTerm * w.load;
     return {
       credential: pair.credential,
       target: pair.target,
+      probe: pair.probe,
       score: base * pair.credential.weight * pair.target.weight,
       reasons
     };
@@ -31348,8 +31477,8 @@ function rank(input2) {
       break;
     case "roundRobin": {
       const idle = (c) => {
-        const h = input2.snapshot.health.get(healthKey(c.credential.id, c.target.model));
-        return h?.lastUsedAt == null ? Number.POSITIVE_INFINITY : input2.now - h.lastUsedAt;
+        const at = input2.recent?.get(healthKey(c.credential.id, c.target.model))?.lastReleasedAt;
+        return at === undefined ? Number.POSITIVE_INFINITY : input2.now - at;
       };
       const spent = (c) => headroom(c) < QUOTA_FLOOR ? 1 : 0;
       scored.sort((a, b) => spent(a) - spent(b) || inflight(a) - inflight(b) || idle(b) - idle(a));
@@ -31521,16 +31650,23 @@ async function refreshCredential(deps, id) {
   return getCredential(deps.store, id);
 }
 async function credentialHealth(deps) {
-  const [health, quota, settings] = await Promise.all([
+  const [health, quota, settings, credentials] = await Promise.all([
     deps.store.credentials.listHealth(),
     deps.store.credentials.listQuota(),
-    deps.store.config.getSettings()
+    deps.store.config.getSettings(),
+    deps.store.credentials.list()
   ]);
+  const lastUsed = {};
+  for (const c of credentials) {
+    const at = await deps.store.usage.lastUsedByCredential(c.id);
+    if (at !== null)
+      lastUsed[c.id] = at;
+  }
   const burn = burnEstimates(quota, {
     now: deps.now(),
     pollIntervalMs: settings.quotaPollIntervalMs
   });
-  return { health, quota, burn };
+  return { health, quota, burn, lastUsed };
 }
 async function credentialStatus(store, options) {
   const [credentials, quota, adminConfigured] = await Promise.all([
@@ -31644,14 +31780,14 @@ function listSnapshots(deps) {
   }
   return snapshots.sort((a, b) => b.createdAt - a.createdAt);
 }
-var DAY_MS = 86400000;
+var DAY_MS2 = 86400000;
 var SNAPSHOT_HEADROOM = 1.1;
 function retentionOf(settings) {
   return { keepLatest: settings.snapshotKeepLatest, maxAgeDays: settings.snapshotMaxAgeDays };
 }
 function applyRetention(deps, policy, now) {
   const dir = snapshotsDir(deps);
-  const cutoff = now - policy.maxAgeDays * DAY_MS;
+  const cutoff = now - policy.maxAgeDays * DAY_MS2;
   const snapshots = listSnapshots(deps);
   const undo = snapshots.find((snapshot) => snapshot.reason === "preRestore")?.id;
   let removed = 0;
@@ -33476,12 +33612,12 @@ function readsNothing(scope) {
   return scope.kind === "none" || scope.kind === "key" && scope.apiKeyId === "";
 }
 // packages/control/src/quota/history.ts
-var DAY_MS2 = 24 * 60 * 60 * 1000;
+var DAY_MS3 = 24 * 60 * 60 * 1000;
 var HOUR_MS3 = 3600000;
 async function retainedSpan(deps, input2, maxSpanMs) {
   const now = deps.now();
   const settings = await deps.store.config.getSettings();
-  const retained = now - settings.logRetentionDays * DAY_MS2;
+  const retained = now - settings.logRetentionDays * DAY_MS3;
   const oldest = maxSpanMs === undefined ? retained : Math.max(retained, now - maxSpanMs);
   return {
     since: Math.max(optionalNumber(input2.since, oldest), oldest),
@@ -33924,7 +34060,11 @@ function createContext(parsed2, options = {}) {
         const current = config2;
         if (current === null)
           throw new CliError(configError ?? "invalid configuration");
-        opened = deriveKey(current.encryptionKey).then((key) => createStore({ path: databasePath, encryptionKey: key })).then((created) => {
+        opened = deriveKey(current.encryptionKey).then((key) => createStore({
+          path: databasePath,
+          encryptionKey: key,
+          dayOffsetMinutes: current.dayOffsetMinutes
+        })).then((created) => {
           store = created;
           return created;
         });
@@ -34775,17 +34915,17 @@ var credentialsAddKey = {
 };
 var credentialsHealth = {
   usage: "credentials health",
-  summary: "Show breaker state and latency per credential and model",
+  summary: "Show breaker state per credential and model",
   options: { all: { type: "boolean" } },
   async run(args, { ctx, writer }) {
     const store = await ctx.store();
-    const [{ health: rows }, credentials] = await Promise.all([
+    const [{ health: rows, lastUsed }, credentials] = await Promise.all([
       credentialHealth({ store, now: ctx.now }),
       listCredentials(store)
     ]);
     const labels = new Map(credentials.map((c) => [c.id, c.label]));
     const shown = boolFlag(args.values, "all") ? rows : rows.filter((r) => r.breakerState !== "closed" || r.consecutiveFailures > 0);
-    emit(ctx, writer, { health: rows }, () => {
+    emit(ctx, writer, { health: rows, lastUsed }, () => {
       if (shown.length === 0)
         return "every credential is healthy";
       return table([
@@ -34793,15 +34933,13 @@ var credentialsHealth = {
         { header: "MODEL" },
         { header: "BREAKER" },
         { header: "FAILS", align: "right" },
-        { header: "TTFT", align: "right" },
         { header: "LAST USED" }
       ], shown.map((row) => [
         labels.get(row.credentialId) ?? row.credentialId,
         row.model,
         state(ctx, row.breakerState === "closed", row.breakerState),
         String(row.consecutiveFailures),
-        row.ewmaTtftMs === null ? "\u2014" : `${Math.round(row.ewmaTtftMs)}ms`,
-        paint(ctx, "dim", formatTime(row.lastUsedAt))
+        paint(ctx, "dim", formatTime(lastUsed[row.credentialId] ?? null))
       ]));
     });
   }
@@ -34842,7 +34980,8 @@ var dbMigrate = {
       const source = await ctx.store();
       const target = await createPostgresStore({
         url: to,
-        encryptionKey: await deriveKey(ctx.config().encryptionKey)
+        encryptionKey: await deriveKey(ctx.config().encryptionKey),
+        dayOffsetMinutes: ctx.config().dayOffsetMinutes
       });
       try {
         const report = await copyStore(source, target);
@@ -35755,7 +35894,7 @@ function createServiceDeps(input2) {
 }
 
 // apps/cli/src/version.ts
-var VERSION = "0.10.3";
+var VERSION = "0.11.0";
 
 // apps/cli/src/commands/service.ts
 function gatewayArgv(root) {