@reinconsole/policy-engine 0.1.0

package/dist/server.js

@@ -0,0 +1,829 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { fileURLToPath } from "url";
+import { realpathSync } from "fs";
+import Fastify from "fastify";
+import { z as z3 } from "zod";
+
+// ../../packages/core/dist/index.js
+import { z } from "zod";
+var Chain = z.enum(["base", "solana", "polygon", "bnb"]);
+var Asset = z.enum(["USDC", "USDT", "EURC"]);
+var DecimalString = z.string().regex(/^\d+(\.\d+)?$/, 'must be a non-negative decimal string, e.g. "5.00"');
+var DECIMAL_RE = /^\d+(\.\d+)?$/;
+function isValidDecimal(value) {
+  return DECIMAL_RE.test(value);
+}
+function assertDecimal(value) {
+  if (!isValidDecimal(value)) {
+    throw new TypeError(`invalid decimal string: ${JSON.stringify(value)}`);
+  }
+}
+function fractionLength(value) {
+  const dot = value.indexOf(".");
+  return dot === -1 ? 0 : value.length - dot - 1;
+}
+function toScaled(value, scale) {
+  const dot = value.indexOf(".");
+  const intPart = dot === -1 ? value : value.slice(0, dot);
+  const fracPart = dot === -1 ? "" : value.slice(dot + 1);
+  const paddedFrac = (fracPart + "0".repeat(scale)).slice(0, scale);
+  return BigInt(intPart + paddedFrac);
+}
+function fromScaled(scaled, scale) {
+  if (scale === 0) return scaled.toString();
+  const digits = scaled.toString().padStart(scale + 1, "0");
+  const intPart = digits.slice(0, digits.length - scale);
+  const fracPart = digits.slice(digits.length - scale).replace(/0+$/, "");
+  return fracPart.length > 0 ? `${intPart}.${fracPart}` : intPart;
+}
+function compareDecimal(a, b) {
+  assertDecimal(a);
+  assertDecimal(b);
+  const scale = Math.max(fractionLength(a), fractionLength(b));
+  const av = toScaled(a, scale);
+  const bv = toScaled(b, scale);
+  return av < bv ? -1 : av > bv ? 1 : 0;
+}
+function sumDecimal(values) {
+  if (values.length === 0) return "0";
+  let scale = 0;
+  for (const v of values) {
+    assertDecimal(v);
+    scale = Math.max(scale, fractionLength(v));
+  }
+  let total = 0n;
+  for (const v of values) total += toScaled(v, scale);
+  return fromScaled(total, scale);
+}
+function mulDecimal(a, b) {
+  assertDecimal(a);
+  assertDecimal(b);
+  const scaleA = fractionLength(a);
+  const scaleB = fractionLength(b);
+  const product = toScaled(a, scaleA) * toScaled(b, scaleB);
+  return fromScaled(product, scaleA + scaleB);
+}
+function gt(a, b) {
+  return compareDecimal(a, b) === 1;
+}
+function globMatch(pattern, value) {
+  const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const withWildcard = escaped.replace(/\\\*/g, ".*");
+  return new RegExp(`^${withWildcard}$`).test(value);
+}
+function globMatchAny(patterns, value) {
+  return patterns.some((p) => globMatch(p, value));
+}
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function randomBytes(length) {
+  const bytes = new Uint8Array(length);
+  globalThis.crypto.getRandomValues(bytes);
+  return bytes;
+}
+function encodeTime(now) {
+  let time = now;
+  let out = "";
+  for (let i = TIME_LEN - 1; i >= 0; i--) {
+    out = ENCODING.charAt(time % 32) + out;
+    time = Math.floor(time / 32);
+  }
+  return out;
+}
+function encodeRandom() {
+  let out = "";
+  for (const byte of randomBytes(RANDOM_LEN)) {
+    out += ENCODING.charAt(byte % 32);
+  }
+  return out;
+}
+function ulid(seedTime = Date.now()) {
+  return encodeTime(seedTime) + encodeRandom();
+}
+function newId(prefix) {
+  return `${prefix}_${ulid()}`;
+}
+var ULID_BODY = "[0-9A-HJKMNP-TV-Z]{26}";
+function prefixedId(prefix) {
+  return z.string().regex(new RegExp(`^${prefix}_${ULID_BODY}$`), `expected a "${prefix}_" prefixed id`);
+}
+var OrgId = prefixedId("org");
+var AgentId = prefixedId("agt");
+var PolicyId = prefixedId("pol");
+var IntentId = prefixedId("int");
+var DecisionId = prefixedId("dec");
+var ReceiptId = prefixedId("rcp");
+var SessionId = prefixedId("ses");
+var GateReceiptId = prefixedId("grc");
+var EnforcementMode = z.enum(["observed", "sdk", "session-key"]);
+var AgentWallet = z.object({
+  chain: Chain,
+  address: z.string().min(1),
+  mode: EnforcementMode
+});
+var AgentStatus = z.enum(["active", "frozen"]);
+var Agent = z.object({
+  id: AgentId,
+  orgId: OrgId,
+  name: z.string().min(1).max(200),
+  /** On-chain ERC-8004 identity, if the agent is registered. */
+  erc8004Id: z.string().optional(),
+  wallets: z.array(AgentWallet).default([]),
+  status: AgentStatus.default("active"),
+  createdAt: z.coerce.date()
+});
+var ID_PATTERN = /^eip155:(\d+):(0x[0-9a-fA-F]{40})\/(\d+)$/;
+function parseErc8004Id(value) {
+  const match = ID_PATTERN.exec(value);
+  if (!match) return void 0;
+  const chainId = Number(match[1]);
+  if (!Number.isSafeInteger(chainId) || chainId < 1) return void 0;
+  return {
+    chainId,
+    registry: match[2].toLowerCase(),
+    tokenId: BigInt(match[3])
+  };
+}
+var Erc8004Id = z.string().refine((value) => parseErc8004Id(value) !== void 0, {
+  message: 'expected "eip155:{chainId}:{registry}/{tokenId}"'
+});
+var Vendor = z.object({
+  host: z.string().min(1),
+  address: z.string().min(1),
+  erc8004Id: z.string().optional()
+});
+var TaskContext = z.object({
+  taskId: z.string().optional(),
+  parentRunId: z.string().optional(),
+  purpose: z.string().max(500).optional()
+});
+var PaymentIntent = z.object({
+  id: IntentId,
+  agentId: AgentId,
+  vendor: Vendor,
+  resource: z.string(),
+  amount: DecimalString,
+  asset: Asset,
+  chain: Chain,
+  taskContext: TaskContext.default({}),
+  nonce: z.string().min(1),
+  createdAt: z.coerce.date()
+});
+var DecisionOutcome = z.enum(["allow", "deny", "escalate"]);
+var Decision = z.object({
+  id: DecisionId,
+  intentId: IntentId,
+  /**
+   * sha256 of the intent's canonical content (see canonical.ts). Binds the
+   * decision to the exact transfer it judged — amount, recipient, asset,
+   * chain — so a signer can verify an {intent, decision} pair offline as a
+   * self-contained spend voucher, not just a reference by id.
+   */
+  intentHash: z.string(),
+  outcome: DecisionOutcome,
+  /** Ids of the rules that fired, for explainability. */
+  matchedRules: z.array(z.string()).default([]),
+  /** Human-readable explanation surfaced in the dashboard. */
+  reason: z.string().optional(),
+  policyId: z.string(),
+  policyVersion: z.string(),
+  /** Hash of the previous decision in the chain (tamper-evident log). */
+  prevHash: z.string(),
+  /** Hash of this decision's canonical content. */
+  hash: z.string(),
+  /** Service signing-key signature over `hash`. */
+  signature: z.string(),
+  latencyMs: z.number().nonnegative(),
+  decidedAt: z.coerce.date()
+});
+function canonicalIntent(intent) {
+  return JSON.stringify({
+    id: intent.id,
+    agentId: intent.agentId,
+    vendor: {
+      host: intent.vendor.host,
+      address: intent.vendor.address,
+      erc8004Id: intent.vendor.erc8004Id ?? null
+    },
+    resource: intent.resource,
+    amount: intent.amount,
+    asset: intent.asset,
+    chain: intent.chain,
+    taskContext: {
+      taskId: intent.taskContext.taskId ?? null,
+      parentRunId: intent.taskContext.parentRunId ?? null,
+      purpose: intent.taskContext.purpose ?? null
+    },
+    nonce: intent.nonce,
+    createdAt: intent.createdAt.toISOString()
+  });
+}
+function canonicalDecision(d) {
+  return JSON.stringify({
+    intentId: d.intentId,
+    intentHash: d.intentHash,
+    outcome: d.outcome,
+    matchedRules: d.matchedRules,
+    policyId: d.policyId,
+    policyVersion: d.policyVersion,
+    prevHash: d.prevHash,
+    decidedAt: d.decidedAt.toISOString()
+  });
+}
+var Session = z.object({
+  id: SessionId,
+  agentId: AgentId,
+  /** sha256 hex of the bearer token. */
+  tokenHash: z.string(),
+  /** Cumulative ceiling across the session's lifetime. Absent = uncapped. */
+  capAmount: DecimalString.optional(),
+  /** Ceiling per individual signature. Absent = uncapped. */
+  maxPerPayment: DecimalString.optional(),
+  expiresAt: z.coerce.date(),
+  createdAt: z.coerce.date(),
+  revokedAt: z.coerce.date().optional()
+});
+var SettledPayment = z.object({
+  intentId: IntentId,
+  txHash: z.string(),
+  chain: Chain,
+  blockNumber: z.coerce.bigint(),
+  facilitator: z.string().optional(),
+  feePaid: DecimalString.optional(),
+  confirmedAt: z.coerce.date()
+});
+var ReceiptSettlement = z.object({
+  txHash: z.string().optional(),
+  networkId: z.string().optional(),
+  /** Raw header payload, kept for forensics until the indexer confirms. */
+  raw: z.string().optional()
+});
+var Receipt = z.object({
+  id: ReceiptId,
+  agentId: AgentId,
+  intentId: IntentId,
+  decisionId: DecisionId,
+  outcome: DecisionOutcome,
+  /** The URL the agent actually fetched (the paywalled resource). */
+  url: z.string(),
+  method: z.string().default("GET"),
+  vendorHost: z.string(),
+  amount: DecimalString,
+  asset: Asset,
+  chain: Chain,
+  taskContext: TaskContext.default({}),
+  /** Human-readable explanation copied from the decision. */
+  reason: z.string().optional(),
+  /** Present only once a payment was made and the vendor confirmed it. */
+  settlement: ReceiptSettlement.optional(),
+  createdAt: z.coerce.date()
+});
+var GateReceipt = z.object({
+  id: GateReceiptId,
+  at: z.coerce.date(),
+  /** The route pattern that priced this request, e.g. "/api/reports/*". */
+  route: z.string().min(1),
+  /** The concrete resource paid for (URL path actually requested). */
+  resource: z.string().min(1),
+  method: z.string().min(1),
+  /** The paying wallet address, as asserted by the settled payment. */
+  payer: z.string().min(1),
+  payTo: z.string().min(1),
+  /** Human-unit decimal amount, e.g. "0.05". */
+  amount: DecimalString,
+  /** The same amount in the asset's atomic units, e.g. "50000". */
+  amountAtomic: z.string().regex(/^\d+$/, "atomic amount must be an integer string"),
+  /** Token symbol or contract address, exactly as quoted in the requirement. */
+  asset: z.string().min(1),
+  network: z.string().min(1),
+  /** Settlement transaction hash (mock ledger or on-chain). */
+  transaction: z.string().min(1)
+});
+var Window = z.string().regex(/^\d+[smhd]$/, 'window must be like "30s", "15m", "1h", or "7d"');
+var Multiplier = z.string().regex(/^\d+(\.\d+)?x$/, 'multiplier must be like "3x"');
+var Condition = z.object({
+  /** Per-transaction amount exceeds this value. */
+  amountGt: DecimalString.optional(),
+  /** Sum of spend in a rolling window exceeds `gt`. */
+  rollingSum: z.object({ window: Window, gt: DecimalString }).optional(),
+  /** Transaction count in a rolling window exceeds `gt`. */
+  txCount: z.object({ window: Window, gt: z.number().int().nonnegative() }).optional(),
+  /** Vendor host matches one of these patterns (supports `*` globs). */
+  vendorHostIn: z.array(z.string()).optional(),
+  /** First time Rein has seen this vendor for the agent. */
+  vendorFirstSeen: z.boolean().optional(),
+  /** Vendor reputation score is below this threshold (Phase 3 hook). */
+  vendorReputationLt: z.number().min(0).max(100).optional(),
+  /** Amount is more than `gt`-times the observed median for this resource. */
+  amountVsResourceMedian: z.object({ gt: Multiplier }).optional()
+}).refine((c) => Object.values(c).some((v) => v !== void 0), {
+  message: "a condition must specify at least one predicate"
+});
+var Rule = z.object({
+  id: z.string().min(1),
+  allow: Condition.optional(),
+  deny: Condition.optional(),
+  escalate: Condition.optional()
+}).refine((r) => [r.allow, r.deny, r.escalate].filter((v) => v !== void 0).length === 1, {
+  message: "a rule must specify exactly one of allow / deny / escalate"
+});
+var PolicyDefault = z.enum(["allow", "deny"]);
+var AppliesTo = z.object({
+  /** Agent id patterns (supports `*` globs, e.g. "agt_research_*"). */
+  agents: z.array(z.string()).optional(),
+  chains: z.array(Chain).optional()
+});
+var Escalation = z.object({
+  approvers: z.array(z.string()).default([]),
+  timeoutAction: PolicyDefault.default("deny"),
+  timeoutMin: z.number().int().positive().default(15)
+});
+var Policy = z.object({
+  policyId: z.string().min(1),
+  version: z.string().default("1"),
+  appliesTo: AppliesTo.default({}),
+  rules: z.array(Rule).default([]),
+  default: PolicyDefault.default("deny"),
+  /** Below this amount, fail-open is permitted during a policy-service outage. */
+  denyFloor: DecimalString.default("0.05"),
+  escalation: Escalation.optional()
+});
+var ReputationSubject = z.object({
+  kind: z.enum(["agent", "vendor"]),
+  id: z.string()
+});
+var ReputationComponents = z.object({
+  volume: z.number(),
+  longevity: z.number(),
+  disputeRate: z.number(),
+  counterpartyQuality: z.number(),
+  settlementReliability: z.number()
+});
+var ReputationScore = z.object({
+  subject: ReputationSubject,
+  score: z.number().min(0).max(100),
+  components: ReputationComponents,
+  confidence: z.number().min(0).max(1),
+  asOf: z.coerce.date(),
+  /** Hash-anchored attestation, optionally published on-chain (ERC-8004). */
+  evidenceUri: z.string().optional()
+});
+var ReinEvent = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("intent.created"), at: z.coerce.date(), intent: PaymentIntent }),
+  z.object({ type: z.literal("decision.made"), at: z.coerce.date(), decision: Decision }),
+  z.object({ type: z.literal("payment.settled"), at: z.coerce.date(), payment: SettledPayment }),
+  z.object({
+    type: z.literal("shadow.spend"),
+    at: z.coerce.date(),
+    agentId: AgentId,
+    txHash: z.string(),
+    chain: Chain,
+    amount: DecimalString
+  }),
+  z.object({
+    type: z.literal("signature.released"),
+    at: z.coerce.date(),
+    sessionId: SessionId,
+    agentId: AgentId,
+    intentId: IntentId,
+    decisionId: DecisionId,
+    amount: DecimalString
+  }),
+  z.object({
+    type: z.literal("signature.refused"),
+    at: z.coerce.date(),
+    /** Refusal code, e.g. "decision_replayed" (see @reinconsole/signer). */
+    code: z.string(),
+    reason: z.string(),
+    sessionId: SessionId.optional(),
+    agentId: AgentId.optional(),
+    intentId: IntentId.optional()
+  }),
+  z.object({
+    type: z.literal("gate.quoted"),
+    at: z.coerce.date(),
+    resource: z.string(),
+    method: z.string(),
+    amount: DecimalString,
+    asset: z.string(),
+    network: z.string()
+  }),
+  z.object({ type: z.literal("gate.settled"), at: z.coerce.date(), receipt: GateReceipt }),
+  z.object({
+    type: z.literal("gate.refused"),
+    at: z.coerce.date(),
+    /** Refusal code, e.g. "payment_replayed" (see @reinconsole/gate). */
+    code: z.string(),
+    reason: z.string(),
+    resource: z.string(),
+    /** Known only when the payment header decoded far enough to name a payer. */
+    payer: z.string().optional()
+  })
+]);
+
+// src/engine.ts
+import { EventEmitter } from "events";
+import { createHash as createHash2 } from "crypto";
+import { performance } from "perf_hooks";
+import { z as z2 } from "zod";
+
+// src/evaluator.ts
+function policyApplies(policy, intent) {
+  const { agents, chains } = policy.appliesTo;
+  if (chains && !chains.includes(intent.chain)) return false;
+  if (agents && agents.length > 0 && !globMatchAny(agents, intent.agentId)) return false;
+  return true;
+}
+function conditionMatches(cond, intent, ctx) {
+  if (cond.amountGt !== void 0 && !gt(intent.amount, cond.amountGt)) return false;
+  if (cond.rollingSum) {
+    const prospective = sumDecimal([ctx.rollingSum(cond.rollingSum.window), intent.amount]);
+    if (!gt(prospective, cond.rollingSum.gt)) return false;
+  }
+  if (cond.txCount) {
+    const prospective = ctx.txCount(cond.txCount.window) + 1;
+    if (prospective <= cond.txCount.gt) return false;
+  }
+  if (cond.vendorHostIn && !globMatchAny(cond.vendorHostIn, intent.vendor.host)) return false;
+  if (cond.vendorFirstSeen !== void 0 && ctx.isVendorFirstSeen(intent.vendor.host) !== cond.vendorFirstSeen) {
+    return false;
+  }
+  if (cond.vendorReputationLt !== void 0) {
+    const rep = ctx.vendorReputation(intent.vendor.host);
+    if (rep === void 0 || !(rep < cond.vendorReputationLt)) return false;
+  }
+  if (cond.amountVsResourceMedian) {
+    const med = ctx.resourceMedian(intent.resource);
+    if (med === void 0) return false;
+    const factor = cond.amountVsResourceMedian.gt.replace(/x$/, "");
+    if (!gt(intent.amount, mulDecimal(med, factor))) return false;
+  }
+  return true;
+}
+function actionOf(rule) {
+  if (rule.deny) return { action: "deny", cond: rule.deny };
+  if (rule.escalate) return { action: "escalate", cond: rule.escalate };
+  return { action: "allow", cond: rule.allow };
+}
+function evaluate(intent, policies, ctx) {
+  const policy = policies.find((p) => policyApplies(p, intent));
+  if (!policy) {
+    return {
+      outcome: "deny",
+      matchedRules: [],
+      reason: "no applicable policy (fail-closed default)",
+      policyId: "none",
+      policyVersion: "0"
+    };
+  }
+  const denies = [];
+  const escalates = [];
+  const allows = [];
+  for (const rule of policy.rules) {
+    const { action, cond } = actionOf(rule);
+    if (!conditionMatches(cond, intent, ctx)) continue;
+    if (action === "deny") denies.push(rule.id);
+    else if (action === "escalate") escalates.push(rule.id);
+    else allows.push(rule.id);
+  }
+  const base = { policyId: policy.policyId, policyVersion: policy.version };
+  if (denies.length > 0) {
+    return { outcome: "deny", matchedRules: denies, reason: `denied by: ${denies.join(", ")}`, ...base };
+  }
+  if (escalates.length > 0) {
+    return {
+      outcome: "escalate",
+      matchedRules: escalates,
+      reason: `escalated by: ${escalates.join(", ")}`,
+      ...base
+    };
+  }
+  if (allows.length > 0) {
+    return { outcome: "allow", matchedRules: allows, reason: `allowed by: ${allows.join(", ")}`, ...base };
+  }
+  return {
+    outcome: policy.default,
+    matchedRules: [],
+    reason: `no rule matched; policy default = ${policy.default}`,
+    ...base
+  };
+}
+
+// src/stores.ts
+var WINDOW_MS = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+function parseWindowMs(window) {
+  const match = /^(\d+)([smhd])$/.exec(window);
+  if (!match) throw new TypeError(`invalid window: ${window}`);
+  const unit = WINDOW_MS[match[2]];
+  return Number(match[1]) * (unit ?? 0);
+}
+function within(records, window, now) {
+  const cutoff = now - parseWindowMs(window);
+  return records.filter((r) => r.at >= cutoff);
+}
+function median(values) {
+  if (values.length === 0) return void 0;
+  const sorted = [...values].sort(compareDecimal);
+  return sorted[Math.floor(sorted.length / 2)];
+}
+var InMemorySpendStore = class {
+  records = [];
+  reputations = /* @__PURE__ */ new Map();
+  record(rec) {
+    this.records.push(rec);
+  }
+  setVendorReputation(host, score) {
+    this.reputations.set(host, score);
+  }
+  /** Resolve a point-in-time spend context for one agent (prior activity only). */
+  contextFor(agentId, now = Date.now()) {
+    const mine = this.records.filter((r) => r.agentId === agentId);
+    const reputations = this.reputations;
+    const all = this.records;
+    return {
+      rollingSum: (window) => sumDecimal(within(mine, window, now).map((r) => r.amount)),
+      txCount: (window) => within(mine, window, now).length,
+      isVendorFirstSeen: (host) => !mine.some((r) => r.host === host),
+      vendorReputation: (host) => reputations.get(host),
+      resourceMedian: (resource) => median(all.filter((r) => r.resource === resource).map((r) => r.amount))
+    };
+  }
+};
+var InMemoryPolicyStore = class {
+  policies = [];
+  /** Upsert by policyId (a new version replaces the prior one). */
+  add(policy) {
+    this.policies = this.policies.filter((p) => p.policyId !== policy.policyId);
+    this.policies.push(policy);
+  }
+  list() {
+    return this.policies;
+  }
+  get(policyId) {
+    return this.policies.find((p) => p.policyId === policyId);
+  }
+  applicableFor(intent) {
+    return this.policies.filter((p) => policyApplies(p, intent));
+  }
+};
+var InMemoryAgentRegistry = class {
+  agents = /* @__PURE__ */ new Map();
+  frozen = /* @__PURE__ */ new Set();
+  register(agent) {
+    this.agents.set(agent.id, agent);
+    if (agent.status === "frozen") this.frozen.add(agent.id);
+  }
+  get(id) {
+    return this.agents.get(id);
+  }
+  list() {
+    return [...this.agents.values()];
+  }
+  freeze(id) {
+    this.frozen.add(id);
+  }
+  unfreeze(id) {
+    this.frozen.delete(id);
+  }
+  isFrozen(id) {
+    return this.frozen.has(id);
+  }
+};
+
+// src/decision-log.ts
+import {
+  createHash,
+  generateKeyPairSync,
+  sign as edSign,
+  verify as edVerify,
+  createPublicKey
+} from "crypto";
+var DecisionLog = class {
+  prevHash;
+  privateKey;
+  publicKeyPem;
+  chain;
+  persist;
+  tail = Promise.resolve();
+  constructor(options = {}) {
+    const kp = options.keyPair ?? generateKeyPairSync("ed25519");
+    this.privateKey = kp.privateKey;
+    this.publicKeyPem = kp.publicKey.export({ type: "spki", format: "pem" }).toString();
+    this.chain = [...options.resume ?? []];
+    this.prevHash = this.chain.at(-1)?.hash ?? "genesis";
+    this.persist = options.persist;
+  }
+  append(input) {
+    const run = this.tail.then(() => this.appendSerialized(input));
+    this.tail = run.catch(() => void 0);
+    return run;
+  }
+  async appendSerialized(input) {
+    const decidedAt = /* @__PURE__ */ new Date();
+    const hash = createHash("sha256").update(canonicalDecision({ ...input, prevHash: this.prevHash, decidedAt })).digest("hex");
+    const signature = edSign(null, Buffer.from(hash), this.privateKey).toString("base64");
+    const decision = {
+      id: newId("dec"),
+      intentId: input.intentId,
+      intentHash: input.intentHash,
+      outcome: input.outcome,
+      matchedRules: input.matchedRules,
+      reason: input.reason,
+      policyId: input.policyId,
+      policyVersion: input.policyVersion,
+      prevHash: this.prevHash,
+      hash,
+      signature,
+      latencyMs: input.latencyMs,
+      decidedAt
+    };
+    if (this.persist) await this.persist(decision);
+    this.prevHash = hash;
+    this.chain.push(decision);
+    return decision;
+  }
+  all() {
+    return this.chain;
+  }
+};
+
+// src/engine.ts
+var IntentInput = z2.object({
+  id: IntentId.optional(),
+  agentId: AgentId,
+  vendor: Vendor,
+  resource: z2.string(),
+  amount: DecimalString,
+  asset: Asset,
+  chain: Chain,
+  taskContext: TaskContext.optional(),
+  nonce: z2.string().min(1).optional(),
+  createdAt: z2.coerce.date().optional()
+});
+var PolicyEngine = class {
+  spend;
+  policies;
+  agents;
+  log;
+  bus = new EventEmitter();
+  tail = Promise.resolve();
+  constructor(stores = {}) {
+    this.spend = stores.spend ?? new InMemorySpendStore();
+    this.policies = stores.policies ?? new InMemoryPolicyStore();
+    this.agents = stores.agents ?? new InMemoryAgentRegistry();
+    this.log = stores.log ?? new DecisionLog();
+  }
+  get publicKeyPem() {
+    return this.log.publicKeyPem;
+  }
+  onEvent(handler) {
+    this.bus.on("event", handler);
+  }
+  emit(event) {
+    this.bus.emit("event", event);
+  }
+  async registerAgent(input) {
+    const agent = Agent.parse(input);
+    await this.agents.register(agent);
+    return agent;
+  }
+  async addPolicy(input) {
+    const policy = Policy.parse(input);
+    await this.policies.add(policy);
+    return policy;
+  }
+  async freeze(agentId) {
+    await this.agents.freeze(agentId);
+  }
+  async unfreeze(agentId) {
+    await this.agents.unfreeze(agentId);
+  }
+  normalize(input) {
+    return PaymentIntent.parse({
+      id: input.id ?? newId("int"),
+      agentId: input.agentId,
+      vendor: input.vendor,
+      resource: input.resource,
+      amount: input.amount,
+      asset: input.asset,
+      chain: input.chain,
+      taskContext: input.taskContext ?? {},
+      nonce: input.nonce ?? newId("non"),
+      createdAt: input.createdAt ?? /* @__PURE__ */ new Date()
+    });
+  }
+  evaluateIntent(input) {
+    const run = this.tail.then(() => this.evaluateSerialized(input));
+    this.tail = run.catch(() => void 0);
+    return run;
+  }
+  async evaluateSerialized(input) {
+    const start = performance.now();
+    const intent = this.normalize(input);
+    this.emit({ type: "intent.created", at: /* @__PURE__ */ new Date(), intent });
+    let result;
+    if (this.agents.isFrozen(intent.agentId)) {
+      result = {
+        outcome: "deny",
+        matchedRules: ["agent-frozen"],
+        reason: "agent is frozen (kill switch)",
+        policyId: "system",
+        policyVersion: "0"
+      };
+    } else {
+      const ctx = this.spend.contextFor(intent.agentId, intent.createdAt.getTime());
+      result = evaluate(intent, this.policies.list(), ctx);
+    }
+    const latencyMs = performance.now() - start;
+    const intentHash = createHash2("sha256").update(canonicalIntent(intent)).digest("hex");
+    const decision = await this.log.append({
+      ...result,
+      intentId: intent.id,
+      intentHash,
+      latencyMs
+    });
+    this.emit({ type: "decision.made", at: /* @__PURE__ */ new Date(), decision });
+    if (decision.outcome === "allow") {
+      await this.spend.record({
+        agentId: intent.agentId,
+        host: intent.vendor.host,
+        resource: intent.resource,
+        amount: intent.amount,
+        at: intent.createdAt.getTime()
+      });
+    }
+    return { intent, decision };
+  }
+  decisions() {
+    return this.log.all();
+  }
+};
+
+// src/server.ts
+var AgentInput = z3.object({
+  orgId: OrgId,
+  name: z3.string().min(1).max(200),
+  erc8004Id: z3.string().optional(),
+  wallets: Agent.shape.wallets.optional()
+});
+function buildServer(engine = new PolicyEngine()) {
+  const app = Fastify({ logger: false });
+  app.setErrorHandler((err, _req, reply) => {
+    if (err instanceof z3.ZodError) {
+      return reply.status(400).send({ error: "validation_error", issues: err.issues });
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return reply.status(500).send({ error: "internal_error", message });
+  });
+  app.get("/health", () => ({ status: "ok", publicKey: engine.publicKeyPem }));
+  app.post("/v1/agents", (req) => {
+    const input = AgentInput.parse(req.body);
+    return engine.registerAgent({
+      id: newId("agt"),
+      orgId: input.orgId,
+      name: input.name,
+      erc8004Id: input.erc8004Id,
+      wallets: input.wallets ?? [],
+      status: "active",
+      createdAt: /* @__PURE__ */ new Date()
+    });
+  });
+  app.get("/v1/agents", () => engine.agents.list());
+  app.post("/v1/agents/:id/freeze", async (req, reply) => {
+    await engine.freeze(req.params.id);
+    return reply.status(204).send();
+  });
+  app.post("/v1/agents/:id/unfreeze", async (req, reply) => {
+    await engine.unfreeze(req.params.id);
+    return reply.status(204).send();
+  });
+  app.post("/v1/policies", (req) => engine.addPolicy(Policy.parse(req.body)));
+  app.get("/v1/policies", () => engine.policies.list());
+  app.post("/v1/evaluate", (req) => engine.evaluateIntent(IntentInput.parse(req.body)));
+  app.get("/v1/decisions", () => engine.decisions());
+  return app;
+}
+function isMainModule() {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+if (isMainModule()) {
+  const port = Number(process.env.PORT ?? 8787);
+  const host = process.env.HOST ?? "0.0.0.0";
+  const app = buildServer();
+  app.listen({ port, host }).then(() => console.log(`[rein] policy-engine listening on http://${host}:${port}`)).catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}
+export {
+  buildServer
+};
+//# sourceMappingURL=server.js.map