@bytesbrains/cruise 0.0.0-stage → 0.12.0

package/dist/report-VRYJ3W5L.mjs

@@ -0,0 +1,414 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+import {
+  compressionSavings,
+  savedShare
+} from "./chunk-HQDQTXRX.mjs";
+import {
+  laneSavings
+} from "./chunk-42ERHAJD.mjs";
+import {
+  rescuesBy
+} from "./chunk-BNP63KB2.mjs";
+import "./chunk-SYTYOTO4.mjs";
+import "./chunk-O7TNRKSA.mjs";
+import "./chunk-T3ICD43U.mjs";
+import {
+  formatUsd
+} from "./chunk-THEXUHQC.mjs";
+import "./chunk-5TVD3ZAI.mjs";
+import {
+  connect,
+  environmentOf,
+  parseArgs,
+  run
+} from "./chunk-7NQHBXVZ.mjs";
+import "./chunk-JZPUTXM7.mjs";
+
+// src/report-cache.ts
+async function byLaneCache(db, month, tenantId) {
+  const { results } = await db.prepare(
+    `SELECT l.lane AS lane,
+              l.traffic_class AS trafficClass,
+              count(*) AS requests,
+              sum(CASE WHEN l.cache_status = 'HIT' AND l.cache_scope = 'model' THEN 1 ELSE 0 END) AS modelHits,
+              sum(CASE WHEN l.cache_status = 'HIT' AND l.cache_scope = 'lane' THEN 1 ELSE 0 END) AS laneHits
+         FROM ledger l
+        WHERE (?1 IS NULL OR strftime('%Y-%m', l.at) = ?1)
+          AND (?2 IS NULL OR l.tenant_id = ?2)
+          AND l.requested_model = l.lane
+          AND EXISTS (SELECT 1 FROM lanes ln WHERE ln.id = l.lane)
+        GROUP BY l.lane, l.traffic_class
+        ORDER BY l.lane, l.traffic_class`
+  ).bind(month, tenantId ?? null).all();
+  return results.map((row) => ({
+    ...row,
+    modelHitRate: row.requests > 0 ? row.modelHits / row.requests : null,
+    laneHitRate: row.requests > 0 ? row.laneHits / row.requests : null
+  }));
+}
+var VIOLATION_WINDOW_MINUTES = 10;
+async function tierViolations(db, month, tenantId, windowMinutes = VIOLATION_WINDOW_MINUTES) {
+  const { results } = await db.prepare(
+    `WITH hits AS (
+         SELECT id, rowid AS seq, tenant_id, lane, key_prefix, cache_digest, at
+           FROM ledger
+          WHERE cache_status = 'HIT' AND cache_scope = 'lane' AND cache_digest IS NOT NULL
+            AND (?1 IS NULL OR strftime('%Y-%m', at) = ?1)
+            AND (?2 IS NULL OR tenant_id = ?2)
+       )
+       SELECT h.lane AS lane,
+              count(*) AS laneHits,
+              sum(EXISTS (
+                SELECT 1 FROM ledger r
+                 WHERE r.tenant_id = h.tenant_id AND r.key_prefix = h.key_prefix AND r.cache_digest = h.cache_digest
+                   AND (r.at > h.at OR (r.at = h.at AND r.rowid > h.seq))
+                   AND (julianday(r.at) - julianday(h.at)) * 1440.0 <= ?3
+                   AND r.cache_requested IN ('off', 'model')
+              )) AS suspected
+         FROM hits h
+        GROUP BY h.lane
+        ORDER BY h.lane`
+  ).bind(month, tenantId ?? null, windowMinutes).all();
+  return results;
+}
+
+// src/report.ts
+async function observationWindow(db) {
+  const row = await db.prepare(
+    `SELECT min(at) AS firstAt, max(at) AS lastAt, count(*) AS requests,
+              CAST((julianday(max(at)) - julianday(min(at))) AS REAL) AS days
+         FROM ledger`
+  ).first();
+  return {
+    firstAt: row?.firstAt ?? null,
+    lastAt: row?.lastAt ?? null,
+    days: row?.days ?? 0,
+    requests: row?.requests ?? 0
+  };
+}
+async function byTrafficClass(db) {
+  const { results } = await db.prepare(
+    `SELECT traffic_class AS trafficClass,
+              count(*) AS requests,
+              sum(CASE WHEN cache_status = 'HIT' THEN 1 ELSE 0 END) AS hits,
+              sum(CASE WHEN streamed = 1 THEN 1 ELSE 0 END) AS streamedCount
+         FROM ledger
+        GROUP BY traffic_class
+        ORDER BY requests DESC`
+  ).all();
+  const rows = [];
+  for (const row of results) {
+    const timing = await db.prepare(
+      `SELECT
+           (SELECT CAST(avg(upstream_ms) AS INTEGER) FROM ledger
+             WHERE traffic_class = ?1 AND cache_status != 'HIT' AND upstream_ms IS NOT NULL) AS miss,
+           (SELECT CAST(avg(upstream_ms) AS INTEGER) FROM ledger
+             WHERE traffic_class = ?1 AND cache_status = 'HIT' AND upstream_ms IS NOT NULL) AS hit`
+    ).bind(row.trafficClass).first();
+    rows.push({
+      trafficClass: row.trafficClass,
+      requests: row.requests,
+      hits: row.hits,
+      hitRate: row.requests > 0 ? row.hits / row.requests : null,
+      streamedShare: row.requests > 0 ? row.streamedCount / row.requests : null,
+      medianMissMs: timing?.miss ?? null,
+      medianHitMs: timing?.hit ?? null
+    });
+  }
+  return rows;
+}
+async function byCacheScope(db) {
+  const { results } = await db.prepare(
+    `SELECT traffic_class AS trafficClass,
+              cache_scope AS scope,
+              count(*) AS hits,
+              COALESCE(sum(cost_micros), 0) AS micros,
+              COALESCE(sum(list_micros), 0) AS listMicros
+         FROM ledger
+        WHERE cache_scope IS NOT NULL
+        GROUP BY traffic_class, cache_scope
+        ORDER BY hits DESC`
+  ).all();
+  return results;
+}
+async function reasoningExhaustedSpend(db) {
+  const { results } = await db.prepare(
+    `SELECT model,
+              sum(CASE WHEN completion_tokens > 0 AND reasoning_tokens = completion_tokens THEN 1 ELSE 0 END) AS requests,
+              COALESCE(sum(CASE WHEN completion_tokens > 0 AND reasoning_tokens = completion_tokens THEN cost_micros ELSE 0 END), 0) AS micros,
+              count(*) AS empties
+         FROM ledger
+        WHERE outcome = 'empty'
+        GROUP BY model
+       HAVING requests > 0
+        ORDER BY micros DESC`
+  ).all();
+  return results;
+}
+async function fallbacks(db) {
+  const { results } = await db.prepare(
+    `SELECT requested_model AS requestedModel, model AS servedModel, count(*) AS times
+         FROM ledger
+        WHERE requested_model IS NOT NULL AND requested_model != model
+          -- A lane request always differs from what served; that is allocation,
+          -- not a chain firing, and has its own section (0027).
+          AND requested_model NOT LIKE 'bb/%'
+        GROUP BY requested_model, model
+        ORDER BY times DESC`
+  ).all();
+  return results;
+}
+async function priceProblems(db) {
+  const { results } = await db.prepare(
+    `SELECT m.id AS model,
+              CASE WHEN EXISTS (SELECT 1 FROM model_prices p WHERE p.model = m.id)
+                   THEN 'future' ELSE 'missing' END AS kind,
+              (SELECT min(p.effective_from) FROM model_prices p
+                WHERE p.model = m.id AND p.effective_from > date('now')) AS startsOn
+         FROM models m
+         JOIN upstreams u ON u.id = m.upstream_id
+        WHERE m.enabled = 1 AND u.enabled = 1
+          AND NOT EXISTS (
+                SELECT 1 FROM model_prices p
+                 WHERE p.model = m.id AND p.effective_from <= date('now'))
+          -- A speech row is priced by its character line, not a token row
+          -- (0059, src/billing-block.ts); read the log that holds it.
+          AND NOT (m.modality = 'speech' AND EXISTS (
+                SELECT 1 FROM model_components c
+                 WHERE c.model = m.id AND c.component = 'character'
+                   AND c.effective_from <= date('now')))
+        ORDER BY m.id`
+  ).all();
+  return results;
+}
+async function byProvider(db) {
+  const { results } = await db.prepare(
+    `SELECT upstream_id AS upstreamId,
+              count(*) AS requests,
+              COALESCE(sum(cost_micros), 0) AS micros,
+              sum(CASE WHEN http_status >= 500 THEN 1 ELSE 0 END) AS errors,
+              sum(CASE WHEN http_status = 429 THEN 1 ELSE 0 END) AS rateLimited
+         FROM ledger
+        GROUP BY upstream_id
+        ORDER BY micros DESC`
+  ).all();
+  return results;
+}
+var MIN_DAYS = 14;
+var MIN_REQUESTS = 1e3;
+function verdict(window) {
+  if (window.requests < MIN_REQUESTS) {
+    return {
+      sufficient: false,
+      why: `${window.requests} requests is below the ${MIN_REQUESTS} needed for any rate here to mean much.`
+    };
+  }
+  if (window.days < MIN_DAYS) {
+    return {
+      sufficient: false,
+      why: `${window.days.toFixed(1)} days is below the ${MIN_DAYS} needed to survive a weekly cycle.`
+    };
+  }
+  return { sufficient: true, why: `${window.requests} requests over ${window.days.toFixed(1)} days.` };
+}
+
+// src/selection.ts
+async function costPerCompleted(db, tenantId, since) {
+  const { results } = await db.prepare(
+    `SELECT model,
+              count(*) AS requests,
+              sum(CASE WHEN outcome = 'served' THEN 1 ELSE 0 END) AS completed,
+              COALESCE(sum(cost_micros), 0) AS micros
+         FROM ledger
+        WHERE tenant_id = ?1 AND at >= ?2
+        GROUP BY model
+        ORDER BY micros DESC`
+  ).bind(tenantId, since).all();
+  return results.map((row) => ({
+    model: row.model,
+    requests: row.requests,
+    completed: row.completed,
+    micros: row.micros,
+    microsPerCompleted: row.completed > 0 ? Math.round(row.micros / row.completed) : null,
+    completionRate: row.requests > 0 ? row.completed / row.requests : 0
+  }));
+}
+
+// scripts/report.ts
+var pct = (value) => value === null ? "-" : `${(value * 100).toFixed(1)}%`;
+var ms = (value) => value === null ? "-" : `${value}ms`;
+run(async () => {
+  const args = parseArgs(process.argv.slice(2));
+  const db = connect(environmentOf(args));
+  const window = await observationWindow(db);
+  const status = verdict(window);
+  console.log("Cruise \u2014 phase 1 measurement report\n");
+  console.log(`observation window   ${window.firstAt ?? "-"}  \u2192  ${window.lastAt ?? "-"}`);
+  console.log(`                     ${window.requests} requests over ${window.days.toFixed(1)} days`);
+  if (!status.sufficient) {
+    console.log(`
+  \u26A0  PROVISIONAL \u2014 ${status.why}`);
+    console.log("     No gate in v0.md \xA76 should be decided on this. The traffic that makes these");
+    console.log("     numbers real is the traffic this build releases.");
+  } else {
+    console.log(`
+  sufficient \u2014 ${status.why}`);
+  }
+  const classes = await byTrafficClass(db);
+  console.log("\n\ncache behaviour, by traffic class \u2014 never blended");
+  console.log("class          reqs    hit rate   streamed   miss TTFB   hit TTFB");
+  if (classes.length === 0) console.log("  (no traffic)");
+  for (const row of classes) {
+    console.log(
+      `${row.trafficClass.padEnd(14)} ${String(row.requests).padStart(4)}   ${pct(row.hitRate).padStart(8)}   ${pct(row.streamedShare).padStart(8)}   ${ms(row.medianMissMs).padStart(9)}   ${ms(row.medianHitMs).padStart(8)}`
+    );
+  }
+  console.log("\n  Scheduled pipelines re-run near-identical prompts by construction, so only");
+  console.log("  the interactive and agentic rows generalise to anyone else. A blended figure");
+  console.log("  would flatter us badly, which is why one is not printed.");
+  console.log("  One hit rate, not two: the platform caches streams (measured 2026-08-13), so");
+  console.log("  the served/shadow split v0.md \xA77 once required would now describe nothing.");
+  const scopes = await byCacheScope(db);
+  console.log("\n\ncache hits by scope and class \u2014 never blended");
+  console.log("class          scope     hits      charged        at list");
+  if (scopes.length === 0) console.log("  (nothing has been served from the cache)");
+  for (const row of scopes) {
+    console.log(
+      `${row.trafficClass.padEnd(14)} ${row.scope.padEnd(9)} ${String(row.hits).padStart(4)}   ${formatUsd(row.micros).padStart(10)}   ${formatUsd(row.listMicros).padStart(12)}`
+    );
+  }
+  const providers = await byProvider(db);
+  console.log("\n\nspend and reliability, by provider");
+  console.log("provider        reqs        spend    5xx    429");
+  if (providers.length === 0) console.log("  (no traffic)");
+  for (const row of providers) {
+    console.log(
+      `${row.upstreamId.padEnd(15)} ${String(row.requests).padStart(4)}  ${formatUsd(row.micros, 4).padStart(11)}  ${String(row.errors).padStart(5)}  ${String(row.rateLimited).padStart(5)}`
+    );
+  }
+  const completed = await costPerCompleted(db, "bytesbrains", "2000-01-01");
+  console.log("\n\ncost per completed request \u2014 what an answer actually costs");
+  console.log("model                                          reqs   done    spend   per done");
+  if (completed.length === 0) console.log("  (no traffic)");
+  for (const row of completed) {
+    console.log(
+      `${row.model.slice(0, 44).padEnd(45)} ${String(row.requests).padStart(4)}  ${pct(row.completionRate).padStart(5)}  ${formatUsd(row.micros, 4).padStart(9)}  ${(row.microsPerCompleted === null ? "never" : formatUsd(row.microsPerCompleted, 4)).padStart(9)}`
+    );
+  }
+  console.log(
+    "\n  `never` is a model that has completed nothing: unrankable rather than\n  merely expensive, and the spend beside it is real."
+  );
+  const exhausted = await reasoningExhaustedSpend(db);
+  console.log("\n\ncompletions that were entirely reasoning \u2014 billed, and nothing to show (#142)");
+  console.log("model                                          reqs   of empties      spend");
+  if (exhausted.length === 0) console.log("  none");
+  for (const row of exhausted) {
+    console.log(
+      `${row.model.slice(0, 44).padEnd(45)} ${String(row.requests).padStart(4)}   ${String(row.empties).padStart(10)}  ${formatUsd(row.micros, 4).padStart(9)}`
+    );
+  }
+  if (exhausted.length > 0) {
+    console.log("  An output budget too small for a reasoning model, or a lane allocating one to");
+    console.log("  requests it cannot finish. A unary response says so: x-cruise-warning: reasoning_exhausted.");
+  }
+  const priced = await priceProblems(db);
+  console.log("\n\nmodels whose spend is not being priced");
+  if (priced.length === 0) {
+    console.log("  none \u2014 every routable model has a price in force today");
+  }
+  for (const row of priced) {
+    console.log(
+      row.kind === "future" ? `  ${row.model}  \u2014 a price row exists but does not start until ${row.startsOn} (UTC)` : `  ${row.model}  \u2014 no price row at all; charged its full reservation`
+    );
+  }
+  if (priced.length > 0) {
+    console.log("  Until then these are billed at the reservation, which over-counts. A");
+    console.log("  future-dated row is the worse of the two: it looks like the work was done.");
+  }
+  const chains = await fallbacks(db);
+  console.log("\n\nfallback chains that fired");
+  if (chains.length === 0) {
+    console.log("  none \u2014 every request was served by the model it asked for");
+  }
+  for (const row of chains) {
+    console.log(`  ${row.requestedModel}  \u2192  ${row.servedModel}   ${row.times}\xD7`);
+  }
+  const month = (/* @__PURE__ */ new Date()).toISOString().slice(0, 7);
+  const rescues = await rescuesBy(db, { month });
+  console.log(`
+
+rescues \u2014 requests a failed model would have lost, ${month} (#647)`);
+  console.log(`  ${rescues.rescued} of ${rescues.requests} request(s) rescued, ${pct(rescues.rescued_share)}`);
+  for (const row of rescues.rows) {
+    console.log(`  ${row.lane.padEnd(26)} ${row.failed_model} (${row.failed_status ?? "no answer"})  \u2192  ${row.served_model}   ${row.rescued}\xD7`);
+  }
+  const compression = await compressionSavings(db);
+  console.log("\n\nrequest compression \u2014 bytes removed from tool outputs (#593)");
+  console.log("month    project                     reqs  applied      before       after   saved   billed in");
+  if (compression.length === 0) console.log("  (compression has not run \u2014 every project starts off, and COMPRESS_MODE gates it)");
+  for (const row of compression) {
+    console.log(
+      `${row.month}  ${row.projectId.slice(0, 26).padEnd(26)}${String(row.requests).padStart(6)}  ${String(row.applied).padStart(7)}  ${String(row.bytesBefore).padStart(10)}  ${String(row.bytesAfter).padStart(10)}  ${pct(savedShare(row)).padStart(6)}  ${String(row.promptTokens).padStart(10)}`
+    );
+  }
+  if (compression.length > 0) {
+    console.log("  Bytes of the body sent to the model that answered, built with and without compression.");
+    console.log("  'billed in' is the provider's prompt tokens, which are already the after figure.");
+  }
+  const lanes = await laneSavings(db, null);
+  console.log("\n\nlanes \u2014 what allocating by price saved (0027)");
+  console.log("lane                  reqs  members      spent   vs dearest   vs first-listed");
+  if (lanes.length === 0) console.log("  (no lane traffic)");
+  for (const row of lanes) {
+    const vsDearest = row.dearestMicros - row.spentMicros;
+    const vsRef = row.referenceMicros - row.spentMicros;
+    const dearestPct = row.dearestMicros > 0 ? vsDearest / row.dearestMicros : null;
+    const refPct = row.referenceMicros > 0 ? vsRef / row.referenceMicros : null;
+    console.log(
+      `${row.lane.padEnd(22)}${String(row.requests).padStart(4)}  ${String(row.membersUsed).padStart(7)}  ${formatUsd(row.spentMicros, 4).padStart(9)}  ${formatUsd(vsDearest, 4).padStart(8)} ${pct(dearestPct).padStart(6)}  ${formatUsd(vsRef, 4).padStart(8)} ${pct(refPct).padStart(6)} (${row.referenceRequests} reqs)`
+    );
+  }
+  if (lanes.length > 0) {
+    console.log("  Each alternative is priced at its own rate, at that hour, for the tokens the");
+    console.log("  served member actually used \u2014 the same work at the other member's price, not a");
+    console.log("  claim about what the other member would have written. 'vs dearest' is the upper");
+    console.log("  bound; 'vs first-listed' is against the member a human would have pinned, over");
+    console.log("  only the requests where it passed the gates, so its request count differs.");
+    console.log("  A negative number means the first-listed member was the cheapest that passed.");
+    console.log("\nlane                  cache hits   cache saved   selection saved");
+    for (const row of lanes) {
+      console.log(
+        `${row.lane.padEnd(22)}${String(row.cacheHits).padStart(10)}   ${formatUsd(row.cacheMicros, 4).padStart(11)}   ${formatUsd(row.dearestMicros - row.spentMicros, 4).padStart(15)}`
+      );
+    }
+    console.log("  'cache saved' is what the lane's hits saved against list; 'selection saved' is");
+    console.log("  'vs dearest' above. Never added: one chose a cheaper model, the other replayed");
+    console.log("  an answer, and they carry different risks.");
+  }
+  const laneCache = await byLaneCache(db, null);
+  console.log("\n\ncache hit rate by lane, scope and class \u2014 never blended");
+  console.log("lane                  class          reqs   model scope       lane scope");
+  if (laneCache.length === 0) console.log("  (no lane traffic)");
+  for (const row of laneCache) {
+    console.log(
+      `${row.lane.padEnd(22)}${row.trafficClass.padEnd(14)} ${String(row.requests).padStart(4)}   ${pct(row.modelHitRate).padStart(6)} (${String(row.modelHits).padStart(4)})   ${pct(row.laneHitRate).padStart(6)} (${String(row.laneHits).padStart(4)})`
+    );
+  }
+  console.log("  The switch-on rule reads a lane's interactive row and nothing");
+  console.log("  else: a scheduled pipeline re-runs the same prompts by construction.");
+  const violations = await tierViolations(db, null);
+  console.log("\n\nsuspected tier-rule violations \u2014 a lane hit the caller then disowned (#21)");
+  if (violations.length === 0) console.log("  none \u2014 no lane-scope hit has been served");
+  for (const row of violations) {
+    console.log(
+      `  ${row.lane.padEnd(22)} ${String(row.suspected).padStart(3)} of ${row.laneHits} lane hits re-sent by the same key within ${VIOLATION_WINDOW_MINUTES} minutes with scope=off or scope=model`
+    );
+  }
+  console.log("  Target zero. Above it, a rank in that lane's quality_ranks is wrong, or lane");
+  console.log("  scope should be withdrawn from it. Suspected, not proven: a retry loop looks the same.");
+  console.log("\n\nnot yet answerable, and why");
+  console.log("  \u2022 OpenRouter spend          \u2014 no models routed there yet (#15)");
+  console.log("  \u2022 is phase 1a worth it      \u2014 needs the hit TTFB gap above, over real traffic");
+  console.log("  \u2022 is lane scope worth it    \u2014 the interactive rows above, thirty days after model scope");
+});

