@agent-receipts/dashboard 0.2.6 → 0.2.8

package/standalone/packages/mcp-server/dist/index.js

@@ -0,0 +1,1738 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/storage/sqlite-receipt-store.ts
+import { readdir, mkdir } from "fs/promises";
+import { join } from "path";
+import Database from "better-sqlite3";
+var SORTABLE_COLUMNS = /* @__PURE__ */ new Set([
+  "timestamp",
+  "completed_at",
+  "cost_usd",
+  "latency_ms",
+  "tokens_in",
+  "tokens_out",
+  "confidence"
+]);
+var SqliteReceiptStore = class {
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+    this.dbPath = join(dataDir, "receipts.db");
+    this.receiptsDir = join(dataDir, "receipts");
+  }
+  dbPath;
+  receiptsDir;
+  db;
+  async init() {
+    await mkdir(this.dataDir, { recursive: true });
+    this.db = new Database(this.dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS receipts (
+        receipt_id TEXT PRIMARY KEY,
+        chain_id TEXT NOT NULL,
+        parent_receipt_id TEXT,
+        receipt_type TEXT NOT NULL,
+        agent_id TEXT NOT NULL,
+        org_id TEXT NOT NULL,
+        action TEXT NOT NULL,
+        status TEXT NOT NULL,
+        environment TEXT NOT NULL,
+        input_hash TEXT NOT NULL,
+        output_hash TEXT,
+        model TEXT,
+        tokens_in INTEGER,
+        tokens_out INTEGER,
+        cost_usd REAL,
+        latency_ms INTEGER,
+        confidence REAL,
+        timestamp TEXT NOT NULL,
+        completed_at TEXT,
+        expires_at TEXT,
+        tags TEXT,
+        data TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_receipts_agent_id ON receipts(agent_id);
+      CREATE INDEX IF NOT EXISTS idx_receipts_chain_id ON receipts(chain_id);
+      CREATE INDEX IF NOT EXISTS idx_receipts_status ON receipts(status);
+      CREATE INDEX IF NOT EXISTS idx_receipts_action ON receipts(action);
+      CREATE INDEX IF NOT EXISTS idx_receipts_timestamp ON receipts(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_receipts_environment ON receipts(environment);
+      CREATE INDEX IF NOT EXISTS idx_receipts_receipt_type ON receipts(receipt_type);
+      CREATE INDEX IF NOT EXISTS idx_receipts_expires_at ON receipts(expires_at);
+      CREATE INDEX IF NOT EXISTS idx_receipts_parent_receipt_id ON receipts(parent_receipt_id);
+    `);
+    await this.migrateJsonFiles();
+  }
+  async migrateJsonFiles() {
+    let files;
+    try {
+      files = await readdir(this.receiptsDir);
+    } catch {
+      return;
+    }
+    const jsonFiles = files.filter((f) => f.endsWith(".json") && !f.startsWith("."));
+    if (jsonFiles.length === 0) return;
+    const insert = this.db.prepare(`INSERT OR IGNORE INTO receipts (
+      receipt_id, chain_id, parent_receipt_id, receipt_type, agent_id, org_id,
+      action, status, environment, input_hash, output_hash, model,
+      tokens_in, tokens_out, cost_usd, latency_ms, confidence,
+      timestamp, completed_at, expires_at, tags, data
+    ) VALUES (
+      @receipt_id, @chain_id, @parent_receipt_id, @receipt_type, @agent_id, @org_id,
+      @action, @status, @environment, @input_hash, @output_hash, @model,
+      @tokens_in, @tokens_out, @cost_usd, @latency_ms, @confidence,
+      @timestamp, @completed_at, @expires_at, @tags, @data
+    )`);
+    let migrated = 0;
+    const tx = this.db.transaction(() => {
+      for (const file of jsonFiles) {
+        try {
+          const fs = __require("fs");
+          const raw = fs.readFileSync(join(this.receiptsDir, file), "utf-8");
+          const receipt = JSON.parse(raw);
+          insert.run(this.toRow(receipt));
+          migrated++;
+        } catch {
+        }
+      }
+    });
+    tx();
+    if (migrated > 0) {
+      console.log(`Migrated ${migrated} receipts from JSON files to SQLite`);
+    }
+  }
+  toRow(receipt) {
+    const meta = receipt.metadata;
+    return {
+      receipt_id: receipt.receipt_id,
+      chain_id: receipt.chain_id,
+      parent_receipt_id: receipt.parent_receipt_id,
+      receipt_type: receipt.receipt_type,
+      agent_id: receipt.agent_id,
+      org_id: receipt.org_id,
+      action: receipt.action,
+      status: receipt.status,
+      environment: receipt.environment,
+      input_hash: receipt.input_hash,
+      output_hash: receipt.output_hash,
+      model: receipt.model,
+      tokens_in: receipt.tokens_in,
+      tokens_out: receipt.tokens_out,
+      cost_usd: receipt.cost_usd,
+      latency_ms: receipt.latency_ms,
+      confidence: receipt.confidence,
+      timestamp: receipt.timestamp,
+      completed_at: receipt.completed_at,
+      expires_at: meta?.expires_at ?? null,
+      tags: receipt.tags ? JSON.stringify(receipt.tags) : null,
+      data: JSON.stringify(receipt)
+    };
+  }
+  async save(receipt) {
+    const row = this.toRow(receipt);
+    this.db.prepare(`INSERT OR REPLACE INTO receipts (
+      receipt_id, chain_id, parent_receipt_id, receipt_type, agent_id, org_id,
+      action, status, environment, input_hash, output_hash, model,
+      tokens_in, tokens_out, cost_usd, latency_ms, confidence,
+      timestamp, completed_at, expires_at, tags, data
+    ) VALUES (
+      @receipt_id, @chain_id, @parent_receipt_id, @receipt_type, @agent_id, @org_id,
+      @action, @status, @environment, @input_hash, @output_hash, @model,
+      @tokens_in, @tokens_out, @cost_usd, @latency_ms, @confidence,
+      @timestamp, @completed_at, @expires_at, @tags, @data
+    )`).run(row);
+  }
+  async get(receiptId) {
+    const row = this.db.prepare("SELECT data FROM receipts WHERE receipt_id = ?").get(receiptId);
+    if (!row) return null;
+    return JSON.parse(row.data);
+  }
+  async exists(receiptId) {
+    const row = this.db.prepare("SELECT 1 FROM receipts WHERE receipt_id = ?").get(receiptId);
+    return row !== void 0;
+  }
+  async list(filter, page = 1, limit = 50, sort = "timestamp:desc") {
+    const { where, params } = this.buildWhere(filter);
+    const countRow = this.db.prepare(`SELECT COUNT(*) as cnt FROM receipts ${where}`).get(...params);
+    const total = countRow.cnt;
+    const [sortField, sortDir] = sort.split(":");
+    const col = sortField === "created_at" ? "timestamp" : sortField;
+    const safeCol = SORTABLE_COLUMNS.has(col) ? col : "timestamp";
+    const dir = sortDir === "asc" ? "ASC" : "DESC";
+    const orderClause = `ORDER BY CASE WHEN ${safeCol} IS NULL THEN 1 ELSE 0 END, ${safeCol} ${dir}`;
+    const offset = (page - 1) * limit;
+    const rows = this.db.prepare(
+      `SELECT data FROM receipts ${where} ${orderClause} LIMIT ? OFFSET ?`
+    ).all(...params, limit, offset);
+    const totalPages = Math.max(1, Math.ceil(total / limit));
+    return {
+      data: rows.map((r) => JSON.parse(r.data)),
+      pagination: {
+        page,
+        limit,
+        total,
+        total_pages: totalPages,
+        has_next: page < totalPages,
+        has_prev: page > 1
+      }
+    };
+  }
+  async getChain(chainId) {
+    const result = await this.list({ chain_id: chainId }, 1, 1e3, "timestamp:asc");
+    return result.data;
+  }
+  async count(filter) {
+    const { where, params } = this.buildWhere(filter);
+    const row = this.db.prepare(`SELECT COUNT(*) as cnt FROM receipts ${where}`).get(...params);
+    return row.cnt;
+  }
+  async delete(receiptId) {
+    const result = this.db.prepare("DELETE FROM receipts WHERE receipt_id = ?").run(receiptId);
+    return result.changes > 0;
+  }
+  async cleanup() {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const totalRow = this.db.prepare("SELECT COUNT(*) as cnt FROM receipts").get();
+    const total = totalRow.cnt;
+    const result = this.db.prepare(
+      "DELETE FROM receipts WHERE expires_at IS NOT NULL AND expires_at < ?"
+    ).run(now);
+    return { deleted: result.changes, total };
+  }
+  buildWhere(filter) {
+    if (!filter) return { where: "", params: [] };
+    const conditions = [];
+    const params = [];
+    if (filter.agent_id) {
+      conditions.push("agent_id = ?");
+      params.push(filter.agent_id);
+    }
+    if (filter.action) {
+      conditions.push("action = ?");
+      params.push(filter.action);
+    }
+    if (filter.status) {
+      conditions.push("status = ?");
+      params.push(filter.status);
+    }
+    if (filter.environment) {
+      conditions.push("environment = ?");
+      params.push(filter.environment);
+    }
+    if (filter.receipt_type) {
+      conditions.push("receipt_type = ?");
+      params.push(filter.receipt_type);
+    }
+    if (filter.chain_id) {
+      conditions.push("chain_id = ?");
+      params.push(filter.chain_id);
+    }
+    if (filter.parent_receipt_id) {
+      conditions.push("parent_receipt_id = ?");
+      params.push(filter.parent_receipt_id);
+    }
+    if (filter.tag) {
+      conditions.push("tags LIKE ?");
+      params.push(`%"${filter.tag}"%`);
+    }
+    if (filter.from) {
+      conditions.push("timestamp >= ?");
+      params.push(filter.from);
+    }
+    if (filter.to) {
+      conditions.push("timestamp <= ?");
+      params.push(filter.to);
+    }
+    if (conditions.length === 0) return { where: "", params: [] };
+    return { where: `WHERE ${conditions.join(" AND ")}`, params };
+  }
+};
+
+// src/storage/receipt-store.ts
+import { readdir as readdir2, readFile as readFile2, writeFile, rename, mkdir as mkdir2, unlink } from "fs/promises";
+import { join as join2 } from "path";
+import { randomBytes } from "crypto";
+var ReceiptStore = class {
+  receiptsDir;
+  constructor(dataDir) {
+    this.receiptsDir = join2(dataDir, "receipts");
+  }
+  async init() {
+    await mkdir2(this.receiptsDir, { recursive: true });
+  }
+  async save(receipt) {
+    await this.init();
+    const filePath = join2(this.receiptsDir, `${receipt.receipt_id}.json`);
+    const tmpPath = join2(this.receiptsDir, `.tmp_${randomBytes(8).toString("hex")}.json`);
+    const data = JSON.stringify(receipt, null, 2);
+    await writeFile(tmpPath, data, "utf-8");
+    await rename(tmpPath, filePath);
+  }
+  async get(receiptId) {
+    try {
+      const filePath = join2(this.receiptsDir, `${receiptId}.json`);
+      const data = await readFile2(filePath, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async exists(receiptId) {
+    const receipt = await this.get(receiptId);
+    return receipt !== null;
+  }
+  async list(filter, page = 1, limit = 50, sort = "timestamp:desc") {
+    await this.init();
+    const files = await readdir2(this.receiptsDir);
+    const receiptFiles = files.filter((f) => f.endsWith(".json") && !f.startsWith("."));
+    let receipts = [];
+    for (const file of receiptFiles) {
+      try {
+        const data = await readFile2(join2(this.receiptsDir, file), "utf-8");
+        receipts.push(JSON.parse(data));
+      } catch {
+      }
+    }
+    if (filter) {
+      receipts = receipts.filter((r) => {
+        if (filter.agent_id && r.agent_id !== filter.agent_id) return false;
+        if (filter.action && r.action !== filter.action) return false;
+        if (filter.status && r.status !== filter.status) return false;
+        if (filter.environment && r.environment !== filter.environment) return false;
+        if (filter.receipt_type && r.receipt_type !== filter.receipt_type) return false;
+        if (filter.chain_id && r.chain_id !== filter.chain_id) return false;
+        if (filter.parent_receipt_id && r.parent_receipt_id !== filter.parent_receipt_id) return false;
+        if (filter.tag && (!r.tags || !r.tags.includes(filter.tag))) return false;
+        if (filter.from && r.timestamp < filter.from) return false;
+        if (filter.to && r.timestamp > filter.to) return false;
+        return true;
+      });
+    }
+    const [sortField, sortDir] = sort.split(":");
+    receipts.sort((a, b) => {
+      const aVal = a[sortField === "created_at" ? "timestamp" : sortField];
+      const bVal = b[sortField === "created_at" ? "timestamp" : sortField];
+      if (aVal === null || aVal === void 0) return 1;
+      if (bVal === null || bVal === void 0) return -1;
+      const cmp = String(aVal).localeCompare(String(bVal));
+      return sortDir === "desc" ? -cmp : cmp;
+    });
+    const total = receipts.length;
+    const totalPages = Math.max(1, Math.ceil(total / limit));
+    const start = (page - 1) * limit;
+    const paged = receipts.slice(start, start + limit);
+    return {
+      data: paged,
+      pagination: {
+        page,
+        limit,
+        total,
+        total_pages: totalPages,
+        has_next: page < totalPages,
+        has_prev: page > 1
+      }
+    };
+  }
+  async getChain(chainId) {
+    const result = await this.list({ chain_id: chainId }, 1, 1e3, "timestamp:asc");
+    return result.data;
+  }
+  async count(filter) {
+    const result = await this.list(filter, 1, 1);
+    return result.pagination.total;
+  }
+  async delete(receiptId) {
+    try {
+      const filePath = join2(this.receiptsDir, `${receiptId}.json`);
+      await unlink(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async cleanup() {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const allReceipts = await this.list(void 0, 1, 1e5);
+    let deleted = 0;
+    for (const receipt of allReceipts.data) {
+      const expiresAt = receipt.metadata?.expires_at;
+      if (expiresAt && expiresAt < now) {
+        await this.delete(receipt.receipt_id);
+        deleted++;
+      }
+    }
+    return { deleted, total: allReceipts.data.length };
+  }
+};
+
+// src/storage/key-manager.ts
+import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir3, chmod } from "fs/promises";
+import { join as join3 } from "path";
+import { generateKeyPair, getPublicKeyFromPrivate } from "@agent-receipts/crypto";
+var KeyManager = class {
+  keysDir;
+  privateKey = null;
+  publicKey = null;
+  constructor(dataDir) {
+    this.keysDir = join3(dataDir, "keys");
+  }
+  async init() {
+    await mkdir3(this.keysDir, { recursive: true });
+    await this.loadKeys();
+  }
+  async loadKeys() {
+    const envKey = process.env["RECEIPT_SIGNING_PRIVATE_KEY"];
+    if (envKey) {
+      this.privateKey = envKey;
+      this.publicKey = getPublicKeyFromPrivate(envKey);
+      return;
+    }
+    const privateKeyPath = join3(this.keysDir, "private.key");
+    try {
+      this.privateKey = (await readFile3(privateKeyPath, "utf-8")).trim();
+      this.publicKey = getPublicKeyFromPrivate(this.privateKey);
+      return;
+    } catch {
+    }
+    const keyPair = generateKeyPair();
+    this.privateKey = keyPair.privateKey;
+    this.publicKey = keyPair.publicKey;
+    await writeFile2(privateKeyPath, this.privateKey, { encoding: "utf-8", mode: 384 });
+    await chmod(privateKeyPath, 384);
+    const publicKeyPath = join3(this.keysDir, "public.key");
+    await writeFile2(publicKeyPath, this.publicKey, "utf-8");
+  }
+  getPrivateKey() {
+    if (!this.privateKey) {
+      throw new Error("KeyManager not initialized \u2014 call init() first");
+    }
+    return this.privateKey;
+  }
+  getPublicKey() {
+    if (!this.publicKey) {
+      throw new Error("KeyManager not initialized \u2014 call init() first");
+    }
+    return this.publicKey;
+  }
+};
+
+// src/storage/config-manager.ts
+import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir4 } from "fs/promises";
+import { join as join4, dirname } from "path";
+import { homedir } from "os";
+var DEFAULT_CONFIG = {
+  agentId: "local-agent",
+  orgId: "local-org",
+  environment: "production"
+};
+var ConfigManager = class {
+  configPath;
+  config = { ...DEFAULT_CONFIG };
+  constructor(dataDir) {
+    this.configPath = join4(dataDir, "config.json");
+  }
+  async init() {
+    await mkdir4(dirname(this.configPath), { recursive: true });
+    await this.load();
+  }
+  async load() {
+    try {
+      const data = await readFile4(this.configPath, "utf-8");
+      const saved = JSON.parse(data);
+      this.config = { ...DEFAULT_CONFIG, ...saved };
+    } catch {
+    }
+    const envAgentId = process.env["AGENT_RECEIPTS_AGENT_ID"];
+    if (envAgentId) this.config.agentId = envAgentId;
+    const envOrgId = process.env["AGENT_RECEIPTS_ORG_ID"];
+    if (envOrgId) this.config.orgId = envOrgId;
+    const envEnvironment = process.env["AGENT_RECEIPTS_ENVIRONMENT"];
+    if (envEnvironment === "development" || envEnvironment === "production" || envEnvironment === "staging" || envEnvironment === "test") {
+      this.config.environment = envEnvironment;
+    }
+  }
+  async save() {
+    await mkdir4(dirname(this.configPath), { recursive: true });
+    await writeFile3(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  async update(partial) {
+    this.config = { ...this.config, ...partial };
+    await this.save();
+  }
+  static getDefaultDataDir() {
+    return process.env["AGENT_RECEIPTS_DATA_DIR"] ?? join4(homedir(), ".agent-receipts");
+  }
+};
+
+// src/engine/receipt-engine.ts
+import { nanoid } from "nanoid";
+import { ActionReceipt } from "@agent-receipts/schema";
+import { signReceipt, verifyReceipt, getSignablePayload } from "@agent-receipts/crypto";
+
+// src/hash.ts
+import { createHash } from "crypto";
+function deepCanonicalize(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(deepCanonicalize);
+  }
+  if (typeof value === "object") {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+      sorted[key] = deepCanonicalize(value[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function hashData(data) {
+  const canonical = JSON.stringify(deepCanonicalize(data)) ?? "null";
+  const hash = createHash("sha256").update(canonical).digest("hex");
+  return `sha256:${hash}`;
+}
+
+// src/engine/json-schema-validator.ts
+function validateJsonSchema(data, schema, path = "") {
+  const errors = [];
+  if (Object.keys(schema).length === 0) {
+    return errors;
+  }
+  if (schema.type !== void 0) {
+    const expectedType = schema.type;
+    if (!checkType(data, expectedType)) {
+      errors.push(`${path || "."}: expected type ${expectedType}, got ${getType(data)}`);
+      return errors;
+    }
+  }
+  if (schema.enum !== void 0) {
+    const allowed = schema.enum;
+    if (!allowed.some((v) => JSON.stringify(v) === JSON.stringify(data))) {
+      errors.push(`${path || "."}: value ${JSON.stringify(data)} not in enum ${JSON.stringify(allowed)}`);
+    }
+  }
+  if (typeof data === "string") {
+    if (schema.minLength !== void 0 && data.length < schema.minLength) {
+      errors.push(`${path || "."}: string length ${data.length} < minLength ${schema.minLength}`);
+    }
+    if (schema.maxLength !== void 0 && data.length > schema.maxLength) {
+      errors.push(`${path || "."}: string length ${data.length} > maxLength ${schema.maxLength}`);
+    }
+    if (schema.pattern !== void 0) {
+      const regex = new RegExp(schema.pattern);
+      if (!regex.test(data)) {
+        errors.push(`${path || "."}: string does not match pattern ${schema.pattern}`);
+      }
+    }
+  }
+  if (typeof data === "number") {
+    if (schema.minimum !== void 0 && data < schema.minimum) {
+      errors.push(`${path || "."}: ${data} < minimum ${schema.minimum}`);
+    }
+    if (schema.maximum !== void 0 && data > schema.maximum) {
+      errors.push(`${path || "."}: ${data} > maximum ${schema.maximum}`);
+    }
+  }
+  if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+    const obj = data;
+    if (schema.required !== void 0) {
+      const required = schema.required;
+      for (const key of required) {
+        if (!(key in obj)) {
+          errors.push(`${path || "."}: missing required property "${key}"`);
+        }
+      }
+    }
+    if (schema.properties !== void 0) {
+      const props = schema.properties;
+      for (const [key, propSchema] of Object.entries(props)) {
+        if (key in obj) {
+          const propErrors = validateJsonSchema(obj[key], propSchema, `${path}.${key}`);
+          errors.push(...propErrors);
+        }
+      }
+    }
+    if (schema.additionalProperties === false && schema.properties !== void 0) {
+      const allowedKeys = new Set(Object.keys(schema.properties));
+      for (const key of Object.keys(obj)) {
+        if (!allowedKeys.has(key)) {
+          errors.push(`${path || "."}: additional property "${key}" not allowed`);
+        }
+      }
+    }
+  }
+  if (Array.isArray(data)) {
+    if (schema.minItems !== void 0 && data.length < schema.minItems) {
+      errors.push(`${path || "."}: array length ${data.length} < minItems ${schema.minItems}`);
+    }
+    if (schema.maxItems !== void 0 && data.length > schema.maxItems) {
+      errors.push(`${path || "."}: array length ${data.length} > maxItems ${schema.maxItems}`);
+    }
+    if (schema.items !== void 0) {
+      const itemSchema = schema.items;
+      for (let i = 0; i < data.length; i++) {
+        const itemErrors = validateJsonSchema(data[i], itemSchema, `${path}[${i}]`);
+        errors.push(...itemErrors);
+      }
+    }
+  }
+  return errors;
+}
+function checkType(data, expectedType) {
+  switch (expectedType) {
+    case "string":
+      return typeof data === "string";
+    case "number":
+      return typeof data === "number";
+    case "integer":
+      return typeof data === "number" && Number.isInteger(data);
+    case "boolean":
+      return typeof data === "boolean";
+    case "object":
+      return typeof data === "object" && data !== null && !Array.isArray(data);
+    case "array":
+      return Array.isArray(data);
+    case "null":
+      return data === null;
+    default:
+      return false;
+  }
+}
+function getType(data) {
+  if (data === null) return "null";
+  if (Array.isArray(data)) return "array";
+  return typeof data;
+}
+
+// src/engine/constraint-evaluator.ts
+var RECEIPT_FIELD_NAMES = /* @__PURE__ */ new Set([
+  "receipt_id",
+  "parent_receipt_id",
+  "chain_id",
+  "receipt_type",
+  "agent_id",
+  "org_id",
+  "action",
+  "input_hash",
+  "output_hash",
+  "output_summary",
+  "model",
+  "tokens_in",
+  "tokens_out",
+  "cost_usd",
+  "latency_ms",
+  "tool_calls",
+  "timestamp",
+  "completed_at",
+  "status",
+  "error",
+  "environment",
+  "tags",
+  "constraints",
+  "constraint_result",
+  "signature",
+  "verify_url",
+  "callback_verified",
+  "confidence",
+  "metadata"
+]);
+function evaluateMaxLatencyMs(receipt, constraint) {
+  const expected = constraint.value;
+  const actual = receipt.latency_ms;
+  if (actual === null || actual === void 0) {
+    return {
+      type: constraint.type,
+      passed: false,
+      expected,
+      actual: null,
+      message: constraint.message ?? "latency_ms is null"
+    };
+  }
+  return {
+    type: constraint.type,
+    passed: actual <= expected,
+    expected,
+    actual,
+    message: constraint.message
+  };
+}
+function evaluateMaxCostUsd(receipt, constraint) {
+  const expected = constraint.value;
+  const actual = receipt.cost_usd;
+  if (actual === null || actual === void 0) {
+    return {
+      type: constraint.type,
+      passed: false,
+      expected,
+      actual: null,
+      message: constraint.message ?? "cost_usd is null"
+    };
+  }
+  return {
+    type: constraint.type,
+    passed: actual <= expected,
+    expected,
+    actual,
+    message: constraint.message
+  };
+}
+function evaluateMinConfidence(receipt, constraint) {
+  const expected = constraint.value;
+  const actual = receipt.confidence;
+  if (actual === null || actual === void 0) {
+    return {
+      type: constraint.type,
+      passed: false,
+      expected,
+      actual: null,
+      message: constraint.message ?? "confidence is null"
+    };
+  }
+  return {
+    type: constraint.type,
+    passed: actual >= expected,
+    expected,
+    actual,
+    message: constraint.message
+  };
+}
+function evaluateRequiredFields(receipt, constraint) {
+  const fields = constraint.value;
+  if (!Array.isArray(fields)) {
+    return {
+      type: constraint.type,
+      passed: false,
+      expected: fields,
+      actual: null,
+      message: constraint.message ?? "value must be an array of field names"
+    };
+  }
+  const receiptRecord = receipt;
+  const missingFields = [];
+  const unknownFields = [];
+  for (const field of fields) {
+    if (!RECEIPT_FIELD_NAMES.has(field)) {
+      unknownFields.push(field);
+    } else if (receiptRecord[field] === null || receiptRecord[field] === void 0) {
+      missingFields.push(field);
+    }
+  }
+  if (unknownFields.length > 0) {
+    return {
+      type: constraint.type,
+      passed: false,
+      expected: fields,
+      actual: unknownFields,
+      message: constraint.message ?? `Unknown field(s): ${unknownFields.join(", ")}`
+    };
+  }
+  return {
+    type: constraint.type,
+    passed: missingFields.length === 0,
+    expected: fields,
+    actual: missingFields.length > 0 ? missingFields : fields,
+    message: constraint.message ?? (missingFields.length > 0 ? `Missing field(s): ${missingFields.join(", ")}` : void 0)
+  };
+}
+function evaluateStatusMustBe(receipt, constraint) {
+  const expected = constraint.value;
+  const actual = receipt.status;
+  const allowedStatuses = Array.isArray(expected) ? expected : [expected];
+  return {
+    type: constraint.type,
+    passed: allowedStatuses.includes(actual),
+    expected,
+    actual,
+    message: constraint.message
+  };
+}
+function evaluateOutputSchema(constraint, rawOutput) {
+  if (rawOutput === void 0) {
+    return {
+      type: "output_schema",
+      passed: false,
+      expected: constraint.value,
+      actual: null,
+      message: constraint.message ?? "output_schema requires raw output data \u2014 only available during track() or create()"
+    };
+  }
+  const schema = constraint.value;
+  const errors = validateJsonSchema(rawOutput, schema);
+  return {
+    type: "output_schema",
+    passed: errors.length === 0,
+    expected: schema,
+    actual: errors.length > 0 ? errors : rawOutput,
+    message: errors.length > 0 ? constraint.message ?? `Schema validation failed: ${errors.join(", ")}` : void 0
+  };
+}
+function evaluateConstraints(receipt, constraints, context) {
+  if (constraints.length === 0) {
+    return {
+      passed: true,
+      results: [],
+      evaluated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const results = [];
+  for (const constraint of constraints) {
+    let result;
+    switch (constraint.type) {
+      case "max_latency_ms":
+        result = evaluateMaxLatencyMs(receipt, constraint);
+        break;
+      case "max_cost_usd":
+        result = evaluateMaxCostUsd(receipt, constraint);
+        break;
+      case "min_confidence":
+        result = evaluateMinConfidence(receipt, constraint);
+        break;
+      case "required_fields":
+        result = evaluateRequiredFields(receipt, constraint);
+        break;
+      case "status_must_be":
+        result = evaluateStatusMustBe(receipt, constraint);
+        break;
+      case "output_schema":
+        result = evaluateOutputSchema(constraint, context?.rawOutput);
+        break;
+      default:
+        result = {
+          type: constraint.type,
+          passed: false,
+          expected: constraint.value,
+          actual: null,
+          message: constraint.message ?? `Unknown constraint type: ${constraint.type}`
+        };
+    }
+    results.push(result);
+  }
+  return {
+    passed: results.every((r) => r.passed),
+    results,
+    evaluated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/engine/invoice.ts
+function generateInvoiceNumber() {
+  const now = /* @__PURE__ */ new Date();
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+  let suffix = "";
+  for (let i = 0; i < 4; i++) {
+    suffix += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return `AR-${y}${m}${d}-${suffix}`;
+}
+function receiptToLineItem(receipt) {
+  const cr = receipt.constraint_result;
+  return {
+    receipt_id: receipt.receipt_id,
+    action: receipt.action,
+    agent_id: receipt.agent_id,
+    timestamp: receipt.timestamp,
+    description: receipt.output_summary ?? `${receipt.action} by ${receipt.agent_id}`,
+    cost_usd: receipt.cost_usd,
+    latency_ms: receipt.latency_ms,
+    model: receipt.model,
+    tokens_in: receipt.tokens_in,
+    tokens_out: receipt.tokens_out,
+    constraints_passed: cr && typeof cr.passed === "boolean" ? cr.passed : null,
+    receipt
+  };
+}
+function groupItems(items, groupBy) {
+  if (groupBy === "none") {
+    const subtotal = items.reduce((s, i) => s + (i.cost_usd ?? 0), 0);
+    return [{ label: "All Items", items, subtotal_usd: subtotal, count: items.length }];
+  }
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    let key;
+    if (groupBy === "action") {
+      key = item.action;
+    } else if (groupBy === "agent") {
+      key = item.agent_id;
+    } else {
+      key = item.timestamp.slice(0, 10);
+    }
+    const group = map.get(key) ?? [];
+    group.push(item);
+    map.set(key, group);
+  }
+  const groups = [];
+  for (const [label, groupItems2] of map) {
+    const subtotal = groupItems2.reduce((s, i) => s + (i.cost_usd ?? 0), 0);
+    groups.push({ label, items: groupItems2, subtotal_usd: subtotal, count: groupItems2.length });
+  }
+  return groups.sort((a, b) => a.label.localeCompare(b.label));
+}
+function calculateSummary(items) {
+  let totalCost = 0;
+  let totalTokensIn = 0;
+  let totalTokensOut = 0;
+  let totalLatency = 0;
+  let constraintsEvaluated = 0;
+  let constraintsPassed = 0;
+  let constraintsFailed = 0;
+  for (const item of items) {
+    totalCost += item.cost_usd ?? 0;
+    totalTokensIn += item.tokens_in ?? 0;
+    totalTokensOut += item.tokens_out ?? 0;
+    totalLatency += item.latency_ms ?? 0;
+    if (item.constraints_passed !== null) {
+      constraintsEvaluated++;
+      if (item.constraints_passed) constraintsPassed++;
+      else constraintsFailed++;
+    }
+  }
+  return {
+    total_receipts: items.length,
+    total_cost_usd: totalCost,
+    avg_cost_usd: items.length > 0 ? totalCost / items.length : 0,
+    total_tokens_in: totalTokensIn,
+    total_tokens_out: totalTokensOut,
+    total_latency_ms: totalLatency,
+    avg_latency_ms: items.length > 0 ? totalLatency / items.length : 0,
+    constraints_evaluated: constraintsEvaluated,
+    constraints_passed: constraintsPassed,
+    constraints_failed: constraintsFailed
+  };
+}
+async function generateInvoice(store, keyManager, options) {
+  const result = await store.list(
+    { from: options.from, to: options.to, status: "completed" },
+    1,
+    1e5,
+    "timestamp:asc"
+  );
+  let receipts = result.data;
+  if (options.agent_ids && options.agent_ids.length > 0) {
+    const agentSet = new Set(options.agent_ids);
+    receipts = receipts.filter((r) => agentSet.has(r.agent_id));
+  }
+  if (options.actions && options.actions.length > 0) {
+    const actionSet = new Set(options.actions);
+    receipts = receipts.filter((r) => actionSet.has(r.action));
+  }
+  if (options.constraints_passed_only) {
+    receipts = receipts.filter((r) => {
+      const cr = r.constraint_result;
+      return !cr || cr.passed !== false;
+    });
+  }
+  const items = receipts.map(receiptToLineItem);
+  const groupBy = options.group_by ?? "none";
+  const groups = groupItems(items, groupBy);
+  const summary = calculateSummary(items);
+  const publicKey = keyManager.getPublicKey();
+  return {
+    invoice_number: generateInvoiceNumber(),
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    period: { from: options.from, to: options.to },
+    client: options.client,
+    provider: options.provider,
+    groups,
+    summary,
+    public_key: publicKey,
+    notes: options.notes,
+    payment_terms: options.payment_terms
+  };
+}
+
+// src/engine/receipt-engine.ts
+var ReceiptEngine = class {
+  constructor(store, keyManager, configManager) {
+    this.store = store;
+    this.keyManager = keyManager;
+    this.configManager = configManager;
+  }
+  async create(params) {
+    const config = this.configManager.getConfig();
+    const receiptId = `rcpt_${nanoid(12)}`;
+    const chainId = params.chain_id ?? `chain_${nanoid(8)}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const constraintDefs = params.constraints && params.constraints.length > 0 ? params.constraints : null;
+    const constraintsForStorage = constraintDefs ? { definitions: constraintDefs } : null;
+    let expiresAt = params.expires_at;
+    if (!expiresAt && params.ttl_ms) {
+      expiresAt = new Date(Date.now() + params.ttl_ms).toISOString();
+    }
+    const metadata = { ...params.metadata ?? {} };
+    if (expiresAt) {
+      metadata.expires_at = expiresAt;
+    }
+    const receiptData = {
+      receipt_id: receiptId,
+      parent_receipt_id: params.parent_receipt_id ?? null,
+      chain_id: chainId,
+      receipt_type: params.receipt_type ?? "action",
+      agent_id: config.agentId,
+      org_id: config.orgId,
+      action: params.action,
+      input_hash: params.input_hash,
+      output_hash: params.output_hash ?? null,
+      output_summary: params.output_summary ?? null,
+      model: params.model ?? null,
+      tokens_in: params.tokens_in ?? null,
+      tokens_out: params.tokens_out ?? null,
+      cost_usd: params.cost_usd ?? null,
+      latency_ms: params.latency_ms ?? null,
+      tool_calls: params.tool_calls ?? null,
+      timestamp: now,
+      completed_at: params.status === "completed" ? now : null,
+      status: params.status ?? "pending",
+      error: null,
+      environment: config.environment,
+      tags: params.tags ?? null,
+      constraints: constraintsForStorage,
+      constraint_result: null,
+      signature: "",
+      // placeholder — will be replaced
+      verify_url: `local://verify/${receiptId}`,
+      callback_verified: null,
+      confidence: params.confidence ?? null,
+      metadata
+    };
+    if (receiptData.status === "completed" && constraintDefs) {
+      receiptData.constraint_result = evaluateConstraints(
+        receiptData,
+        constraintDefs,
+        { rawOutput: params._rawOutput }
+      );
+    }
+    const signable = getSignablePayload(receiptData);
+    const signature = signReceipt(signable, this.keyManager.getPrivateKey());
+    receiptData.signature = signature;
+    const receipt = ActionReceipt.parse(receiptData);
+    await this.store.save(receipt);
+    return receipt;
+  }
+  async complete(receiptId, params) {
+    const existing = await this.store.get(receiptId);
+    if (!existing) {
+      throw new Error(`Receipt not found: ${receiptId}`);
+    }
+    if (existing.status !== "pending") {
+      throw new Error(`Receipt ${receiptId} is not pending (status: ${existing.status})`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updated = {
+      ...existing,
+      status: params.status,
+      completed_at: now,
+      output_hash: params.output_hash ?? existing.output_hash,
+      output_summary: params.output_summary ?? existing.output_summary,
+      model: params.model ?? existing.model,
+      tokens_in: params.tokens_in ?? existing.tokens_in,
+      tokens_out: params.tokens_out ?? existing.tokens_out,
+      cost_usd: params.cost_usd ?? existing.cost_usd,
+      latency_ms: params.latency_ms ?? existing.latency_ms,
+      tool_calls: params.tool_calls ?? existing.tool_calls,
+      confidence: params.confidence ?? existing.confidence,
+      callback_verified: params.callback_verified ?? existing.callback_verified,
+      error: params.error ?? existing.error,
+      metadata: params.metadata ? { ...existing.metadata, ...params.metadata } : existing.metadata,
+      constraint_result: existing.constraint_result
+    };
+    const storedConstraints = existing.constraints;
+    const constraints = storedConstraints?.definitions ?? null;
+    if (Array.isArray(constraints) && constraints.length > 0) {
+      updated.constraint_result = evaluateConstraints(
+        updated,
+        constraints
+      );
+    }
+    const signable = getSignablePayload(updated);
+    const signature = signReceipt(signable, this.keyManager.getPrivateKey());
+    updated.signature = signature;
+    const receipt = ActionReceipt.parse(updated);
+    await this.store.save(receipt);
+    return receipt;
+  }
+  async track(params) {
+    const inputHash = hashData(params.input);
+    const outputHash = params.output !== void 0 ? hashData(params.output) : null;
+    return this.create({
+      action: params.action,
+      input_hash: inputHash,
+      output_hash: outputHash,
+      output_summary: params.output_summary ?? null,
+      model: params.model ?? null,
+      tokens_in: params.tokens_in ?? null,
+      tokens_out: params.tokens_out ?? null,
+      cost_usd: params.cost_usd ?? null,
+      latency_ms: params.latency_ms ?? null,
+      tool_calls: params.tool_calls ?? null,
+      tags: params.tags ?? null,
+      confidence: params.confidence ?? null,
+      metadata: params.metadata ?? {},
+      parent_receipt_id: params.parent_receipt_id ?? null,
+      chain_id: params.chain_id,
+      status: "completed",
+      constraints: params.constraints,
+      expires_at: params.expires_at,
+      ttl_ms: params.ttl_ms,
+      _rawOutput: params.output
+    });
+  }
+  async verify(receiptId) {
+    const receipt = await this.store.get(receiptId);
+    if (!receipt) {
+      throw new Error(`Receipt not found: ${receiptId}`);
+    }
+    const signable = getSignablePayload(receipt);
+    const verified = verifyReceipt(signable, receipt.signature, this.keyManager.getPublicKey());
+    return { verified, receipt };
+  }
+  async get(receiptId) {
+    return this.store.get(receiptId);
+  }
+  async list(filter, page, limit, sort) {
+    return this.store.list(filter, page, limit, sort);
+  }
+  async getChain(chainId) {
+    return this.store.getChain(chainId);
+  }
+  async getJudgments(receiptId) {
+    const result = await this.store.list({
+      parent_receipt_id: receiptId,
+      receipt_type: "judgment"
+    });
+    return result.data;
+  }
+  async cleanup() {
+    const result = await this.store.cleanup();
+    return { deleted: result.deleted, remaining: result.total - result.deleted };
+  }
+  getPublicKey() {
+    return this.keyManager.getPublicKey();
+  }
+  async generateInvoice(options) {
+    return generateInvoice(this.store, this.keyManager, options);
+  }
+};
+
+// src/engine/invoice-formatters.ts
+function formatInvoiceJSON(invoice, includeReceipts = false) {
+  if (!includeReceipts) {
+    const stripped = {
+      ...invoice,
+      groups: invoice.groups.map((g) => ({
+        ...g,
+        items: g.items.map(({ receipt, ...rest }) => rest)
+      }))
+    };
+    return JSON.stringify(stripped, null, 2);
+  }
+  return JSON.stringify(invoice, null, 2);
+}
+function formatInvoiceCSV(invoice) {
+  const lines = [];
+  lines.push("receipt_id,action,agent_id,timestamp,description,cost_usd,latency_ms,model,tokens_in,tokens_out,constraints_passed,group");
+  for (const group of invoice.groups) {
+    for (const item of group.items) {
+      lines.push([
+        csvEscape(item.receipt_id),
+        csvEscape(item.action),
+        csvEscape(item.agent_id),
+        csvEscape(item.timestamp),
+        csvEscape(item.description),
+        item.cost_usd ?? "",
+        item.latency_ms ?? "",
+        csvEscape(item.model ?? ""),
+        item.tokens_in ?? "",
+        item.tokens_out ?? "",
+        item.constraints_passed ?? "",
+        csvEscape(group.label)
+      ].join(","));
+    }
+  }
+  lines.push("");
+  lines.push(`# Invoice: ${invoice.invoice_number}`);
+  lines.push(`# Period: ${invoice.period.from} to ${invoice.period.to}`);
+  lines.push(`# Total Receipts: ${invoice.summary.total_receipts}`);
+  lines.push(`# Total Cost: $${invoice.summary.total_cost_usd.toFixed(4)}`);
+  return lines.join("\n");
+}
+function csvEscape(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function formatInvoiceMarkdown(invoice) {
+  const lines = [];
+  lines.push(`# Invoice ${invoice.invoice_number}`);
+  lines.push("");
+  lines.push(`**Generated:** ${invoice.generated_at}`);
+  lines.push(`**Period:** ${invoice.period.from} to ${invoice.period.to}`);
+  lines.push("");
+  if (invoice.provider) {
+    lines.push("## Provider");
+    lines.push(`**${invoice.provider.name}**`);
+    if (invoice.provider.email) lines.push(`Email: ${invoice.provider.email}`);
+    if (invoice.provider.address) lines.push(`Address: ${invoice.provider.address}`);
+    lines.push("");
+  }
+  if (invoice.client) {
+    lines.push("## Bill To");
+    lines.push(`**${invoice.client.name}**`);
+    if (invoice.client.email) lines.push(`Email: ${invoice.client.email}`);
+    if (invoice.client.address) lines.push(`Address: ${invoice.client.address}`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  for (const group of invoice.groups) {
+    lines.push(`### ${group.label}`);
+    lines.push("");
+    lines.push("| Receipt ID | Action | Agent | Description | Cost |");
+    lines.push("|------------|--------|-------|-------------|------|");
+    for (const item of group.items) {
+      const cost = item.cost_usd !== null ? `$${item.cost_usd.toFixed(4)}` : "-";
+      const desc = item.description.length > 50 ? item.description.slice(0, 47) + "..." : item.description;
+      lines.push(`| \`${item.receipt_id}\` | ${item.action} | ${item.agent_id} | ${desc} | ${cost} |`);
+    }
+    lines.push("");
+    lines.push(`**Subtotal:** $${group.subtotal_usd.toFixed(4)} (${group.count} items)`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(`| Metric | Value |`);
+  lines.push(`|--------|-------|`);
+  lines.push(`| Total Receipts | ${invoice.summary.total_receipts} |`);
+  lines.push(`| Total Cost | $${invoice.summary.total_cost_usd.toFixed(4)} |`);
+  lines.push(`| Avg Cost | $${invoice.summary.avg_cost_usd.toFixed(4)} |`);
+  lines.push(`| Total Tokens (in) | ${invoice.summary.total_tokens_in} |`);
+  lines.push(`| Total Tokens (out) | ${invoice.summary.total_tokens_out} |`);
+  lines.push(`| Avg Latency | ${Math.round(invoice.summary.avg_latency_ms)}ms |`);
+  if (invoice.summary.constraints_evaluated > 0) {
+    lines.push(`| Constraints Passed | ${invoice.summary.constraints_passed}/${invoice.summary.constraints_evaluated} |`);
+  }
+  lines.push("");
+  if (invoice.notes) {
+    lines.push("## Notes");
+    lines.push("");
+    lines.push(invoice.notes);
+    lines.push("");
+  }
+  if (invoice.payment_terms) {
+    lines.push("## Payment Terms");
+    lines.push("");
+    lines.push(invoice.payment_terms);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("## Verification");
+  lines.push("");
+  lines.push("Every line item is a cryptographically signed receipt that can be independently verified.");
+  lines.push("");
+  lines.push(`**Public Key:** \`${invoice.public_key}\``);
+  lines.push("");
+  return lines.join("\n");
+}
+function formatInvoiceHTML(invoice) {
+  const providerSection = invoice.provider ? `
+    <div class="party">
+      <h3>From</h3>
+      <p class="party-name">${esc(invoice.provider.name)}</p>
+      ${invoice.provider.email ? `<p>${esc(invoice.provider.email)}</p>` : ""}
+      ${invoice.provider.address ? `<p>${esc(invoice.provider.address)}</p>` : ""}
+    </div>` : "";
+  const clientSection = invoice.client ? `
+    <div class="party">
+      <h3>Bill To</h3>
+      <p class="party-name">${esc(invoice.client.name)}</p>
+      ${invoice.client.email ? `<p>${esc(invoice.client.email)}</p>` : ""}
+      ${invoice.client.address ? `<p>${esc(invoice.client.address)}</p>` : ""}
+    </div>` : "";
+  const groupSections = invoice.groups.map((group) => `
+    <div class="group">
+      <h3>${esc(group.label)}</h3>
+      <table>
+        <thead>
+          <tr>
+            <th>Receipt ID</th>
+            <th>Action</th>
+            <th>Agent</th>
+            <th>Description</th>
+            <th>Timestamp</th>
+            <th class="num">Cost</th>
+          </tr>
+        </thead>
+        <tbody>
+          ${group.items.map((item) => itemRow(item)).join("\n")}
+        </tbody>
+        <tfoot>
+          <tr>
+            <td colspan="5" class="subtotal-label">Subtotal (${group.count} items)</td>
+            <td class="num subtotal-value">$${group.subtotal_usd.toFixed(4)}</td>
+          </tr>
+        </tfoot>
+      </table>
+    </div>`).join("\n");
+  const constraintRow = invoice.summary.constraints_evaluated > 0 ? `<tr><td>Constraints Passed</td><td>${invoice.summary.constraints_passed}/${invoice.summary.constraints_evaluated}</td></tr>` : "";
+  const notesSection = invoice.notes ? `<div class="section"><h3>Notes</h3><p>${esc(invoice.notes)}</p></div>` : "";
+  const paymentSection = invoice.payment_terms ? `<div class="section"><h3>Payment Terms</h3><p>${esc(invoice.payment_terms)}</p></div>` : "";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Invoice ${esc(invoice.invoice_number)}</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; color: #1a1a1a; line-height: 1.5; padding: 40px; max-width: 1000px; margin: 0 auto; }
+    .header { display: flex; justify-content: space-between; align-items: flex-start; margin-bottom: 32px; padding-bottom: 24px; border-bottom: 2px solid #e5e7eb; }
+    .header h1 { font-size: 28px; font-weight: 700; color: #111; }
+    .header .invoice-number { font-size: 14px; color: #6b7280; margin-top: 4px; }
+    .header .meta { text-align: right; font-size: 13px; color: #6b7280; }
+    .parties { display: flex; gap: 48px; margin-bottom: 32px; }
+    .party h3 { font-size: 11px; text-transform: uppercase; letter-spacing: 0.05em; color: #9ca3af; margin-bottom: 4px; }
+    .party-name { font-weight: 600; font-size: 15px; }
+    .party p { font-size: 13px; color: #4b5563; }
+    .group { margin-bottom: 24px; }
+    .group h3 { font-size: 15px; font-weight: 600; margin-bottom: 8px; color: #374151; }
+    table { width: 100%; border-collapse: collapse; font-size: 12px; }
+    th { text-align: left; padding: 8px 10px; background: #f9fafb; border-bottom: 1px solid #e5e7eb; font-weight: 600; color: #374151; font-size: 11px; text-transform: uppercase; letter-spacing: 0.03em; }
+    td { padding: 7px 10px; border-bottom: 1px solid #f3f4f6; color: #4b5563; }
+    .num { text-align: right; font-variant-numeric: tabular-nums; }
+    .receipt-id { font-family: ui-monospace, monospace; font-size: 11px; color: #6b7280; }
+    .subtotal-label { text-align: right; font-weight: 600; color: #374151; }
+    .subtotal-value { font-weight: 600; color: #111; }
+    .summary { margin-top: 32px; padding-top: 24px; border-top: 2px solid #e5e7eb; }
+    .summary h3 { font-size: 15px; font-weight: 600; margin-bottom: 12px; }
+    .summary table { max-width: 360px; }
+    .summary td { padding: 5px 10px; }
+    .summary td:first-child { font-weight: 500; color: #374151; }
+    .summary td:last-child { text-align: right; font-variant-numeric: tabular-nums; }
+    .total-row td { font-size: 16px; font-weight: 700; color: #111; border-top: 2px solid #e5e7eb; padding-top: 10px; }
+    .section { margin-top: 24px; }
+    .section h3 { font-size: 13px; font-weight: 600; margin-bottom: 6px; color: #374151; }
+    .section p { font-size: 13px; color: #4b5563; }
+    .verification { margin-top: 32px; padding: 16px; background: #f0fdf4; border: 1px solid #bbf7d0; border-radius: 8px; }
+    .verification h3 { font-size: 13px; font-weight: 600; color: #166534; margin-bottom: 6px; }
+    .verification p { font-size: 12px; color: #15803d; }
+    .verification code { font-family: ui-monospace, monospace; font-size: 11px; background: #dcfce7; padding: 2px 6px; border-radius: 3px; word-break: break-all; }
+    .footer { margin-top: 40px; padding-top: 16px; border-top: 1px solid #e5e7eb; text-align: center; font-size: 11px; color: #9ca3af; }
+    @media print {
+      body { padding: 20px; }
+      .verification { break-inside: avoid; }
+      table { page-break-inside: auto; }
+      tr { page-break-inside: avoid; }
+    }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <div>
+      <h1>Invoice</h1>
+      <div class="invoice-number">${esc(invoice.invoice_number)}</div>
+    </div>
+    <div class="meta">
+      <div>Generated: ${esc(formatDate(invoice.generated_at))}</div>
+      <div>Period: ${esc(formatDate(invoice.period.from))} &mdash; ${esc(formatDate(invoice.period.to))}</div>
+    </div>
+  </div>
+
+  ${providerSection || clientSection ? `<div class="parties">${providerSection}${clientSection}</div>` : ""}
+
+  ${groupSections}
+
+  <div class="summary">
+    <h3>Summary</h3>
+    <table>
+      <tr class="total-row"><td>Total Cost</td><td>$${invoice.summary.total_cost_usd.toFixed(4)}</td></tr>
+      <tr><td>Total Receipts</td><td>${invoice.summary.total_receipts}</td></tr>
+      <tr><td>Avg Cost per Receipt</td><td>$${invoice.summary.avg_cost_usd.toFixed(4)}</td></tr>
+      <tr><td>Total Tokens (in/out)</td><td>${invoice.summary.total_tokens_in} / ${invoice.summary.total_tokens_out}</td></tr>
+      <tr><td>Avg Latency</td><td>${Math.round(invoice.summary.avg_latency_ms)}ms</td></tr>
+      ${constraintRow}
+    </table>
+  </div>
+
+  ${notesSection}
+  ${paymentSection}
+
+  <div class="verification">
+    <h3>Verification</h3>
+    <p>Every line item is a cryptographically signed receipt that can be independently verified.</p>
+    <p style="margin-top: 6px;">Public Key: <code>${esc(invoice.public_key)}</code></p>
+  </div>
+
+  <div class="footer">
+    Generated by Agent Receipts &mdash; ${esc(invoice.invoice_number)}
+  </div>
+</body>
+</html>`;
+}
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function formatDate(iso) {
+  try {
+    return new Date(iso).toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    });
+  } catch {
+    return iso;
+  }
+}
+function itemRow(item) {
+  const cost = item.cost_usd !== null ? `$${item.cost_usd.toFixed(4)}` : "-";
+  const desc = item.description.length > 60 ? item.description.slice(0, 57) + "..." : item.description;
+  const ts = formatDate(item.timestamp);
+  return `          <tr>
+            <td class="receipt-id">${esc(item.receipt_id)}</td>
+            <td>${esc(item.action)}</td>
+            <td>${esc(item.agent_id)}</td>
+            <td>${esc(desc)}</td>
+            <td>${esc(ts)}</td>
+            <td class="num">${cost}</td>
+          </tr>`;
+}
+
+// src/engine/seed.ts
+var AGENTS = ["agent-alpha", "agent-beta", "agent-gamma", "agent-delta"];
+var ACTIONS = [
+  "code_review",
+  "generate_code",
+  "analyze_data",
+  "summarize_text",
+  "translate",
+  "classify_intent",
+  "extract_entities",
+  "search_docs",
+  "validate_input",
+  "optimize_query",
+  "draft_email",
+  "parse_json",
+  "run_tests",
+  "deploy_service",
+  "monitor_health",
+  "audit_logs"
+];
+var MODELS = [
+  "claude-sonnet-4-20250514",
+  "claude-haiku-4-5-20251001",
+  "gpt-4o",
+  "gpt-4o-mini",
+  "gemini-2.0-flash"
+];
+var TAGS_POOL = [
+  "production",
+  "staging",
+  "dev",
+  "critical",
+  "batch",
+  "realtime",
+  "async",
+  "retry",
+  "cached",
+  "v2"
+];
+var OUTPUT_SUMMARIES = [
+  "Successfully processed request",
+  "Generated 3 code suggestions",
+  "Analyzed 500 rows of data",
+  "Translated document to Spanish",
+  "Classified as support_request",
+  "Extracted 12 named entities",
+  "Found 5 relevant documents",
+  "Validated all required fields",
+  "Optimized query: 3.2x faster",
+  "Draft ready for review",
+  "Parsed 45 JSON records",
+  "All 12 tests passing",
+  "Deployed to production v2.1.0",
+  "Health check: all systems nominal",
+  "Audit complete: no anomalies",
+  "Summarized 3 key findings"
+];
+function pick(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function randInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function randFloat(min, max, decimals = 4) {
+  return parseFloat((Math.random() * (max - min) + min).toFixed(decimals));
+}
+function weightedWeekday(baseDate, dayOffset) {
+  const d = new Date(baseDate);
+  d.setDate(d.getDate() - dayOffset);
+  const dow = d.getDay();
+  if ((dow === 0 || dow === 6) && Math.random() < 0.7) {
+    d.setDate(d.getDate() + (dow === 0 ? 1 : -1));
+  }
+  d.setHours(randInt(8, 22), randInt(0, 59), randInt(0, 59), randInt(0, 999));
+  return d;
+}
+function pickTags() {
+  if (Math.random() < 0.4) return void 0;
+  const count = randInt(1, 3);
+  const tags = [];
+  const pool = [...TAGS_POOL];
+  for (let i = 0; i < count && pool.length > 0; i++) {
+    const idx = Math.floor(Math.random() * pool.length);
+    tags.push(pool.splice(idx, 1)[0]);
+  }
+  return tags;
+}
+async function seedDemoData(store, keyManager, options) {
+  const configManager = new ConfigManager(store["receiptsDir"].replace(/\/receipts$/, ""));
+  await configManager.init();
+  const engine = new ReceiptEngine(store, keyManager, configManager);
+  const targetCount = options?.count ?? randInt(80, 100);
+  const now = /* @__PURE__ */ new Date();
+  if (options?.clean) {
+    const existing = await store.list(void 0, 1, 1e5);
+    for (const r of existing.data) {
+      await store.delete(r.receipt_id);
+    }
+  }
+  const result = {
+    total: 0,
+    agents: {},
+    chains: 0,
+    judgments: 0,
+    constraints: { passed: 0, failed: 0 },
+    expired: 0
+  };
+  const allReceipts = [];
+  const isSmall = targetCount < 40;
+  const judgmentCount = isSmall ? 0 : 4;
+  const expiredCount = isSmall ? 1 : 3;
+  const futureCount = isSmall ? 1 : 5;
+  const reservedCount = judgmentCount + expiredCount + futureCount;
+  const chainTarget = isSmall ? Math.max(1, Math.floor(targetCount / 10)) : 12;
+  const avgChainSteps = isSmall ? 3 : 4;
+  const estimatedChainReceipts = chainTarget * avgChainSteps;
+  const standaloneCount = Math.max(3, targetCount - reservedCount - estimatedChainReceipts);
+  for (let i = 0; i < standaloneCount; i++) {
+    const agent = pick(AGENTS);
+    const action = pick(ACTIONS);
+    const dayOffset = randInt(0, 13);
+    const ts = weightedWeekday(now, dayOffset);
+    if (i < 5) {
+      ts.setTime(now.getTime() - randInt(6e4, 36e5));
+    }
+    const model = pick(MODELS);
+    const tokensIn = randInt(50, 8e3);
+    const tokensOut = randInt(20, 4e3);
+    const latency = randInt(100, 12e3);
+    const costBase = tokensIn * 3e-6 + tokensOut * 15e-6;
+    const cost = parseFloat(costBase.toFixed(6));
+    const useConstraints = Math.random() < 0.4;
+    const constraints = useConstraints ? buildConstraints(latency, cost) : void 0;
+    const tags = pickTags();
+    const receipt = await engine.track({
+      action,
+      input: { query: `demo-input-${i}`, context: `batch-${Math.floor(i / 10)}` },
+      output: { result: `demo-output-${i}`, items: randInt(1, 20) },
+      model,
+      tokens_in: tokensIn,
+      tokens_out: tokensOut,
+      cost_usd: cost,
+      latency_ms: latency,
+      confidence: randFloat(0.6, 0.99),
+      tags,
+      output_summary: pick(OUTPUT_SUMMARIES),
+      constraints,
+      metadata: { demo: true, generated_at: ts.toISOString() }
+    });
+    allReceipts.push({
+      receipt_id: receipt.receipt_id,
+      chain_id: receipt.chain_id,
+      action: receipt.action,
+      agent_id: receipt.agent_id
+    });
+    result.agents[receipt.agent_id] = (result.agents[receipt.agent_id] ?? 0) + 1;
+    result.total++;
+    if (useConstraints && receipt.constraint_result) {
+      const cr = receipt.constraint_result;
+      if (cr.passed) result.constraints.passed++;
+      else result.constraints.failed++;
+    }
+  }
+  const chainBudget = Math.max(chainTarget * 5, targetCount - standaloneCount - reservedCount);
+  const chainCount = chainTarget;
+  let chainReceiptsUsed = 0;
+  for (let c = 0; c < chainCount && chainReceiptsUsed < chainBudget; c++) {
+    const steps = randInt(3, Math.min(7, chainBudget - chainReceiptsUsed));
+    const agent = pick(AGENTS);
+    const baseAction = pick(ACTIONS);
+    let parentId;
+    let chainId;
+    for (let s = 0; s < steps; s++) {
+      const dayOffset = randInt(0, 10);
+      const latency = randInt(200, 8e3);
+      const tokensIn = randInt(100, 5e3);
+      const tokensOut = randInt(50, 3e3);
+      const cost = parseFloat((tokensIn * 3e-6 + tokensOut * 15e-6).toFixed(6));
+      const useConstraints = Math.random() < 0.4;
+      const constraints = useConstraints ? buildConstraints(latency, cost) : void 0;
+      const receipt = await engine.track({
+        action: `${baseAction}_step${s + 1}`,
+        input: { step: s + 1, chain_step: `chain-${c}-step-${s}` },
+        output: { step_result: `completed step ${s + 1}` },
+        model: pick(MODELS),
+        tokens_in: tokensIn,
+        tokens_out: tokensOut,
+        cost_usd: cost,
+        latency_ms: latency,
+        confidence: randFloat(0.7, 0.98),
+        tags: pickTags(),
+        output_summary: `Step ${s + 1} of ${steps} completed`,
+        parent_receipt_id: parentId,
+        chain_id: chainId,
+        constraints,
+        metadata: { demo: true }
+      });
+      if (s === 0) chainId = receipt.chain_id;
+      parentId = receipt.receipt_id;
+      allReceipts.push({
+        receipt_id: receipt.receipt_id,
+        chain_id: receipt.chain_id,
+        action: receipt.action,
+        agent_id: receipt.agent_id
+      });
+      result.agents[receipt.agent_id] = (result.agents[receipt.agent_id] ?? 0) + 1;
+      result.total++;
+      chainReceiptsUsed++;
+      if (useConstraints && receipt.constraint_result) {
+        const cr = receipt.constraint_result;
+        if (cr.passed) result.constraints.passed++;
+        else result.constraints.failed++;
+      }
+    }
+    result.chains++;
+  }
+  const judgmentTargets = allReceipts.slice(5, 5 + judgmentCount);
+  for (const target of judgmentTargets) {
+    const pending = await engine.create({
+      receipt_type: "judgment",
+      action: "judge",
+      input_hash: hashData({ receipt_id: target.receipt_id }),
+      parent_receipt_id: target.receipt_id,
+      chain_id: target.chain_id,
+      status: "pending",
+      metadata: { rubric_version: "1.0", demo: true }
+    });
+    const verdict = pick(["pass", "pass", "partial", "fail"]);
+    const score = verdict === "pass" ? randFloat(0.8, 0.98) : verdict === "partial" ? randFloat(0.5, 0.79) : randFloat(0.2, 0.49);
+    await engine.complete(pending.receipt_id, {
+      status: "completed",
+      output_hash: hashData({ verdict, score }),
+      output_summary: `${verdict.toUpperCase()} (${score.toFixed(2)})`,
+      confidence: randFloat(0.75, 0.95),
+      metadata: {
+        rubric_version: "1.0",
+        demo: true,
+        judgment: {
+          verdict,
+          score,
+          criteria_results: [
+            { criterion: "accuracy", score: randFloat(0.5, 1), passed: Math.random() > 0.3, reasoning: "Evaluated accuracy of output" },
+            { criterion: "completeness", score: randFloat(0.4, 1), passed: Math.random() > 0.3, reasoning: "Checked completeness of response" },
+            { criterion: "clarity", score: randFloat(0.6, 1), passed: Math.random() > 0.2, reasoning: "Assessed clarity and readability" }
+          ],
+          overall_reasoning: `Evaluation of ${target.action}: ${verdict === "pass" ? "Meets quality standards" : verdict === "partial" ? "Partially meets standards, improvements needed" : "Does not meet minimum quality threshold"}`,
+          rubric_version: "1.0"
+        }
+      }
+    });
+    result.total += 2;
+    result.judgments++;
+  }
+  result.total = result.total - judgmentCount;
+  for (let i = 0; i < expiredCount; i++) {
+    const daysAgo = randInt(2, 7);
+    const expiredAt = new Date(now.getTime() - daysAgo * 864e5).toISOString();
+    await engine.track({
+      action: pick(ACTIONS),
+      input: { expired_demo: i },
+      output: { result: "expired result" },
+      model: pick(MODELS),
+      tokens_in: randInt(100, 2e3),
+      tokens_out: randInt(50, 1e3),
+      cost_usd: randFloat(1e-4, 0.01),
+      latency_ms: randInt(200, 5e3),
+      expires_at: expiredAt,
+      metadata: { demo: true }
+    });
+    result.total++;
+    result.expired++;
+  }
+  for (let i = 0; i < futureCount; i++) {
+    const daysAhead = randInt(1, 30);
+    const expiresAt = new Date(now.getTime() + daysAhead * 864e5).toISOString();
+    await engine.track({
+      action: pick(ACTIONS),
+      input: { future_expiry_demo: i },
+      output: { result: "future expiring result" },
+      model: pick(MODELS),
+      tokens_in: randInt(100, 3e3),
+      tokens_out: randInt(50, 1500),
+      cost_usd: randFloat(1e-4, 0.02),
+      latency_ms: randInt(150, 6e3),
+      expires_at: expiresAt,
+      tags: ["expiring"],
+      metadata: { demo: true }
+    });
+    result.total++;
+  }
+  return result;
+}
+function buildConstraints(latencyMs, costUsd) {
+  const constraints = [];
+  const latencyThreshold = Math.random() < 0.3 ? Math.floor(latencyMs * 0.5) : Math.floor(latencyMs * 2);
+  constraints.push({ type: "max_latency_ms", value: latencyThreshold });
+  if (Math.random() < 0.6) {
+    const costThreshold = Math.random() < 0.2 ? costUsd * 0.5 : costUsd * 3;
+    constraints.push({ type: "max_cost_usd", value: parseFloat(costThreshold.toFixed(6)) });
+  }
+  if (Math.random() < 0.3) {
+    constraints.push({ type: "min_confidence", value: randFloat(0.6, 0.9) });
+  }
+  return constraints;
+}
+export {
+  ConfigManager,
+  ReceiptStore as JsonReceiptStore,
+  KeyManager,
+  ReceiptEngine,
+  SqliteReceiptStore as ReceiptStore,
+  SqliteReceiptStore,
+  evaluateConstraints,
+  formatInvoiceCSV,
+  formatInvoiceHTML,
+  formatInvoiceJSON,
+  formatInvoiceMarkdown,
+  generateInvoice,
+  hashData,
+  seedDemoData,
+  validateJsonSchema
+};
+//# sourceMappingURL=index.js.map