@hasna/economy 0.5.10 → 0.5.11

package/dist/cli/index.js

@@ -1,23 +1,36 @@
 #!/usr/bin/env bun
 // @bun
+import {
+  buildStatusLine,
+  gatherStatusData
+} from "../chunks/index-akxt4n8x.js";
+import"../chunks/index-w3bvv0ns.js";
+import {
+  JournalMaintenanceError,
+  PendingIngestError,
+  backfillMachineId,
+  billingSyncToCloud,
+  getIngestCachePath,
+  ingestJournalOperationSchema,
+  recalculateZeroCostRequests,
+  runIngestJournalOperation,
+  syncAllToCloud,
+  syncHasFailures,
+  syncOutcomeLines
+} from "../chunks/index-yv28hyk7.js";
 import {
   syncAnthropicBilling,
   syncGeminiBilling,
   syncOpenAIBilling
 } from "../chunks/index-gtjqy0kd.js";
-import {
-  buildStatusLine,
-  gatherStatusData
-} from "../chunks/index-w4r6xs02.js";
-import"../chunks/index-w3bvv0ns.js";
 import {
   agentPaths,
   syncAll
-} from "../chunks/index-t777mc83.js";
+} from "../chunks/index-mgnzgf1m.js";
 import {
   getStore,
   isCloudStore
-} from "../chunks/index-twn8ncdp.js";
+} from "../chunks/index-v35tm3xg.js";
 import {
   billingDriftCheck,
   comparisonValueChange,
@@ -25,13 +38,9 @@ import {
   economyTransportReport,
   formatComparisonValue,
   packageMetadata
-} from "../chunks/index-4v5r3c22.js";
+} from "../chunks/index-b36bq51x.js";
 import {
   AGENTS,
-  MAX_INGEST_BYTES,
-  MAX_INGEST_ROWS,
-  cacheDir,
-  canonicalIngestBodyHash,
   dedupeRequests,
   ensurePricingSeeded,
   formatBillingValue,
@@ -44,10 +53,7 @@ import {
   getPricingFromDb,
   parseAgent,
   queryZeroCostTokenizedModels,
-  rollupSession,
-  setIngestState,
-  stableJson,
-  validateIngest
+  setIngestState
 } from "../chunks/index-zgvmrqyc.js";
 import {
   __require
@@ -1359,23 +1365,23 @@ function registerExtendedCommands(program) {
     console.log();
   });
   program.command("tui").description("Terminal status dashboard (Linux/SSH friendly)").option("--watch", "Live refresh").option("--interval <seconds>", "Refresh interval", "30").action(async (opts) => {
-    const { runTui } = await import("../chunks/tui-5s5w6yjd.js");
+    const { runTui } = await import("../chunks/tui-hxjczmv5.js");
     await runTui({
       watch: Boolean(opts.watch),
       interval: Number(opts.interval ?? 30)
     });
   });
   program.command("waybar").description("Print waybar-compatible JSON status line").action(async () => {
-    const { printWaybarJson } = await import("../chunks/tui-5s5w6yjd.js");
+    const { printWaybarJson } = await import("../chunks/tui-hxjczmv5.js");
     await printWaybarJson();
   });
   const barCmd = program.command("bar").description("Status bar helpers (Linux)");
   barCmd.command("tui").description("Alias for economy tui").option("--watch", "Live refresh").action(async (opts) => {
-    const { runTui } = await import("../chunks/tui-5s5w6yjd.js");
+    const { runTui } = await import("../chunks/tui-hxjczmv5.js");
     await runTui({ watch: Boolean(opts.watch) });
   });
   barCmd.command("waybar").description("Alias for economy waybar").action(async () => {
-    const { printWaybarJson } = await import("../chunks/tui-5s5w6yjd.js");
+    const { printWaybarJson } = await import("../chunks/tui-hxjczmv5.js");
     await printWaybarJson();
   });
   program.command("estimate").description("Estimate cost for token counts").requiredOption("--model <model>", "Model name").option("--input <n>", "Input tokens", "0").option("--output <n>", "Output tokens", "0").action(async (opts) => {
@@ -1433,755 +1439,7 @@ function registerFleetCommands(program) {
 }
 
 // src/lib/ingest-journal-client.ts
-import { z as z2 } from "zod";
-
-// src/lib/ingest-journal.ts
-import { constants, closeSync, fsyncSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, opendirSync, realpathSync, writeFileSync } from "fs";
-import { createHash } from "crypto";
-import { join as join2, resolve } from "path";
-import { HasnaHttpError } from "@hasna/contracts/client";
-var MAX_COMMANDS = 1000;
-var MAX_BYTES = 64 * 1024 * 1024;
-var RECEIPT_RESERVE = 4096;
-var MAINTENANCE_RESERVE = 16384;
-var sha = (s) => createHash("sha256").update(s).digest("hex");
-
-class PendingIngestError extends Error {
-  pending_keys;
-  code = "INGEST_RECONCILIATION_REQUIRED";
-  constructor(pending_keys) {
-    super("Pending ingestion requires hosted receipt reconciliation; no command was replayed");
-    this.pending_keys = pending_keys;
-    this.name = "PendingIngestError";
-  }
-}
-function definitiveIngestRefusal(status, body) {
-  const reasons = { 400: "invalid_ingest", 409: "ingest_conflict", 413: "ingest_too_large", 422: "unprocessable_ingest" };
-  if (!Object.hasOwn(reasons, status))
-    return null;
-  const legacy = body?.expected === "legacy_aggregate_requires_migration";
-  return {
-    status,
-    code: legacy ? "legacy_aggregate_requires_migration" : "ingest_refused",
-    reason: legacy ? "legacy_aggregate_requires_migration" : reasons[status]
-  };
-}
-function getIngestJournalPath() {
-  return process.env.HASNA_ECONOMY_INGEST_JOURNAL ?? join2(cacheDir({ app: "economy", home: process.env.HOME || process.env.USERPROFILE }), "pending-ingest");
-}
-function targetId(cloud) {
-  const url = new URL(cloud.client.transport.baseUrl);
-  if (url.username || url.password || url.search || url.hash)
-    throw new Error("Ingest authority must not contain URL credentials or capabilities");
-  return sha(url.toString().replace(/\/+$/, ""));
-}
-function secureDirectory(path) {
-  mkdirSync(path, { recursive: true, mode: 448 });
-  const stat = lstatSync(path);
-  if (!stat.isDirectory() || stat.isSymbolicLink() || (stat.mode & 63) !== 0 || process.getuid && stat.uid !== process.getuid())
-    throw new Error("Ingest journal must be a private owner directory");
-}
-function readJson(path, max) {
-  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-  try {
-    const st = fstatSync(fd);
-    if (!st.isFile() || st.size > max || (st.mode & 63) !== 0 || process.getuid && st.uid !== process.getuid())
-      throw new Error("Unsafe ingest journal record");
-    return JSON.parse(readFileSync(fd, "utf8"));
-  } finally {
-    closeSync(fd);
-  }
-}
-function createExact(path, value) {
-  const bytes = JSON.stringify(value);
-  let fd;
-  try {
-    fd = openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
-  } catch (error) {
-    if (error.code === "EEXIST")
-      return false;
-    throw error;
-  }
-  try {
-    writeFileSync(fd, bytes);
-    fsyncSync(fd);
-  } finally {
-    closeSync(fd);
-  }
-  if (JSON.stringify(readJson(path, MAX_INGEST_BYTES + 4096)) !== bytes)
-    throw new Error("Ingest journal readback failed");
-  const directory = openSync(resolve(path, ".."), constants.O_RDONLY);
-  try {
-    fsyncSync(directory);
-  } finally {
-    closeSync(directory);
-  }
-  return true;
-}
-function unwrap(raw) {
-  return raw && typeof raw === "object" && "data" in raw ? raw.data : raw;
-}
-function verifyIngestReceipt(raw, command) {
-  const receipt = unwrap(raw);
-  if (!receipt || typeof receipt !== "object" || !receipt.ingested || typeof receipt.ingested !== "object" || Array.isArray(receipt.ingested) || !Number.isSafeInteger(receipt.total) || receipt.total < 0 || typeof receipt.operation_key !== "string" || !/^[a-f0-9]{64}$/.test(receipt.operation_key) || typeof receipt.replayed !== "boolean")
-    throw new Error("Invalid ingest receipt");
-  let sum = 0;
-  for (const [table, count] of Object.entries(receipt.ingested)) {
-    if (!Array.isArray(command[table]) || typeof count !== "number" || !Number.isSafeInteger(count) || count < 0 || count > command[table].length)
-      throw new Error("Invalid ingest receipt");
-    sum += count;
-  }
-  if (sum !== receipt.total)
-    throw new Error("Invalid ingest receipt");
-  const projected = {
-    ingested: Object.fromEntries(Object.entries(receipt.ingested)),
-    total: receipt.total,
-    operation_key: receipt.operation_key,
-    replayed: receipt.replayed,
-    stale: receipt.stale ?? 0,
-    unchanged: receipt.unchanged ?? 0
-  };
-  const rows = Object.values(command).reduce((n, v) => n + (Array.isArray(v) ? v.length : 0), 0);
-  if (![projected.stale, projected.unchanged].every((n) => Number.isSafeInteger(n) && n >= 0 && n <= rows) || Buffer.byteLength(JSON.stringify(projected)) > RECEIPT_RESERVE - 256)
-    throw new Error("Invalid ingest receipt");
-  return projected;
-}
-function sameReceipt(left, right) {
-  const meaning = (value) => ({ ingested: value?.ingested, total: value?.total, operation_key: value?.operation_key, stale: value?.stale ?? 0, unchanged: value?.unchanged ?? 0 });
-  return stableJson(meaning(left)) === stableJson(meaning(right));
-}
-async function lookupJournalReceipt(cloud, key, bodyHash, timeoutMs = 1e4) {
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
-    throw new RangeError("Receipt lookup requires a positive finite timeout");
-  const query = new URLSearchParams({ idempotency_key: key, body_hash: bodyHash });
-  const deadline = performance.now() + timeoutMs;
-  let failures = 0, lastError;
-  for (;; ) {
-    const remaining = Math.floor(deadline - performance.now());
-    if (remaining <= 0)
-      throw lastError ?? new Error("Receipt lookup deadline expired");
-    let response;
-    try {
-      const abort = new AbortController;
-      let timer;
-      try {
-        const expired = new Promise((_, reject) => {
-          timer = setTimeout(() => {
-            abort.abort();
-            reject(new Error("Receipt lookup deadline expired"));
-          }, remaining);
-        });
-        response = await Promise.race([
-          cloud.client.transport.get(`/ingest/receipts?${query}`, { retry: false, timeoutMs: remaining, signal: abort.signal }),
-          expired
-        ]);
-      } finally {
-        clearTimeout(timer);
-      }
-    } catch (error) {
-      if (!(error instanceof HasnaHttpError) || error.status !== 503)
-        throw error;
-      lastError = error;
-      failures++;
-      const delay = 100 * failures;
-      if (failures >= 3 || deadline - performance.now() <= delay)
-        throw error;
-      await new Promise((resolve2) => setTimeout(resolve2, delay));
-      continue;
-    }
-    if (performance.now() >= deadline)
-      throw new Error("Receipt lookup deadline expired");
-    const raw = unwrap(response);
-    if (!raw || raw.body_hash !== bodyHash)
-      throw new Error("Invalid reconciliation response");
-    if (raw.status === "absent")
-      return null;
-    if (raw.status !== "committed")
-      throw new Error("Invalid reconciliation response");
-    return raw.receipt;
-  }
-}
-
-class IngestJournal {
-  directory;
-  target;
-  inventoryBytes = 0;
-  freshlyStaged = new Set;
-  constructor(cloud, path = getIngestJournalPath()) {
-    this.target = targetId(cloud);
-    secureDirectory(path);
-    this.directory = join2(realpathSync(path), this.target);
-    secureDirectory(this.directory);
-  }
-  names() {
-    const names = [];
-    const directory = opendirSync(this.directory);
-    try {
-      for (let entry;entry = directory.readSync(); ) {
-        if (entry.name === ".lease" || entry.name === ".maintenance" || entry.name === ".authority.json" || entry.name === ".recovery")
-          continue;
-        names.push(entry.name);
-        if (names.length > MAX_COMMANDS * 2)
-          throw new Error("Ingest journal capacity reached; preserve and reconcile records");
-      }
-    } finally {
-      directory.closeSync();
-    }
-    this.inventoryBytes = 0;
-    const set = new Set(names);
-    for (const name of names) {
-      if (!/^[a-f0-9]{64}\.(intent|receipt|refusal)\.json$/.test(name))
-        throw new Error("Unexpected ingest journal entry");
-      if (!name.endsWith(".intent.json") && !set.has(name.replace(/\.(receipt|refusal)\./, ".intent.")))
-        throw new Error("Orphaned ingest outcome requires maintenance recovery");
-      if (name.endsWith(".refusal.json") && set.has(name.replace(".refusal.", ".receipt.")))
-        throw new Error("Conflicting ingest receipt and refusal");
-      const stat = lstatSync(join2(this.directory, name));
-      if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 63) !== 0)
-        throw new Error("Unsafe ingest journal record");
-      if (stat.size > MAX_INGEST_BYTES + 4096)
-        throw new Error("Oversized ingest journal record");
-      this.inventoryBytes += stat.size;
-      if (name.endsWith(".refusal.json"))
-        this.refusal(this.intent(name.replace(".refusal.", ".intent.")).command);
-    }
-    return names;
-  }
-  file(key, kind) {
-    return join2(this.directory, `${sha(key)}.${kind}.json`);
-  }
-  intent(name) {
-    const record = readJson(join2(this.directory, name), MAX_INGEST_BYTES + 4096);
-    if (record.version !== 1 || record.target !== this.target || !record.command || typeof record.command.idempotency_key !== "string" || record.body_hash !== canonicalIngestBodyHash(record.command) || name !== `${sha(record.command.idempotency_key)}.intent.json`)
-      throw new Error("Invalid ingest journal intent");
-    validateIngest(record.command);
-    return record;
-  }
-  status() {
-    const names = this.names(), intents = names.filter((n) => n.endsWith(".intent.json"));
-    const set = new Set(names);
-    const completed = intents.filter((name) => set.has(name.replace(".intent.", ".receipt."))).length;
-    const rejected = intents.filter((name) => set.has(name.replace(".intent.", ".refusal."))).length;
-    const bytes = this.inventoryBytes;
-    return { target: this.target, commands: intents.length, completed, rejected, pending: intents.length - completed - rejected, bytes, reserved_bytes: bytes + (intents.length - completed - rejected) * RECEIPT_RESERVE + MAINTENANCE_RESERVE };
-  }
-  canStage(command, status = this.status()) {
-    const name = `${sha(command.idempotency_key)}.intent.json`;
-    try {
-      if (this.intent(name).body_hash !== canonicalIngestBodyHash(command))
-        throw new Error("Ingest command key is already bound to different content");
-      return true;
-    } catch (error) {
-      if (error.code !== "ENOENT")
-        throw error;
-    }
-    const record = { version: 1, target: this.target, body_hash: canonicalIngestBodyHash(command), command };
-    return status.commands < MAX_COMMANDS && status.reserved_bytes + Buffer.byteLength(JSON.stringify(record)) + RECEIPT_RESERVE <= MAX_BYTES;
-  }
-  receipt(command) {
-    if (this.refusal(command))
-      throw new Error("Conflicting ingest receipt and refusal");
-    const record = readJson(this.file(command.idempotency_key, "receipt"), RECEIPT_RESERVE);
-    if (record.version !== 1 || record.target !== this.target || record.body_hash !== canonicalIngestBodyHash(command))
-      throw new Error("Invalid receipt journal binding");
-    return verifyIngestReceipt(record.receipt, command);
-  }
-  stage(command) {
-    validateIngest(command);
-    const path = this.file(command.idempotency_key, "intent");
-    const record = { version: 1, target: this.target, body_hash: canonicalIngestBodyHash(command), command };
-    if (!this.canStage(command))
-      throw new Error("Ingest journal capacity reached; run economy ingest journal maintain; originals preserved");
-    if (createExact(path, record)) {
-      this.freshlyStaged.add(command.idempotency_key);
-      return true;
-    }
-    this.freshlyStaged.delete(command.idempotency_key);
-    const old = this.intent(`${sha(command.idempotency_key)}.intent.json`);
-    if (old.body_hash !== record.body_hash)
-      throw new Error("Ingest command key is already bound to different content");
-    return false;
-  }
-  accept(command, raw) {
-    if (this.refusal(command))
-      throw new Error("A refused command cannot accept a receipt");
-    this.freshlyStaged.delete(command.idempotency_key);
-    const receipt = verifyIngestReceipt(raw, command);
-    const intent = this.intent(`${sha(command.idempotency_key)}.intent.json`);
-    if (intent.body_hash !== canonicalIngestBodyHash(command))
-      throw new Error("Ingest receipt content conflicts with exact intent");
-    const record = { version: 1, target: this.target, body_hash: canonicalIngestBodyHash(command), receipt };
-    const path = this.file(command.idempotency_key, "receipt");
-    if (!this.names().includes(`${sha(command.idempotency_key)}.receipt.json`) && this.inventoryBytes + Buffer.byteLength(JSON.stringify(record)) > MAX_BYTES)
-      throw new Error("Receipt capacity exhausted; exact intent retained for reconciliation");
-    if (!createExact(path, record)) {
-      const old = readJson(path, MAX_INGEST_BYTES);
-      if (old.body_hash !== record.body_hash || old.target !== this.target || !sameReceipt(old.receipt, receipt))
-        throw new Error("Ingest receipt journal conflict");
-    }
-    return receipt;
-  }
-  recordRefusal(command, refusal) {
-    if (!this.freshlyStaged.delete(command.idempotency_key))
-      throw new Error("Refusal requires this invocation's fresh command");
-    const intent = this.intent(`${sha(command.idempotency_key)}.intent.json`);
-    if (intent.body_hash !== canonicalIngestBodyHash(command))
-      throw new Error("Refusal conflicts with exact intent");
-    const expected = definitiveIngestRefusal(refusal.status, refusal.code === "legacy_aggregate_requires_migration" ? { expected: refusal.code } : null);
-    if (!expected || stableJson(expected) !== stableJson(refusal))
-      throw new Error("Invalid definitive refusal");
-    const names = this.names();
-    if (names.includes(`${sha(command.idempotency_key)}.receipt.json`))
-      throw new Error("A completed command cannot be refused");
-    const record = { version: 1, target: this.target, body_hash: intent.body_hash, refusal };
-    if (Buffer.byteLength(JSON.stringify(record)) > RECEIPT_RESERVE || this.inventoryBytes + Buffer.byteLength(JSON.stringify(record)) > MAX_BYTES)
-      throw new Error("Refusal capacity exhausted; exact intent retained");
-    if (!createExact(this.file(command.idempotency_key, "refusal"), record))
-      throw new Error("Existing refusal requires inspection");
-    this.refusal(command);
-  }
-  refusal(command) {
-    let record;
-    try {
-      record = readJson(this.file(command.idempotency_key, "refusal"), RECEIPT_RESERVE);
-    } catch (error) {
-      if (error.code === "ENOENT")
-        return null;
-      throw error;
-    }
-    const intent = this.intent(`${sha(command.idempotency_key)}.intent.json`), r = record?.refusal;
-    const expected = definitiveIngestRefusal(r?.status, r?.code === "legacy_aggregate_requires_migration" ? { expected: r.code } : null);
-    if (record?.version !== 1 || record.target !== this.target || record.body_hash !== intent.body_hash || intent.body_hash !== canonicalIngestBodyHash(command) || !expected || stableJson(expected) !== stableJson(r))
-      throw new Error("Invalid refusal journal binding");
-    try {
-      lstatSync(this.file(command.idempotency_key, "receipt"));
-      throw new Error("Conflicting ingest receipt and refusal");
-    } catch (error) {
-      if (error.code !== "ENOENT")
-        throw error;
-    }
-    return expected;
-  }
-  async reconcileCommand(cloud, command, timeoutMs = 1e4) {
-    const receipt = await this.lookupReceipt(cloud, command, timeoutMs);
-    return receipt ? this.accept(command, receipt) : null;
-  }
-  assertCloud(cloud) {
-    if (targetId(cloud) !== this.target)
-      throw new Error("Ingest journal authority changed");
-  }
-  async lookupReceipt(cloud, command, timeoutMs = 1e4) {
-    this.assertCloud(cloud);
-    const receipt = await lookupJournalReceipt(cloud, command.idempotency_key, canonicalIngestBodyHash(command), timeoutMs);
-    return receipt === null ? null : verifyIngestReceipt(receipt, command);
-  }
-  async reconcilePending(cloud) {
-    const names = this.names(), unresolved = [];
-    const deadline = performance.now() + 30000;
-    for (const name of names.filter((n) => n.endsWith(".intent.json"))) {
-      const intent = this.intent(name);
-      if (names.includes(`${sha(intent.command.idempotency_key)}.refusal.json`)) {
-        this.refusal(intent.command);
-        continue;
-      }
-      if (names.includes(`${sha(intent.command.idempotency_key)}.receipt.json`)) {
-        const record = readJson(this.file(intent.command.idempotency_key, "receipt"), MAX_INGEST_BYTES);
-        if (record.target !== this.target || record.body_hash !== intent.body_hash)
-          throw new Error("Invalid receipt journal binding");
-        verifyIngestReceipt(record.receipt, intent.command);
-        continue;
-      }
-      if (performance.now() >= deadline) {
-        unresolved.push(intent.command.idempotency_key);
-        continue;
-      }
-      try {
-        if (!await this.reconcileCommand(cloud, intent.command, Math.max(1, Math.min(1e4, deadline - performance.now()))))
-          unresolved.push(intent.command.idempotency_key);
-      } catch {
-        unresolved.push(intent.command.idempotency_key);
-      }
-    }
-    if (unresolved.length)
-      throw new PendingIngestError(unresolved);
-  }
-}
-
-// src/lib/ingest-journal-maintenance.ts
-import { constants as constants2, closeSync as closeSync2, fstatSync as fstatSync2, lstatSync as lstatSync2, openSync as openSync2, readFileSync as readFileSync2, readdirSync } from "fs";
-import { createHash as createHash2 } from "crypto";
-import { join as join3 } from "path";
-var uuid = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
-var digest = /^[a-f0-9]{64}$/;
-var sha2 = (bytes) => createHash2("sha256").update(bytes).digest("hex");
-
-class JournalMaintenanceError extends Error {
-  reason;
-  target;
-  code = "INGEST_JOURNAL_MAINTENANCE_REQUIRED";
-  constructor(reason, target) {
-    super(`Ingest journal maintenance required (${reason}); run economy ingest journal maintain; originals or Trash recovery state preserved`);
-    this.reason = reason;
-    this.target = target;
-    this.name = "JournalMaintenanceError";
-  }
-}
-function exists(path) {
-  try {
-    lstatSync2(path);
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return false;
-    throw error;
-  }
-}
-function snapshot(path) {
-  const fd = openSync2(path, constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
-  try {
-    const stat = fstatSync2(fd);
-    if (!stat.isFile() || stat.nlink !== 1 || stat.size > 4 * 1024 * 1024 + 4096 || (stat.mode & 63) !== 0 || process.getuid && stat.uid !== process.getuid())
-      throw new Error("Unsafe maintenance source");
-    const bytes = readFileSync2(fd), after = fstatSync2(fd);
-    if (after.ctimeMs !== stat.ctimeMs || bytes.length !== stat.size)
-      throw new Error("Maintenance source changed");
-    return { sha256: sha2(bytes), sizeBytes: stat.size, mode: stat.mode & 511, device: String(stat.dev), inode: String(stat.ino), ctime: stat.ctimeMs };
-  } finally {
-    closeSync2(fd);
-  }
-}
-function sameSource(path, expected) {
-  const { capture_sha256: _capture, ...original } = expected;
-  if (JSON.stringify(snapshot(path)) !== JSON.stringify(original))
-    throw new Error("Maintenance source changed; preserve for inspection");
-}
-function validAnchor(value, target) {
-  const a = value;
-  if (a?.version !== 1 || a.target !== target || !/^[A-Za-z0-9._:-]{1,200}$/.test(a.key) || !digest.test(a.body_hash) || !digest.test(a.receipt?.operation_key))
-    throw new Error("Invalid journal authority anchor");
-  return a;
-}
-async function confirm(cloud, anchor, deadline) {
-  if (Date.now() >= deadline)
-    throw new Error("Maintenance deadline reached");
-  const current = await lookupJournalReceipt(cloud, anchor.key, anchor.body_hash, Math.max(1, Math.min(1e4, deadline - Date.now())));
-  if (current === null || !sameReceipt(current, anchor.receipt))
-    throw new Error("Exact Economy receipt is unavailable or changed");
-}
-async function verifyJournalAuthority(journal, cloud) {
-  journal.assertCloud(cloud);
-  const path = join3(journal.directory, ".authority.json");
-  if (!exists(path)) {
-    const names = journal.names();
-    const name = names.find((n) => n.endsWith(".intent.json") && names.includes(n.replace(".intent.", ".receipt.")));
-    if (!name)
-      return;
-    const intent = journal.intent(name), receipt = journal.receipt(intent.command);
-    createExact(path, { version: 1, target: journal.target, key: intent.command.idempotency_key, body_hash: intent.body_hash, receipt });
-  }
-  await confirm(cloud, validAnchor(readJson(path, 4096), journal.target), Date.now() + 1e4);
-}
-function recoveryFactory(cloud, env = process.env) {
-  return async (operationRoot, checkpoint, deadline) => {
-    if (env.HASNA_ECONOMY_INGEST_RECOVERY !== "trash")
-      throw new Error("recovery_not_configured");
-    const economy = new URL(cloud.client.transport.baseUrl);
-    const fleet = economy.origin === "https://api.hasna.com" && /^\/economy(?:\/v1)?\/?$/.test(economy.pathname);
-    if (!fleet && !env.HASNA_TRASH_API_URL)
-      throw new Error("self_host_trash_authority_required");
-    const sdk = await import("@hasna/trash/sdk");
-    if (sdk.VERSION !== "0.2.3")
-      throw new Error("trash_version_mismatch");
-    const boundedFetch = (input, init) => {
-      const remaining = deadline - Date.now();
-      if (remaining <= 0)
-        throw new Error("maintenance_deadline");
-      const signal = AbortSignal.timeout(remaining);
-      return fetch(input, { ...init, signal: init?.signal ? AbortSignal.any([signal, init.signal]) : signal, redirect: "error" });
-    };
-    return Object.assign(sdk.createTrash({ env, operationRoot, checkpoint, fetchImpl: boundedFetch, transferFetch: boundedFetch, lockTimeoutMs: 100 }), { snapshot: sdk.snapshotIdentity });
-  };
-}
-
-class IngestJournalMaintenance {
-  journal;
-  cloud;
-  factory;
-  control;
-  operationRoot;
-  constructor(journal, cloud, factory = recoveryFactory(cloud)) {
-    this.journal = journal;
-    this.cloud = cloud;
-    this.factory = factory;
-    journal.assertCloud(cloud);
-    this.control = join3(journal.directory, ".maintenance");
-    this.operationRoot = join3(journal.directory, ".recovery");
-  }
-  manifest() {
-    secureDirectory(this.control);
-    const names = readdirSync(this.control);
-    if (names.some((n) => !["manifest.json", "intent.operation.json", "receipt.operation.json"].includes(n)))
-      throw new Error("Unexpected maintenance entry");
-    let size = 0;
-    for (const name of names)
-      size += lstatSync2(join3(this.control, name)).size;
-    if (size > MAINTENANCE_RESERVE)
-      throw new Error("Maintenance metadata exceeds reserve");
-    const m = validAnchor(readJson(join3(this.control, "manifest.json"), 8192), this.journal.target);
-    for (const part of [m.intent, m.receipt_file])
-      if (!part || !digest.test(part.sha256) || !digest.test(part.capture_sha256 ?? "") || !Number.isSafeInteger(part.sizeBytes) || part.sizeBytes < 1 || part.sizeBytes > 4198400 || part.mode !== 384 || !/^\d+$/.test(part.device) || !/^\d+$/.test(part.inode) || !Number.isFinite(part.ctime))
-        throw new Error("Invalid maintenance snapshot");
-    return m;
-  }
-  pending(backend) {
-    const pending = backend.pending(4);
-    if (pending.length > 3 || pending.some((p) => !uuid.test(p.id) || p.phase === "unreadable"))
-      throw new Error("Unexpected Trash recovery state");
-    return pending;
-  }
-  async backend(deadline) {
-    const backend = await this.factory(this.operationRoot, async (point, operation) => {
-      if (operation.path === this.control)
-        return;
-      const m = this.manifest();
-      const kind = operation.path === this.journal.file(m.key, "receipt") ? "receipt" : operation.path === this.journal.file(m.key, "intent") ? "intent" : null;
-      if (!kind || operation.kind !== "capture" || !uuid.test(operation.id) || operation.id !== operation.entryId)
-        throw new Error("Unexpected Trash operation");
-      const expected = kind === "receipt" ? m.receipt_file : m.intent;
-      if (point === "afterSnapshot") {
-        if (!operation.receipt || operation.receipt.sha256 !== expected.capture_sha256 || operation.receipt.sizeBytes !== expected.sizeBytes || operation.receipt.mode !== expected.mode)
-          throw new Error("Trash snapshot mismatch");
-        sameSource(operation.path, expected);
-        const path = join3(this.control, `${kind}.operation.json`);
-        createExact(path, { id: operation.id });
-        if (readJson(path, 1024).id !== operation.id)
-          throw new Error("Conflicting Trash operation");
-      }
-      if (point === "beforeStage") {
-        await confirm(this.cloud, m, deadline);
-        sameSource(operation.path, expected);
-      }
-    }, deadline);
-    const status = await backend.doctor();
-    if (!status.station || !uuid.test(status.station.id) || !Number.isInteger(status.retentionDays) || status.retentionDays < 1)
-      throw new Error("Trash station authority unavailable");
-    return backend;
-  }
-  async entry(backend, id, path, expected) {
-    const e = await backend.api.get(id);
-    if (e.id !== id || e.originalPath !== path || e.kind !== "file" || e.sha256 !== expected.capture_sha256 || e.sizeBytes !== expected.sizeBytes || e.mode !== expected.mode || e.state !== "trashed")
-      throw new Error("Trash preservation readback refused");
-    if (exists(path))
-      throw new Error("Retired source reappeared; preserve for inspection");
-  }
-  async pairFile(backend, m, kind, deadline) {
-    await confirm(this.cloud, m, deadline);
-    const path = this.journal.file(m.key, kind), expected = kind === "receipt" ? m.receipt_file : m.intent;
-    const saved = join3(this.control, `${kind}.operation.json`);
-    let id;
-    if (exists(saved))
-      id = readJson(saved, 1024).id;
-    const pending = this.pending(backend);
-    const matches = pending.filter((p) => p.path === path);
-    if (matches.length > 1 || id && !uuid.test(id))
-      throw new Error("Conflicting Trash operation");
-    if (matches[0]) {
-      if (id && id !== matches[0].id)
-        throw new Error("Conflicting Trash operation");
-      id = matches[0].id;
-      const operation = backend.journal.read(id);
-      if (operation.kind !== "capture" || operation.path !== path || operation.entryId !== id)
-        throw new Error("Invalid Trash operation binding");
-      if (exists(path))
-        sameSource(path, expected);
-      await backend.recover(id, { takeAbandonedLock: true });
-    } else if (!id) {
-      sameSource(path, expected);
-      const status = await backend.doctor();
-      const e = await backend.put(path, { retentionDays: status.retentionDays });
-      id = e.id;
-      if (!exists(saved) || readJson(saved, 1024).id !== id)
-        throw new Error("Trash did not persist its capture binding");
-    }
-    await this.entry(backend, id, path, expected);
-  }
-  async recover() {
-    if (!exists(this.control) && !exists(this.operationRoot))
-      return;
-    if (exists(this.operationRoot))
-      secureDirectory(this.operationRoot);
-    if (!exists(this.control) && readdirSync(this.operationRoot).every((n) => n === ".locks"))
-      return;
-    const deadline = Date.now() + 30000;
-    try {
-      await this.finish(await this.backend(deadline), deadline);
-    } catch (error) {
-      if (error instanceof JournalMaintenanceError)
-        throw error;
-      throw new JournalMaintenanceError("recovery_unresolved", this.journal.target);
-    }
-  }
-  async finish(backend, deadline) {
-    const pending = this.pending(backend);
-    const control = pending.filter((p) => p.path === this.control);
-    if (control.length) {
-      if (control.length !== 1 || pending.length !== 1)
-        throw new Error("Conflicting maintenance cleanup");
-      const op = backend.journal.read(control[0].id);
-      if (op.kind !== "capture" || op.path !== this.control)
-        throw new Error("Invalid maintenance cleanup");
-      await backend.recover(op.id, { takeAbandonedLock: true });
-      if (exists(this.control) || this.pending(backend).length)
-        throw new Error("Maintenance cleanup unresolved");
-      return;
-    }
-    if (!exists(this.control)) {
-      if (pending.length)
-        throw new Error("Orphaned maintenance operation");
-      return;
-    }
-    if (readdirSync(this.control).length === 0) {
-      if (pending.length)
-        throw new Error("Orphaned maintenance operation");
-      const status2 = await backend.doctor();
-      await backend.put(this.control, { retentionDays: status2.retentionDays });
-      return;
-    }
-    const m = this.manifest();
-    if (pending.some((p) => p.path !== this.journal.file(m.key, "receipt") && p.path !== this.journal.file(m.key, "intent")))
-      throw new Error("Unexpected recovery path");
-    await this.pairFile(backend, m, "receipt", deadline);
-    await this.pairFile(backend, m, "intent", deadline);
-    if (this.pending(backend).length)
-      throw new Error("Unfinished pair capture");
-    await confirm(this.cloud, m, deadline);
-    const status = await backend.doctor();
-    await backend.put(this.control, { retentionDays: status.retentionDays });
-    if (exists(this.control) || this.pending(backend).length)
-      throw new Error("Maintenance cleanup unresolved");
-  }
-  async maintain(limit = 32) {
-    if (!Number.isInteger(limit) || limit < 1 || limit > 32)
-      throw new Error("Journal maintenance limit must be 1\u201332");
-    await this.recover();
-    await verifyJournalAuthority(this.journal, this.cloud);
-    const sweepDeadline = Date.now() + 30000;
-    let retired = 0, bytes = 0;
-    let backend;
-    try {
-      const names = this.journal.names();
-      for (const name of names.filter((n) => n.endsWith(".intent.json"))) {
-        if (retired >= limit || Date.now() >= sweepDeadline || retired > 0 && bytes >= 1048576)
-          break;
-        if (!names.includes(name.replace(".intent.", ".receipt.")))
-          continue;
-        const intent = this.journal.intent(name), receipt = this.journal.receipt(intent.command);
-        const deadline = Date.now() + 30000;
-        backend = await this.backend(deadline);
-        const m = {
-          version: 1,
-          target: this.journal.target,
-          key: intent.command.idempotency_key,
-          body_hash: intent.body_hash,
-          receipt,
-          intent: snapshot(join3(this.journal.directory, name)),
-          receipt_file: snapshot(this.journal.file(intent.command.idempotency_key, "receipt"))
-        };
-        await confirm(this.cloud, m, deadline);
-        m.intent.capture_sha256 = backend.snapshot(this.journal.file(m.key, "intent")).sha256;
-        m.receipt_file.capture_sha256 = backend.snapshot(this.journal.file(m.key, "receipt")).sha256;
-        secureDirectory(this.control);
-        if (!createExact(join3(this.control, "manifest.json"), m))
-          throw new Error("Existing maintenance transaction");
-        await this.finish(backend, deadline);
-        retired++;
-        bytes += m.intent.sizeBytes + m.receipt_file.sizeBytes;
-      }
-      return { retired, remaining: this.journal.status().completed };
-    } catch (error) {
-      if (error instanceof JournalMaintenanceError)
-        throw error;
-      const reason = error instanceof Error && ["recovery_not_configured", "self_host_trash_authority_required", "trash_version_mismatch"].includes(error.message) ? error.message : backend ? "recovery_unresolved" : "recovery_authority_unavailable";
-      throw new JournalMaintenanceError(reason, this.journal.target);
-    }
-  }
-  async admit(command) {
-    const status = this.journal.status();
-    const fits = this.journal.canStage(command, status);
-    if (status.commands < 64 && status.reserved_bytes < 50331648 && fits)
-      return;
-    try {
-      await this.maintain();
-    } catch (error) {
-      const deferrable = error instanceof JournalMaintenanceError && ["recovery_not_configured", "self_host_trash_authority_required", "trash_version_mismatch", "recovery_authority_unavailable"].includes(error.reason);
-      if (!deferrable || exists(this.control) || !this.journal.canStage(command))
-        throw error;
-    }
-    if (!this.journal.canStage(command))
-      throw new JournalMaintenanceError("capacity", this.journal.target);
-  }
-}
-
-// src/lib/ingest-journal-operation.ts
-import { existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
 import { z } from "zod";
-
-// src/lib/ingest-journal-lock.ts
-import { constants as constants3, closeSync as closeSync3, fstatSync as fstatSync3, lstatSync as lstatSync3, openSync as openSync3 } from "fs";
-import { join as join4 } from "path";
-async function withIngestJournalLock(directory, action) {
-  if (process.platform !== "linux" && process.platform !== "darwin")
-    throw new Error("Ingest journal locking requires Linux or macOS");
-  const { dlopen, FFIType } = await import("bun:ffi");
-  const library = dlopen(process.platform === "darwin" ? "/usr/lib/libSystem.B.dylib" : "libc.so.6", {
-    flock: { args: [FFIType.i32, FFIType.i32], returns: FFIType.i32 }
-  });
-  const path = join4(directory, ".lease");
-  let fd;
-  try {
-    fd = openSync3(path, constants3.O_RDWR | constants3.O_CREAT | constants3.O_NOFOLLOW | constants3.O_NONBLOCK, 384);
-    const stat = fstatSync3(fd), current = lstatSync3(path);
-    if (!stat.isFile() || stat.size !== 0 || stat.nlink !== 1 || stat.ino !== current.ino || stat.dev !== current.dev || (stat.mode & 63) !== 0 || process.getuid && stat.uid !== process.getuid())
-      throw new Error("Unsafe ingest journal lease");
-    if (library.symbols.flock(fd, 6) !== 0) {
-      const error = new Error("Ingest journal is busy; retry after the current operation finishes");
-      Object.assign(error, { code: "INGEST_JOURNAL_BUSY" });
-      throw error;
-    }
-    return await action();
-  } finally {
-    if (fd !== undefined)
-      closeSync3(fd);
-    library.close();
-  }
-}
-
-// src/lib/ingest-journal-operation.ts
-var ingestJournalOperationSchema = z.discriminatedUnion("action", [
-  z.object({ action: z.literal("status") }).strict(),
-  z.object({ action: z.literal("reconcile") }).strict(),
-  z.object({ action: z.literal("maintain"), confirm: z.literal(true), limit: z.number().int().min(1).max(32).default(32) }).strict()
-]);
-async function runIngestJournalOperation(cloud, input) {
-  const options = ingestJournalOperationSchema.parse(input);
-  const journal = new IngestJournal(cloud);
-  return withIngestJournalLock(journal.directory, async () => {
-    const maintenance = new IngestJournalMaintenance(journal, cloud);
-    const unfinished = existsSync2(maintenance.control) || existsSync2(maintenance.operationRoot) && readdirSync2(maintenance.operationRoot).some((n) => n !== ".locks");
-    if (options.action === "status" && unfinished)
-      throw new JournalMaintenanceError("recovery_pending", journal.target);
-    if (options.action !== "status") {
-      await maintenance.recover();
-      if (options.action === "reconcile")
-        await journal.reconcilePending(cloud);
-      await verifyJournalAuthority(journal, cloud);
-    }
-    const sweep = options.action === "maintain" ? await maintenance.maintain(options.limit) : { retired: 0 };
-    return { schema: "economy.ingest-journal.v1", action: options.action, ...journal.status(), ...sweep };
-  });
-}
-
-// src/lib/ingest-journal-client.ts
 async function ingestJournal(input) {
   const operation = ingestJournalOperationSchema.parse(input);
   const cloud = economyCloudStorage();
@@ -2190,7 +1448,7 @@ async function ingestJournal(input) {
   return runIngestJournalOperation(cloud, operation);
 }
 function ingestJournalError(error) {
-  if (error instanceof z2.ZodError)
+  if (error instanceof z.ZodError)
     return { error: {
       code: "INVALID_JOURNAL_OPERATION",
       message: "Use status or reconcile without controls, or maintain with confirm=true and limit 1\u201332.",
@@ -2367,300 +1625,6 @@ function registerBriefCommand(program, deps = {}) {
   });
 }
 
-// src/lib/cloud-ingest.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname, join as join5 } from "path";
-
-// src/lib/sync-maintenance.ts
-function backfillMachineId(db) {
-  const machine = getMachineId();
-  const reqCount = db.prepare(`UPDATE requests SET machine_id = ? WHERE (machine_id = '' OR machine_id IS NULL)
-    AND NOT EXISTS (SELECT 1 FROM economy_legacy_active a WHERE a.request_id = requests.id)`).run(machine);
-  const sessCount = db.prepare(`UPDATE sessions SET machine_id = ? WHERE machine_id = '' OR machine_id IS NULL`).run(machine);
-  return { requests: Number(reqCount.changes), sessions: Number(sessCount.changes) };
-}
-async function recalculateZeroCostRequests(db) {
-  const { assessCostFromDb } = await import("../chunks/pricing-bn88mhqk.js");
-  const zeroRows = db.prepare(`SELECT id, model, input_tokens, output_tokens, cache_read_tokens, cache_create_tokens, cache_create_5m_tokens, cache_create_1h_tokens
-     FROM requests
-     WHERE cost_usd = 0
-       AND NOT EXISTS (SELECT 1 FROM economy_legacy_active a WHERE a.request_id = requests.id)
-       AND (input_tokens > 0 OR output_tokens > 0 OR cache_read_tokens > 0 OR cache_create_tokens > 0)`).all();
-  let fixed = 0;
-  for (const r of zeroRows) {
-    const cache5m = r.cache_create_5m_tokens ?? r.cache_create_tokens;
-    const assessment = assessCostFromDb(db, r.model, r.input_tokens, r.output_tokens, r.cache_read_tokens, cache5m, r.cache_create_1h_tokens ?? 0);
-    const cost = assessment.usd;
-    if (cost !== null && cost > 0) {
-      db.prepare(`UPDATE requests SET cost_usd = ?, cost_basis = CASE WHEN cost_basis = 'unknown' THEN 'estimated' ELSE cost_basis END WHERE id = ?`).run(cost, r.id);
-      fixed++;
-    }
-  }
-  if (fixed > 0) {
-    const touchedSessions = new Set(zeroRows.map((r) => {
-      const row = db.prepare(`SELECT session_id FROM requests WHERE id = ?`).get(r.id);
-      return row?.session_id;
-    }).filter(Boolean));
-    for (const sid of touchedSessions)
-      rollupSession(db, sid);
-  }
-  return { fixed, total: zeroRows.length, buckets: queryZeroCostTokenizedModels(db, 8) };
-}
-
-// src/lib/ingest-batches.ts
-import { createHash as createHash3 } from "crypto";
-function* ingestBatches(body) {
-  let rows = {};
-  let count = 0;
-  let bytes = 0;
-  const finish = () => {
-    const digest2 = createHash3("sha256").update(stableJson(rows)).digest("hex");
-    const batch = { ...rows, schema_version: 1, idempotency_key: `scan-${digest2}` };
-    rows = {};
-    count = 0;
-    bytes = 0;
-    if (Buffer.byteLength(JSON.stringify(batch)) > MAX_INGEST_BYTES)
-      throw new Error("Ingest batch exceeds the server byte limit");
-    return batch;
-  };
-  const rowLimit = Math.min(MAX_INGEST_ROWS, 500);
-  const byteLimit = MAX_INGEST_BYTES - 4096;
-  for (const table2 of Object.keys(body).sort()) {
-    const sorted = body[table2].map((row) => ({ row, canonical: stableJson(row) })).sort((a, b) => a.canonical < b.canonical ? -1 : a.canonical > b.canonical ? 1 : 0);
-    for (const { row, canonical } of sorted) {
-      const size = Buffer.byteLength(canonical) + 1;
-      if (size > byteLimit)
-        throw new Error("One ingestion row exceeds the server byte limit");
-      if (count > 0 && (count >= rowLimit || bytes + size > byteLimit))
-        yield finish();
-      (rows[table2] ??= []).push(row);
-      count++;
-      bytes += size;
-    }
-  }
-  if (count > 0)
-    yield finish();
-}
-
-class IngestBatchFailure extends Error {
-  pending_key;
-  completed;
-  pending_command;
-  constructor(pending_key, completed, pending_command) {
-    super("Ingest batch did not return a verified receipt; retain the exact staged command and reconcile before retrying");
-    this.pending_key = pending_key;
-    this.completed = completed;
-    this.pending_command = pending_command;
-    this.name = "IngestBatchFailure";
-  }
-}
-
-// src/lib/cloud-ingest.ts
-import { HasnaHttpError as HasnaHttpError2 } from "@hasna/contracts/client";
-var CLOUD_INGEST_TABLES = ["requests", "sessions", "billing_daily", "usage_snapshots", "subscriptions", "scan_receipts"];
-function getIngestCachePath() {
-  if (process.env["HASNA_ECONOMY_INGEST_CACHE"])
-    return process.env["HASNA_ECONOMY_INGEST_CACHE"];
-  const home = process.env["HOME"] || process.env["USERPROFILE"] || undefined;
-  return join5(cacheDir({ app: "economy", home }), "ingest-cache.json");
-}
-function readIngestCache(path) {
-  let text;
-  try {
-    text = readFileSync3(path, "utf8");
-  } catch {
-    return [];
-  }
-  try {
-    const parsed = JSON.parse(text);
-    const rows = Array.isArray(parsed?.ingest_state) ? parsed.ingest_state : [];
-    return rows.filter((row) => typeof row === "object" && row !== null && typeof row.source === "string" && typeof row.key === "string" && typeof row.value === "string");
-  } catch {
-    return [];
-  }
-}
-function writeIngestCache(path, rows) {
-  mkdirSync2(dirname(path), { recursive: true });
-  const tmp = `${path}.${process.pid}.tmp`;
-  writeFileSync2(tmp, JSON.stringify({ version: 1, ingest_state: rows }), { mode: 384 });
-  renameSync(tmp, path);
-}
-function loadIngestState(scratch, rows) {
-  scratch.prepare(`DELETE FROM ingest_state`).run();
-  const insert = scratch.prepare(`INSERT INTO ingest_state (source, key, value) VALUES (?, ?, ?)`);
-  for (const row of rows)
-    insert.run(row.source, row.key, row.value);
-}
-function dumpIngestState(scratch) {
-  return scratch.prepare(`SELECT source, key, value FROM ingest_state`).all();
-}
-function exportIngestRows(db) {
-  const body = {};
-  for (const table2 of CLOUD_INGEST_TABLES) {
-    const rows = db.prepare(`SELECT * FROM ${table2}`).all();
-    if (rows.length > 0)
-      body[table2] = rows;
-  }
-  return body;
-}
-
-class IngestRefused extends Error {
-  status;
-  code;
-  reason;
-  constructor(status, code, reason = code) {
-    super(`Ingestion refused: ${reason}; exact command intent retained`);
-    this.status = status;
-    this.code = code;
-    this.reason = reason;
-    this.name = "IngestRefused";
-  }
-}
-async function postIngest(cloud, body) {
-  const journal = new IngestJournal(cloud);
-  return withIngestJournalLock(journal.directory, async () => {
-    const maintenance = new IngestJournalMaintenance(journal, cloud);
-    await maintenance.recover();
-    await journal.reconcilePending(cloud);
-    await verifyJournalAuthority(journal, cloud);
-    const ingested = {};
-    const completed = [];
-    let total = 0;
-    for (const batch of ingestBatches(body)) {
-      try {
-        const refused = journal.refusal(batch);
-        if (refused)
-          throw new IngestRefused(refused.status, refused.code, refused.reason);
-        await maintenance.admit(batch);
-        const known = await journal.lookupReceipt(cloud, batch);
-        const fresh = journal.stage(batch);
-        const sendFresh = async () => {
-          let response;
-          try {
-            response = await cloud.client.transport.post("/ingest", batch, { retry: false });
-          } catch (error) {
-            const refusal = error instanceof HasnaHttpError2 ? definitiveIngestRefusal(error.status, error.body) : null;
-            if (refusal) {
-              journal.recordRefusal(batch, refusal);
-              throw new IngestRefused(refusal.status, refusal.code, refusal.reason);
-            }
-            throw error;
-          }
-          return journal.accept(batch, response);
-        };
-        const payload = known ? journal.accept(batch, known) : fresh ? await sendFresh() : await journal.reconcileCommand(cloud, batch);
-        await verifyJournalAuthority(journal, cloud);
-        if (!payload)
-          throw new PendingIngestError([batch.idempotency_key]);
-        verifyIngestReceipt(payload, batch);
-        const counts = payload["ingested"];
-        if (!counts || typeof counts !== "object" || Array.isArray(counts) || typeof payload["total"] !== "number" || !Number.isSafeInteger(payload["total"]) || payload["total"] < 0)
-          throw new Error("Invalid ingest receipt");
-        let sum = 0;
-        for (const [table2, count] of Object.entries(counts)) {
-          if (!CLOUD_INGEST_TABLES.includes(table2) || typeof count !== "number" || !Number.isSafeInteger(count) || count < 0)
-            throw new Error("Invalid ingest receipt");
-          sum += count;
-          ingested[table2] = (ingested[table2] ?? 0) + count;
-        }
-        if (sum !== payload["total"])
-          throw new Error("Invalid ingest receipt");
-        total += sum;
-        const operation = payload["operation_key"];
-        if (operation !== undefined && (typeof operation !== "string" || !/^[a-f0-9]{64}$/.test(operation)))
-          throw new Error("Invalid ingest receipt");
-        completed.push({
-          idempotency_key: batch.idempotency_key,
-          ...typeof operation === "string" ? { operation_key: operation } : {},
-          replayed: payload["replayed"] === true
-        });
-      } catch (error) {
-        if (error instanceof PendingIngestError || error instanceof JournalMaintenanceError || error instanceof IngestRefused)
-          throw error;
-        if (error instanceof HasnaHttpError2 && error.status >= 400 && error.status < 500 && error.status !== 408) {
-          const body2 = error.body;
-          throw new IngestRefused(error.status, body2?.expected === "legacy_aggregate_requires_migration" ? "legacy_aggregate_requires_migration" : "ingest_refused");
-        }
-        throw new IngestBatchFailure(batch.idempotency_key, completed, batch);
-      }
-    }
-    return { ingested, total, receipts: completed };
-  });
-}
-async function syncAllToCloud(cloud, opts = {}) {
-  await runIngestJournalOperation(cloud, { action: "reconcile" });
-  const { openDatabase } = await import("../chunks/sqlite-store-r219qrjt.js");
-  const scratch = openDatabase(":memory:", true);
-  ensurePricingSeeded(scratch);
-  const cachePath = opts.cachePath ?? getIngestCachePath();
-  try {
-    loadIngestState(scratch, opts.force ? [] : readIngestCache(cachePath));
-    const result = await syncAll(scratch, { ...opts, noCrossAppLocalReads: true });
-    if (opts.backfillMachine)
-      backfillMachineId(scratch);
-    if (opts.recalculate)
-      await recalculateZeroCostRequests(scratch);
-    const body = exportIngestRows(scratch);
-    if (Object.keys(body).length === 0) {
-      writeIngestCache(cachePath, dumpIngestState(scratch));
-      return { ...result, posted: false };
-    }
-    const response = await postIngest(cloud, body);
-    writeIngestCache(cachePath, dumpIngestState(scratch));
-    return { ...result, posted: true, ...response };
-  } finally {
-    try {
-      scratch.close();
-    } catch {}
-  }
-}
-async function billingSyncToCloud(cloud, opts = {}) {
-  await runIngestJournalOperation(cloud, { action: "reconcile" });
-  const { openDatabase } = await import("../chunks/sqlite-store-r219qrjt.js");
-  const scratch = openDatabase(":memory:", true);
-  try {
-    const days = opts.days ?? 31;
-    const providers = {};
-    const attempts = [
-      ["anthropic", () => syncAnthropicBilling(scratch, { days })],
-      ["openai", () => syncOpenAIBilling(scratch, { days })],
-      ["gemini", () => syncGeminiBilling(scratch, { days })]
-    ];
-    const anySelected = opts.anthropic || opts.openai || opts.gemini;
-    let totalUsd = 0;
-    for (const [provider, run] of attempts) {
-      if (anySelected && !opts[provider])
-        continue;
-      {
-        try {
-          const r = await run();
-          providers[provider] = { ok: true, days: r.days, totalUsd: r.totalUsd };
-          totalUsd += r.totalUsd;
-        } catch {
-          providers[provider] = { ok: false, error: "provider_billing_collection_failed" };
-        }
-      }
-    }
-    const body = exportIngestRows(scratch);
-    if (Object.keys(body).length === 0)
-      return { providers, totalUsd, posted: false };
-    const response = await postIngest(cloud, body);
-    return { providers, totalUsd, posted: true, ...response };
-  } finally {
-    try {
-      scratch.close();
-    } catch {}
-  }
-}
-
-// src/lib/sync-report.ts
-function syncHasFailures(result) {
-  return result.collections?.some((row) => row.status === "failed" || row.status === "unsupported") ?? false;
-}
-function syncOutcomeLines(result) {
-  return (result.collections ?? []).map((row) => `${row.source}: ${row.status}${row.error_code ? ` (${row.error_code})` : ""}`);
-}
-
 // src/lib/autosync-gate.ts
 var AUTOSYNC_STATE_SOURCE = "autosync";
 var AUTOSYNC_STATE_KEY = "last_run";
@@ -2698,7 +1662,7 @@ async function autoSyncDue(db, env = process.env) {
 }
 
 // src/lib/contracts-client/transport.ts
-import { HasnaHttpError as HasnaHttpError3 } from "@hasna/contracts/client";
+import { HasnaHttpError } from "@hasna/contracts/client";
 
 // src/cli/index.ts
 var program = new Command;
@@ -3242,13 +2206,15 @@ program.command("accounts [period]").description("List account usage by email ad
   printHiddenRowsHint(rows.length, visibleRows.length, "Use --limit <n>, --verbose, or --json.");
   console.log();
 });
-program.command("watch").description("Live stream of incoming costs").option("--interval <seconds>", "Poll interval in seconds", "10").option("--daemon", "Watch agent data directories and sync on change").option("--agent <agent>", `Filter by agent (${AGENTS.join("|")})`).option("--notify <amount>", "Fire macOS notification when cumulative cost crosses this USD threshold").action(async (opts) => {
-  const { watchCosts } = await import("../chunks/watch-7pf8xj1q.js");
+program.command("watch").description("Live stream of incoming costs").option("--interval <seconds>", "Poll interval in seconds", "10").option("--daemon", "Watch agent data directories and sync on change").option("--sync-interval <seconds>", "Minimum collection interval and fallback scan interval for --daemon", "60").option("--agent <agent>", `Filter by agent (${AGENTS.join("|")})`).option("--notify <amount>", "Fire macOS notification when cumulative cost crosses this USD threshold").option("--no-notifications", "Disable desktop notifications, including high-cost notices").action(async (opts) => {
+  const { watchCosts } = await import("../chunks/watch-ewed2srf.js");
   await watchCosts({
     interval: parsePositiveCliInteger(opts.interval ?? "10", "--interval"),
     daemon: Boolean(opts.daemon),
+    syncInterval: parsePositiveCliInteger(opts.syncInterval ?? "60", "--sync-interval"),
     agent: parseOptionalCliAgent(opts.agent),
-    notify: opts.notify ? parsePositiveCliNumber(opts.notify, "--notify") : undefined
+    notify: opts.notify ? parsePositiveCliNumber(opts.notify, "--notify") : undefined,
+    notifications: opts.notifications
   });
 });
 var budgetCmd = program.command("budget").description("Manage spending budgets");
@@ -3479,7 +2445,7 @@ pricingCmd.command("remove <model>").description("Remove pricing for a model").a
 });
 program.command("serve").description("Start the REST API server").option("-p, --port <port>", "Port", "3456").action(async (opts) => {
   const port = parseCliPort(opts.port ?? "3456", "--port");
-  const { startServer } = await import("../chunks/serve-bqn5j46v.js");
+  const { startServer } = await import("../chunks/serve-kk3n0p7j.js");
   startServer(port);
 });
 program.command("mcp").description("Show MCP server install commands").option("--claude", "Install into Claude Code").option("--codex", "Install into Codex").option("--gemini", "Install into Gemini CLI").option("--all", "Install into all agents").action(async (opts) => {
@@ -3594,8 +2560,8 @@ program.command("export").description("Export data as CSV").option("--type <type
     }
   }
   if (opts.output) {
-    const { writeFileSync: writeFileSync3 } = await import("fs");
-    writeFileSync3(opts.output, csv);
+    const { writeFileSync } = await import("fs");
+    writeFileSync(opts.output, csv);
     console.log(chalk3.green(`\u2713 Exported to ${opts.output}`));
   } else {
     process.stdout.write(csv);
@@ -3900,7 +2866,7 @@ registerJournalCommands(program);
 registerFleetCommands(program);
 registerEventsCommands(program, { source: "economy" });
 function reportCliError(err) {
-  if (err instanceof HasnaHttpError3) {
+  if (err instanceof HasnaHttpError) {
     if (err.status === 404) {
       fail(`economy: the cloud API has no endpoint for this command (${err.method} ${err.path} -> 404). ` + `The economy API server is likely running an older build \u2014 it needs a redeploy of the current version.`);
     }