package/dist/service-key-N2RZ7FMZ.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+import {
+  generateServiceKey
+} from "./chunk-5TVD3ZAI.mjs";
+import {
+  connect,
+  environmentOf,
+  parseArgs,
+  requireString,
+  run
+} from "./chunk-7NQHBXVZ.mjs";
+import "./chunk-JZPUTXM7.mjs";
+
+// scripts/service-key.ts
+run(async () => {
+  const [command, ...rest] = process.argv.slice(2);
+  const args = parseArgs(rest);
+  const db = connect(environmentOf(args));
+  switch (command) {
+    case "issue": {
+      const actor = requireString(args, "actor");
+      const purpose = typeof args.purpose === "string" ? args.purpose : "credits";
+      if (purpose !== "credits" && purpose !== "balance" && purpose !== "provision" && purpose !== "tier" && purpose !== "economics" && purpose !== "promo") {
+        throw new Error("--purpose must be credits, balance, provision, tier, economics or promo");
+      }
+      const generated = await generateServiceKey();
+      await db.prepare(
+        `INSERT INTO service_keys (id, prefix, key_hash, purpose, created_by)
+           VALUES (?, ?, ?, ?, ?)`
+      ).bind(crypto.randomUUID(), generated.prefix, generated.hash, purpose, actor).run();
+      console.log(`Issued for '${purpose}'. Shown once, stored hashed:
+
+  ${generated.key}
+`);
+      console.log(`Prefix (safe in logs): ${generated.prefix}`);
+      break;
+    }
+    case "revoke": {
+      const prefix = requireString(args, "prefix");
+      const reason = requireString(args, "reason");
+      await db.prepare(`UPDATE service_keys SET revoked_at = datetime('now') WHERE prefix = ? AND revoked_at IS NULL`).bind(prefix).run();
+      await db.prepare(
+        `INSERT INTO audit_events (id, actor, action, subject, detail) VALUES (?, 'cli', 'service_key.revoke', ?, ?)`
+      ).bind(crypto.randomUUID(), prefix, JSON.stringify({ reason })).run();
+      console.log(`Revoked ${prefix}.`);
+      break;
+    }
+    case "list": {
+      const { results } = await db.prepare(
+        `SELECT prefix, purpose, created_by, created_at, revoked_at, last_used_at FROM service_keys ORDER BY created_at`
+      ).all();
+      console.table(results);
+      break;
+    }
+    default:
+      throw new Error("Usage: service-key.ts <issue|revoke|list>");
+  }
+});

package/dist/smoke-ZNYX6RO5.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+import {
+  parseArgs,
+  requireString,
+  run
+} from "./chunk-7NQHBXVZ.mjs";
+import "./chunk-JZPUTXM7.mjs";
+
+// src/smoke.ts
+var NOT_CHECKED = "not checked \u2014 the catalogue did not list";
+function catalogueChecks(status, listed) {
+  const entries = listed?.data ?? [];
+  const listedOk = status === 200 && entries.length > 0;
+  const checks = [
+    {
+      name: "models listed",
+      ok: listedOk,
+      detail: status === 200 ? `${entries.length} model(s)` : `HTTP ${status}, so nothing was listed`
+    }
+  ];
+  const unpriced = entries.filter((model) => model["x-cruise"]?.pricing == null).map((model) => model.id);
+  checks.push({
+    name: "every listed model is priced",
+    ok: listedOk && unpriced.length === 0,
+    detail: listedOk ? unpriced.join(", ") || "all priced" : NOT_CHECKED
+  });
+  const lanes = entries.filter((model) => model["x-cruise"]?.lane === true);
+  const concrete = entries.filter((model) => model["x-cruise"]?.lane !== true);
+  const unmeasured = concrete.filter((model) => model["x-cruise"]?.measured_at == null).map((model) => model.id);
+  checks.push({
+    name: "every listed model is measured",
+    ok: listedOk && unmeasured.length === 0,
+    detail: listedOk ? unmeasured.join(", ") || "all measured" : NOT_CHECKED
+  });
+  const ids = new Set(entries.map((model) => model.id));
+  const badLanes = lanes.filter((lane) => {
+    const members = lane["x-cruise"]?.members ?? [];
+    return members.length === 0 || members.some((m) => !ids.has(m));
+  }).map((lane) => lane.id);
+  checks.push({
+    name: "every lane lists members from this catalog",
+    ok: listedOk && lanes.length > 0 && badLanes.length === 0,
+    detail: !listedOk ? NOT_CHECKED : lanes.length === 0 ? "no lanes listed" : badLanes.join(", ") || `${lanes.length} lane(s), all members listed`
+  });
+  return checks;
+}
+
+// scripts/smoke.ts
+var results = [];
+function record(name, ok, detail) {
+  results.push({ name, ok, detail });
+  console.log(`  ${ok ? "ok  " : "FAIL"}  ${name.padEnd(38)} ${detail}`);
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const base = requireString(args, "base").replace(/\/$/, "");
+  const key = typeof args["key"] === "string" ? args["key"] : null;
+  const url = new URL(base);
+  if (url.protocol !== "https:") throw new Error(`--base must be https, got ${base}`);
+  console.log(`
+smoke: ${base}
+`);
+  const health = await fetch(`${base}/health`);
+  const body = await health.json().catch(() => null);
+  record("health responds", health.status === 200 && body?.ok === true, `${health.status} ${body?.environment ?? ""}`);
+  const hsts = health.headers.get("strict-transport-security");
+  record("HSTS present", hsts !== null && hsts.includes("max-age="), hsts ?? "absent");
+  record(
+    "nosniff present",
+    health.headers.get("x-content-type-options") === "nosniff",
+    health.headers.get("x-content-type-options") ?? "absent"
+  );
+  const cleartext = await fetch(`${base.replace(/^https:/, "http:")}/health`, { redirect: "manual" });
+  record(
+    "plain http refused, not redirected",
+    cleartext.status === 400,
+    `${cleartext.status}${cleartext.status >= 300 && cleartext.status < 400 ? " \u2014 REDIRECTED, the key still leaked" : ""}`
+  );
+  const unauthenticated = await fetch(`${base}/v1/chat/completions`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ model: "x", messages: [] })
+  });
+  record("completions require a key", unauthenticated.status === 401, String(unauthenticated.status));
+  if (key === null) {
+    console.log("\n  (no --key, so the model catalog was not checked)");
+  } else {
+    const models = await fetch(`${base}/v1/models`, { headers: { authorization: `Bearer ${key}` } });
+    const listed = await models.json().catch(() => null);
+    for (const check of catalogueChecks(models.status, listed)) {
+      record(check.name, check.ok, check.detail);
+    }
+  }
+  const failed = results.filter((check) => !check.ok);
+  console.log(
+    failed.length === 0 ? `
+${results.length} checks passed
+` : `
+${failed.length} of ${results.length} checks FAILED
+`
+  );
+  if (failed.length > 0) process.exitCode = 1;
+}
+run(main);

package/dist/sweep-SZX7OIDK.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+import {
+  SESSION_IDLE_DAYS,
+  pruneIdleSessions,
+  sweepAbandonedHolds,
+  sweepRateBuckets
+} from "./chunk-UNXM6FSM.mjs";
+import "./chunk-SYTYOTO4.mjs";
+import "./chunk-O7TNRKSA.mjs";
+import "./chunk-T3ICD43U.mjs";
+import "./chunk-THEXUHQC.mjs";
+import "./chunk-5TVD3ZAI.mjs";
+import {
+  connect,
+  environmentOf,
+  parseArgs,
+  run
+} from "./chunk-7NQHBXVZ.mjs";
+import "./chunk-JZPUTXM7.mjs";
+
+// scripts/sweep.ts
+run(async () => {
+  const args = parseArgs(process.argv.slice(2));
+  const environment = environmentOf(args);
+  const db = connect(environment);
+  const removed = await sweepRateBuckets(db, /* @__PURE__ */ new Date());
+  console.log(`${environment}: swept ${removed} stale rate-limit bucket(s)`);
+  const abandoned = await sweepAbandonedHolds(db, /* @__PURE__ */ new Date());
+  console.log(`${environment}: closed ${abandoned} abandoned reservation(s) into the ledger`);
+  const idle = await pruneIdleSessions(db);
+  console.log(`${environment}: removed ${idle} run counter(s) idle over ${SESSION_IDLE_DAYS} days`);
+});