@reinconsole/mock-rails 0.1.1 → 0.3.0-rc.1

package/dist/index.js

@@ -2,11 +2,70 @@
 import { EventEmitter } from "events";
 import { randomBytes } from "crypto";
 
-// ../../packages/core/dist/index.js
+// ../../packages/core/dist/chunk-6H2LDEB7.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 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 ApiKeyId = prefixedId("key");
+var ApproverKeyId = prefixedId("apk");
+var ApiKeyScope = z.enum(["read", "evaluate", "approve", "report", "admin"]);
+var ApiKey = z.object({
+  id: ApiKeyId,
+  name: z.string().min(1).max(200),
+  scopes: z.array(ApiKeyScope).min(1),
+  /**
+   * The org this key acts inside. ABSENT means unscoped — an operator key that
+   * reads and writes across every org, which is what a self-hosted single-org
+   * deployment and every env-seeded boot secret have always been. That is the
+   * compatibility rule the whole tenancy design rests on: adding tenancy
+   * changed no existing key's behaviour, because no existing key has this
+   * field.
+   *
+   * Present, it is a hard confinement, not a default: the key cannot read,
+   * spend, approve or govern outside the org, and a write it submits is
+   * stamped with this org rather than the one the body asked for.
+   */
+  orgId: OrgId.optional(),
+  /**
+   * Narrow an org-scoped key further, to specific agents — what an agent
+   * runtime should carry, so a stolen key spends one agent's budget rather
+   * than the org's. Only meaningful alongside {@link ApiKey.orgId}: agent
+   * narrowing without an org is refused at issuance, because the scope it
+   * would describe has no org to resolve policies and approvers in.
+   *
+   * Capped at 64: a list long enough to need more is a fleet, and a fleet is
+   * what the org scope is for.
+   */
+  agentIds: z.array(AgentId).max(64).optional(),
+  createdAt: z.coerce.date(),
+  /** Last successful authentication, for spotting keys that can be retired. */
+  lastUsedAt: z.coerce.date().optional(),
+  /** Set by revoke(); a revoked key never authenticates again. */
+  revokedAt: z.coerce.date().optional(),
+  /** Set by rotate(); with `previousSecretExpiresAt` it dates the overlap. */
+  rotatedAt: z.coerce.date().optional()
+});
+var ApiKeyRecord = ApiKey.extend({
+  secretHash: z.string(),
+  previousSecretHash: z.string().optional(),
+  previousSecretExpiresAt: z.coerce.date().optional()
+});
+
+// ../../packages/core/dist/index.js
+import { z as z2 } from "zod";
+var Chain = z2.enum(["base", "solana", "polygon", "bnb"]);
+var Asset = z2.enum(["USDC", "USDT", "EURC"]);
+var DecimalString = z2.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);
@@ -35,34 +94,25 @@ function compareDecimal(a, b) {
   const bv = toScaled(b, scale);
   return av < bv ? -1 : av > bv ? 1 : 0;
 }
-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({
+var EnforcementMode = z2.enum(["observed", "sdk", "session-key"]);
+var AgentWallet = z2.object({
   chain: Chain,
-  address: z.string().min(1),
+  address: z2.string().min(1),
   mode: EnforcementMode
 });
-var AgentStatus = z.enum(["active", "frozen"]);
-var Agent = z.object({
+var AgentStatus = z2.enum(["active", "frozen"]);
+var AgentLabel = z2.string().max(40).regex(/^[a-z0-9][a-z0-9-]*$/, 'label must be a lowercase slug like "research" or "prod-trading"');
+var Agent = z2.object({
   id: AgentId,
   orgId: OrgId,
-  name: z.string().min(1).max(200),
+  name: z2.string().min(1).max(200),
   /** On-chain ERC-8004 identity, if the agent is registered. */
-  erc8004Id: z.string().optional(),
-  wallets: z.array(AgentWallet).default([]),
+  erc8004Id: z2.string().optional(),
+  /** Semantic grouping labels — the targets of policy `appliesTo.labels`. */
+  labels: z2.array(AgentLabel).max(16).refine((ls) => new Set(ls).size === ls.length, { message: "labels must be unique" }).default([]),
+  wallets: z2.array(AgentWallet).default([]),
   status: AgentStatus.default("active"),
-  createdAt: z.coerce.date()
+  createdAt: z2.coerce.date()
 });
 var ID_PATTERN = /^eip155:(\d+):(0x[0-9a-fA-F]{40})\/(\d+)$/;
 function parseErc8004Id(value) {
@@ -76,33 +126,33 @@ function parseErc8004Id(value) {
     tokenId: BigInt(match[3])
   };
 }
-var Erc8004Id = z.string().refine((value) => parseErc8004Id(value) !== void 0, {
+var Erc8004Id = z2.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 Vendor = z2.object({
+  host: z2.string().min(1),
+  address: z2.string().min(1),
+  erc8004Id: z2.string().optional()
 });
-var TaskContext = z.object({
-  taskId: z.string().optional(),
-  parentRunId: z.string().optional(),
-  purpose: z.string().max(500).optional()
+var TaskContext = z2.object({
+  taskId: z2.string().optional(),
+  parentRunId: z2.string().optional(),
+  purpose: z2.string().max(500).optional()
 });
-var PaymentIntent = z.object({
+var PaymentIntent = z2.object({
   id: IntentId,
   agentId: AgentId,
   vendor: Vendor,
-  resource: z.string(),
+  resource: z2.string(),
   amount: DecimalString,
   asset: Asset,
   chain: Chain,
   taskContext: TaskContext.default({}),
-  nonce: z.string().min(1),
-  createdAt: z.coerce.date()
+  nonce: z2.string().min(1),
+  createdAt: z2.coerce.date()
 });
-var DecisionOutcome = z.enum(["allow", "deny", "escalate"]);
-var Decision = z.object({
+var DecisionOutcome = z2.enum(["allow", "deny", "escalate"]);
+var Decision = z2.object({
   id: DecisionId,
   intentId: IntentId,
   /**
@@ -111,211 +161,428 @@ var Decision = z.object({
    * 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(),
+  intentHash: z2.string(),
   outcome: DecisionOutcome,
   /** Ids of the rules that fired, for explainability. */
-  matchedRules: z.array(z.string()).default([]),
+  matchedRules: z2.array(z2.string()).default([]),
   /** Human-readable explanation surfaced in the dashboard. */
-  reason: z.string().optional(),
-  policyId: z.string(),
-  policyVersion: z.string(),
+  reason: z2.string().optional(),
+  policyId: z2.string(),
+  policyVersion: z2.string(),
   /** Hash of the previous decision in the chain (tamper-evident log). */
-  prevHash: z.string(),
+  prevHash: z2.string(),
   /** Hash of this decision's canonical content. */
-  hash: z.string(),
+  hash: z2.string(),
   /** Service signing-key signature over `hash`. */
-  signature: z.string(),
-  latencyMs: z.number().nonnegative(),
-  decidedAt: z.coerce.date()
+  signature: z2.string(),
+  latencyMs: z2.number().nonnegative(),
+  decidedAt: z2.coerce.date()
 });
-var Session = z.object({
+var AttributedDecision = Decision.extend({ agentId: AgentId.optional() });
+var Session = z2.object({
   id: SessionId,
   agentId: AgentId,
   /** sha256 hex of the bearer token. */
-  tokenHash: z.string(),
+  tokenHash: z2.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()
+  expiresAt: z2.coerce.date(),
+  createdAt: z2.coerce.date(),
+  revokedAt: z2.coerce.date().optional()
 });
-var SettledPayment = z.object({
+var SettledPayment = z2.object({
   intentId: IntentId,
-  txHash: z.string(),
+  txHash: z2.string(),
   chain: Chain,
-  blockNumber: z.coerce.bigint(),
-  facilitator: z.string().optional(),
+  blockNumber: z2.coerce.bigint(),
+  facilitator: z2.string().optional(),
   feePaid: DecimalString.optional(),
-  confirmedAt: z.coerce.date()
+  confirmedAt: z2.coerce.date()
+});
+var SettlementReport = z2.object({
+  intentId: IntentId,
+  /** The settling transaction, when the observer saw one. */
+  txHash: z2.string().optional(),
+  chain: Chain.optional(),
+  /** The amount as SETTLED, when known — may differ from the amount allowed. */
+  amount: DecimalString.optional(),
+  /** Free-form observer tag, e.g. "indexer", "guard", "facilitator". */
+  source: z2.string().min(1).max(64).optional(),
+  confirmedAt: z2.coerce.date()
 });
-var ReceiptSettlement = z.object({
-  txHash: z.string().optional(),
-  networkId: z.string().optional(),
+var ReceiptSettlement = z2.object({
+  txHash: z2.string().optional(),
+  networkId: z2.string().optional(),
   /** Raw header payload, kept for forensics until the indexer confirms. */
-  raw: z.string().optional()
+  raw: z2.string().optional()
 });
-var Receipt = z.object({
+var Receipt = z2.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(),
+  url: z2.string(),
+  method: z2.string().default("GET"),
+  vendorHost: z2.string(),
   amount: DecimalString,
   asset: Asset,
   chain: Chain,
   taskContext: TaskContext.default({}),
   /** Human-readable explanation copied from the decision. */
-  reason: z.string().optional(),
+  reason: z2.string().optional(),
   /** Present only once a payment was made and the vendor confirmed it. */
   settlement: ReceiptSettlement.optional(),
-  createdAt: z.coerce.date()
+  createdAt: z2.coerce.date()
 });
-var GateReceipt = z.object({
+var GateReceipt = z2.object({
   id: GateReceiptId,
-  at: z.coerce.date(),
+  at: z2.coerce.date(),
   /** The route pattern that priced this request, e.g. "/api/reports/*". */
-  route: z.string().min(1),
+  route: z2.string().min(1),
   /** The concrete resource paid for (URL path actually requested). */
-  resource: z.string().min(1),
-  method: z.string().min(1),
+  resource: z2.string().min(1),
+  method: z2.string().min(1),
   /** The paying wallet address, as asserted by the settled payment. */
-  payer: z.string().min(1),
-  payTo: z.string().min(1),
+  payer: z2.string().min(1),
+  payTo: z2.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"),
+  amountAtomic: z2.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),
+  asset: z2.string().min(1),
+  network: z2.string().min(1),
   /** Settlement transaction hash (mock ledger or on-chain). */
-  transaction: z.string().min(1)
+  transaction: z2.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({
+var Window = z2.string().regex(/^\d+[smhd]$/, 'window must be like "30s", "15m", "1h", or "7d"');
+var Multiplier = z2.string().regex(/^\d+(\.\d+)?x$/, 'multiplier must be like "3x"');
+var Condition = z2.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(),
+  rollingSum: z2.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(),
+  txCount: z2.object({ window: Window, gt: z2.number().int().nonnegative() }).optional(),
   /** Vendor host matches one of these patterns (supports `*` globs). */
-  vendorHostIn: z.array(z.string()).optional(),
+  vendorHostIn: z2.array(z2.string()).optional(),
+  /**
+   * Resource PATH matches one of these patterns (supports `*` globs, e.g.
+   * "/v1/reports/*"). A full-URL resource is reduced to its pathname before
+   * matching (see `resourcePathOf`), so the same pattern works whether the
+   * vendor declares "https://api.x.com/v1/answer" or "/v1/answer". Pair
+   * with `vendorHostIn` to scope a path rule to specific vendors.
+   */
+  resourceIn: z2.array(z2.string()).optional(),
   /** First time Rein has seen this vendor for the agent. */
-  vendorFirstSeen: z.boolean().optional(),
+  vendorFirstSeen: z2.boolean().optional(),
   /** Vendor reputation score is below this threshold (Phase 3 hook). */
-  vendorReputationLt: z.number().min(0).max(100).optional(),
+  vendorReputationLt: z2.number().min(0).max(100).optional(),
   /** Amount is more than `gt`-times the observed median for this resource. */
-  amountVsResourceMedian: z.object({ gt: Multiplier }).optional()
+  amountVsResourceMedian: z2.object({ gt: Multiplier }).optional(),
+  /**
+   * Cumulative spend attributed to THIS intent's `taskContext.taskId`
+   * (prior spend on the task plus this payment) exceeds `gt`. Scopes a
+   * budget to one unit of work rather than to a window: a research run that
+   * is meant to cost a dollar cannot quietly cost fifty, however slowly.
+   *
+   * An intent carrying no `taskId` cannot be attributed to a task, so the
+   * predicate never triggers for one. Requiring attribution is a separate,
+   * deliberate rule (deny on `taskIdMissing`), not a side effect of setting
+   * a budget — otherwise every untagged probe payment would trip every
+   * task budget in the policy.
+   */
+  taskBudget: z2.object({ gt: DecimalString }).optional(),
+  /** The intent carries no `taskContext.taskId` (or an empty one). */
+  taskIdMissing: z2.boolean().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),
+var Breaker = z2.object({
+  id: z2.string().min(1),
+  /** The trailing span the tripwires measure over. */
+  window: Window,
+  /**
+   * Trip when the window would hold MORE than this many transactions.
+   * `10` permits ten in the window and escalates the eleventh.
+   */
+  txCount: z2.number().int().positive().optional(),
+  /**
+   * Trip when the window's spend would exceed this total. `"50.00"` permits
+   * a window totalling exactly 50.00 and escalates the payment that would
+   * carry it past. Prospective, like every other spend predicate: the
+   * payment that would breach the cap is the one that escalates, rather
+   * than the innocent one after it.
+   */
+  valueCap: DecimalString.optional()
+}).refine((b) => b.txCount !== void 0 || b.valueCap !== void 0, {
+  message: "a breaker must specify at least one of txCount / valueCap"
+});
+var Rule = z2.object({
+  id: z2.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({
+var PolicyDefault = z2.enum(["allow", "deny"]);
+var AppliesTo = z2.object({
   /** Agent id patterns (supports `*` globs, e.g. "agt_research_*"). */
-  agents: z.array(z.string()).optional(),
-  chains: z.array(Chain).optional()
+  agents: z2.array(z2.string()).optional(),
+  /**
+   * Agent label patterns (supports `*` globs) — semantic targeting. Matches
+   * when the agent carries at least one label matching any pattern. Requires
+   * the agent DOCUMENT: an intent from an unregistered agent never matches a
+   * labels-targeted policy (and so fails closed when no other policy applies).
+   */
+  labels: z2.array(z2.string()).optional(),
+  chains: z2.array(Chain).optional()
 });
-var Escalation = z.object({
-  approvers: z.array(z.string()).default([]),
+var Escalation = z2.object({
+  approvers: z2.array(z2.string()).default([]),
   timeoutAction: PolicyDefault.default("deny"),
-  timeoutMin: z.number().int().positive().default(15)
+  timeoutMin: z2.number().int().positive().default(15)
 });
-var Policy = z.object({
-  policyId: z.string().min(1),
-  version: z.string().default("1"),
+var Policy = z2.object({
+  policyId: z2.string().min(1),
+  version: z2.string().default("1"),
+  /**
+   * The org this policy governs. ABSENT means GLOBAL — it is considered for
+   * every agent, which is what every policy written before tenancy existed is
+   * and stays.
+   *
+   * This is separate from {@link AppliesTo} on purpose, and it has to be:
+   * `appliesTo: {}` matches every agent, so a tenant's policy carrying the
+   * default targeting would otherwise govern other tenants' agents the moment
+   * it was written. Org scoping is applied BEFORE targeting — a policy whose
+   * `orgId` is not the agent's org is not a candidate at all.
+   */
+  orgId: OrgId.optional(),
   appliesTo: AppliesTo.default({}),
-  rules: z.array(Rule).default([]),
+  rules: z2.array(Rule).default([]),
+  /**
+   * Behavioral breakers evaluated alongside the rules. A tripped breaker
+   * escalates at the same precedence as an `escalate` rule — so an explicit
+   * DENY still wins, and an ALLOW rule cannot wave past a tripped breaker.
+   */
+  breakers: z2.array(Breaker).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 LivenessSource = z2.enum([
+  /** It submitted an intent — ANY outcome, including a denial. */
+  "intent",
+  /** It reported in explicitly, having nothing to buy. */
+  "heartbeat"
+]);
+var DEFAULT_LIVENESS_GRACE_MS = 6e4;
+var LivenessExpectation = z2.object({
+  agentId: AgentId,
+  /** Longest silence still considered normal, e.g. '15m'. */
+  interval: Window,
+  /** Extra slack past `interval` before the silence is an alarm. */
+  graceMs: z2.number().int().nonnegative().default(DEFAULT_LIVENESS_GRACE_MS),
+  /**
+   * When watching began. An agent that has NEVER been seen is measured from
+   * here, so a watch on an agent that never starts does raise an alarm — a
+   * detector that never came up is exactly as dead as one that stopped.
+   */
+  since: z2.coerce.date(),
+  /** What this agent is supposed to be doing, shown beside the alarm. */
+  note: z2.string().max(200).optional()
+});
+var LivenessWatchInput = LivenessExpectation.omit({ since: true }).extend({
+  graceMs: z2.number().int().nonnegative().optional()
+});
+var Heartbeat = z2.object({
+  agentId: AgentId,
+  /** When the agent was alive. Defaults to arrival time. */
+  at: z2.coerce.date().optional(),
+  /** Free-form note from the reporter, e.g. "poll cycle 41 ok". */
+  note: z2.string().max(200).optional()
+});
+var LivenessStatus = z2.enum(["alive", "late", "missing", "unknown"]);
+var ApprovalVerdict = z2.enum(["approve", "reject"]);
+var ApprovalStatus = z2.enum(["pending", "approved", "rejected", "expired"]);
+var ApproverKey = z2.object({
+  id: ApproverKeyId,
+  orgId: OrgId,
+  name: z2.string().min(1).max(200),
+  /** ed25519 public key, SPKI PEM — the same encoding as the decision log's. */
+  publicKey: z2.string().min(1),
+  algorithm: z2.literal("ed25519").default("ed25519"),
+  createdAt: z2.coerce.date(),
+  revokedAt: z2.coerce.date().optional()
+});
+var ApprovalRequest = z2.object({
+  /** The `escalate` decision this request answers (primary key). */
+  decisionId: DecisionId,
+  intentId: IntentId,
+  /** Binds the approval to the exact transfer — the signed bytes commit to it. */
+  intentHash: z2.string(),
+  agentId: AgentId,
+  /**
+   * The org the escalating agent belongs to, stamped when the request is
+   * parked. ABSENT means the agent was never registered (or the request
+   * predates tenancy), and such a request is answerable only by an unscoped
+   * operator — there is no org to check an approver against, and guessing one
+   * is how a cross-tenant approval happens.
+   */
+  orgId: OrgId.optional(),
+  vendorHost: z2.string(),
+  resource: z2.string(),
+  amount: DecimalString,
+  asset: Asset,
+  chain: Chain,
+  /**
+   * Task attribution copied from the intent. Carried so an approved payment
+   * still counts against its `taskBudget` — an escalation that lost its task
+   * id on the way through would make the budget silently under-count exactly
+   * the payments a human had to look at.
+   */
+  taskId: z2.string().optional(),
+  /** Why policy escalated, verbatim from the decision. */
+  reason: z2.string(),
+  /**
+   * Breaker ids whose trip contributed to this escalation. An approval of
+   * this request resets exactly these — moving their counting floor to the
+   * approval instant — so a human waving one payment through also clears the
+   * behavior that stopped it, rather than being asked again immediately.
+   * Empty when ordinary rules did the escalating.
+   */
+  breakers: z2.array(z2.string()).default([]),
+  status: ApprovalStatus,
+  createdAt: z2.coerce.date(),
+  /** Past this instant the request denies, whatever arrives afterwards. */
+  expiresAt: z2.coerce.date(),
+  resolvedAt: z2.coerce.date().optional(),
+  /** Which registered key signed — absent when the TTL lapsed instead. */
+  approverKeyId: ApproverKeyId.optional(),
+  /**
+   * The follow-up decision appended to the chain when this resolved. That
+   * decision, not this record, is the voucher a signer verifies: the original
+   * `escalate` decision is never rewritten.
+   */
+  finalDecisionId: DecisionId.optional()
+});
+var ApprovalChallenges = z2.object({
+  approve: z2.string(),
+  reject: z2.string()
+});
+var ApprovalGrant = z2.object({
+  decisionId: DecisionId,
+  intentHash: z2.string(),
+  verdict: ApprovalVerdict,
+  approverKeyId: ApproverKeyId,
+  signature: z2.string().min(1)
+});
+var ReputationSubject = z2.object({
+  kind: z2.enum(["agent", "vendor"]),
+  id: z2.string()
 });
-var ReputationComponents = z.object({
-  volume: z.number(),
-  longevity: z.number(),
-  disputeRate: z.number(),
-  counterpartyQuality: z.number(),
-  settlementReliability: z.number()
+var ReputationComponents = z2.object({
+  volume: z2.number(),
+  longevity: z2.number(),
+  disputeRate: z2.number(),
+  counterpartyQuality: z2.number(),
+  settlementReliability: z2.number()
 });
-var ReputationScore = z.object({
+var ReputationScore = z2.object({
   subject: ReputationSubject,
-  score: z.number().min(0).max(100),
+  score: z2.number().min(0).max(100),
   components: ReputationComponents,
-  confidence: z.number().min(0).max(1),
-  asOf: z.coerce.date(),
+  confidence: z2.number().min(0).max(1),
+  asOf: z2.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(),
+  evidenceUri: z2.string().optional()
+});
+var ReinEvent = z2.discriminatedUnion("type", [
+  z2.object({ type: z2.literal("intent.created"), at: z2.coerce.date(), intent: PaymentIntent }),
+  z2.object({ type: z2.literal("decision.made"), at: z2.coerce.date(), decision: Decision }),
+  z2.object({ type: z2.literal("payment.settled"), at: z2.coerce.date(), payment: SettledPayment }),
+  z2.object({
+    type: z2.literal("shadow.spend"),
+    at: z2.coerce.date(),
     agentId: AgentId,
-    txHash: z.string(),
+    txHash: z2.string(),
     chain: Chain,
     amount: DecimalString
   }),
-  z.object({
-    type: z.literal("signature.released"),
-    at: z.coerce.date(),
+  z2.object({
+    type: z2.literal("signature.released"),
+    at: z2.coerce.date(),
     sessionId: SessionId,
     agentId: AgentId,
     intentId: IntentId,
     decisionId: DecisionId,
     amount: DecimalString
   }),
-  z.object({
-    type: z.literal("signature.refused"),
-    at: z.coerce.date(),
+  z2.object({
+    type: z2.literal("signature.refused"),
+    at: z2.coerce.date(),
     /** Refusal code, e.g. "decision_replayed" (see @reinconsole/signer). */
-    code: z.string(),
-    reason: z.string(),
+    code: z2.string(),
+    reason: z2.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(),
+  z2.object({
+    type: z2.literal("gate.quoted"),
+    at: z2.coerce.date(),
+    resource: z2.string(),
+    method: z2.string(),
     amount: DecimalString,
-    asset: z.string(),
-    network: z.string()
+    asset: z2.string(),
+    network: z2.string()
+  }),
+  z2.object({ type: z2.literal("gate.settled"), at: z2.coerce.date(), receipt: GateReceipt }),
+  z2.object({
+    type: z2.literal("approval.requested"),
+    at: z2.coerce.date(),
+    request: ApprovalRequest
+  }),
+  z2.object({
+    type: z2.literal("approval.resolved"),
+    at: z2.coerce.date(),
+    request: ApprovalRequest,
+    /** The follow-up allow/deny decision this resolution appended. */
+    decision: Decision
   }),
-  z.object({ type: z.literal("gate.settled"), at: z.coerce.date(), receipt: GateReceipt }),
-  z.object({
-    type: z.literal("gate.refused"),
-    at: z.coerce.date(),
+  z2.object({
+    type: z2.literal("liveness.missing"),
+    at: z2.coerce.date(),
+    agentId: AgentId,
+    expectation: LivenessExpectation,
+    /** How long the agent has been silent when the alarm was raised. */
+    silentMs: z2.number().int().nonnegative(),
+    /** Last sighting, absent when the agent was never seen at all. */
+    lastSeenAt: z2.coerce.date().optional()
+  }),
+  z2.object({
+    type: z2.literal("liveness.recovered"),
+    at: z2.coerce.date(),
+    agentId: AgentId,
+    /** How long the silence lasted, measured to this sighting. */
+    silentMs: z2.number().int().nonnegative(),
+    source: LivenessSource
+  }),
+  z2.object({
+    type: z2.literal("gate.refused"),
+    at: z2.coerce.date(),
     /** Refusal code, e.g. "payment_replayed" (see @reinconsole/gate). */
-    code: z.string(),
-    reason: z.string(),
-    resource: z.string(),
+    code: z2.string(),
+    reason: z2.string(),
+    resource: z2.string(),
     /** Known only when the payment header decoded far enough to name a payer. */
-    payer: z.string().optional()
+    payer: z2.string().optional()
   })
 ]);
 
@@ -350,27 +617,103 @@ var MockLedger = class {
 };
 
 // ../../packages/sdk/dist/index.js
-import { z as z2 } from "zod";
-var Health = z2.object({ status: z2.string(), publicKey: z2.string() });
-var EvaluateResponse = z2.object({ intent: PaymentIntent, decision: Decision });
-var PaymentRequirement = z2.object({
-  scheme: z2.string(),
-  network: z2.string(),
+import { z as z3 } from "zod";
+var BreakerState = z3.object({
+  breaker: Breaker,
+  policyId: z3.string(),
+  txCount: z3.number(),
+  sum: z3.string(),
+  countingFrom: z3.number(),
+  resetAt: z3.number().optional(),
+  tripped: z3.boolean(),
+  reason: z3.string().optional()
+});
+var LivenessState = z3.object({
+  agentId: z3.string(),
+  expectation: LivenessExpectation,
+  lastSeenAt: z3.number().optional(),
+  lastSource: LivenessSource.optional(),
+  silentSince: z3.number(),
+  silentMs: z3.number(),
+  dueAt: z3.number(),
+  overdueAt: z3.number(),
+  status: LivenessStatus,
+  alertedAt: z3.number().optional()
+});
+var Health = z3.object({
+  status: z3.string(),
+  publicKey: z3.string(),
+  /** "api-key" once the engine demands a credential; "none" while it does not. */
+  auth: z3.string().optional(),
+  approvals: z3.string().optional()
+});
+var EvaluateResponse = z3.object({
+  intent: PaymentIntent,
+  decision: Decision,
+  /** Present when an escalation was parked for a signed verdict. */
+  approval: ApprovalRequest.optional()
+});
+var ApprovalView = z3.object({
+  request: ApprovalRequest,
+  challenges: ApprovalChallenges,
+  /** The follow-up allow/deny decision, once the request has resolved. */
+  decision: Decision.optional()
+});
+var ResolveResponse = z3.object({ request: ApprovalRequest, decision: Decision });
+var AllowanceGap = z3.object({
+  intentId: z3.string(),
+  decisionId: z3.string().optional(),
+  agentId: z3.string(),
+  host: z3.string(),
+  resource: z3.string(),
+  amount: z3.string(),
+  settledAmount: z3.string().optional(),
+  taskId: z3.string().optional(),
+  allowedAt: z3.number(),
+  ageMs: z3.number(),
+  state: z3.enum(["in-flight", "unsettled", "overspent"])
+});
+var ReconciliationReport = z3.object({
+  from: z3.number(),
+  to: z3.number(),
+  window: z3.string(),
+  graceMs: z3.number(),
+  allowed: z3.number(),
+  allowedValue: z3.string(),
+  settled: z3.number(),
+  settledValue: z3.string(),
+  inFlight: z3.number(),
+  inFlightValue: z3.string(),
+  unsettled: z3.number(),
+  unsettledValue: z3.string(),
+  // Optional on the wire so a 0.2.0 engine still validates; absent means the
+  // engine predates the check, not that nothing was overspent.
+  overspent: z3.number().optional(),
+  overspentValue: z3.string().optional(),
+  unattributed: z3.number(),
+  settlementsSeen: z3.number(),
+  gaps: z3.array(AllowanceGap),
+  truncated: z3.boolean()
+});
+var IssuedApiKey = z3.object({ key: ApiKey, secret: z3.string() });
+var PaymentRequirement = z3.object({
+  scheme: z3.string(),
+  network: z3.string(),
   /** Amount in the asset's atomic units (e.g. "10000" = 0.01 USDC at 6 decimals). */
-  maxAmountRequired: z2.string().regex(/^\d+$/, "atomic amount must be an integer string"),
-  resource: z2.string().optional(),
-  description: z2.string().optional(),
-  mimeType: z2.string().optional(),
-  payTo: z2.string().min(1),
-  maxTimeoutSeconds: z2.number().optional(),
+  maxAmountRequired: z3.string().regex(/^\d+$/, "atomic amount must be an integer string"),
+  resource: z3.string().optional(),
+  description: z3.string().optional(),
+  mimeType: z3.string().optional(),
+  payTo: z3.string().min(1),
+  maxTimeoutSeconds: z3.number().optional(),
   /** Token contract address — or, mock-first, a plain symbol like "USDC". */
-  asset: z2.string().min(1),
-  extra: z2.record(z2.unknown()).optional()
+  asset: z3.string().min(1),
+  extra: z3.record(z3.unknown()).optional()
 });
-var PaymentRequired = z2.object({
-  x402Version: z2.number(),
-  accepts: z2.array(PaymentRequirement).min(1),
-  error: z2.string().optional()
+var PaymentRequired = z3.object({
+  x402Version: z3.number(),
+  accepts: z3.array(PaymentRequirement).min(1),
+  error: z3.string().optional()
 });
 var NETWORK_TO_CHAIN = {
   base: "base",
@@ -384,6 +727,8 @@ var NETWORK_TO_CHAIN = {
   bnb: "bnb",
   bsc: "bnb"
 };
+var ASSET_DECIMALS = { USDC: 6, USDT: 6, EURC: 6 };
+var EVM_ADDRESS = /^0x[0-9a-fA-F]{40}$/;
 var KNOWN_ASSET_ADDRESSES = {
   "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913": "USDC",
   // USDC on Base
@@ -392,18 +737,38 @@ var KNOWN_ASSET_ADDRESSES = {
   EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v: "USDC"
   // USDC on Solana
 };
+var CAIP2_ALIASES = {
+  base: "eip155:8453",
+  "base-sepolia": "eip155:84532",
+  polygon: "eip155:137",
+  "polygon-amoy": "eip155:80002",
+  bnb: "eip155:56",
+  bsc: "eip155:56",
+  solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  "solana-devnet": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1"
+};
+function caip2Of(network) {
+  const key = network.toLowerCase();
+  return CAIP2_ALIASES[key] ?? key;
+}
+function sameNetwork(a, b) {
+  return caip2Of(a) === caip2Of(b);
+}
 function networkToChain(network) {
   return NETWORK_TO_CHAIN[network.toLowerCase()];
 }
 function resolveAsset(requirement, extraAddresses = {}) {
   const direct = Asset.safeParse(requirement.asset.toUpperCase());
   if (direct.success) return direct.data;
+  const known = extraAddresses[requirement.asset] ?? extraAddresses[requirement.asset.toLowerCase()] ?? KNOWN_ASSET_ADDRESSES[requirement.asset] ?? KNOWN_ASSET_ADDRESSES[requirement.asset.toLowerCase()];
+  if (known) return known;
+  if (EVM_ADDRESS.test(requirement.asset)) return void 0;
   const symbol = requirement.extra?.["symbol"];
   if (typeof symbol === "string") {
     const fromExtra = Asset.safeParse(symbol.toUpperCase());
     if (fromExtra.success) return fromExtra.data;
   }
-  return extraAddresses[requirement.asset] ?? extraAddresses[requirement.asset.toLowerCase()] ?? KNOWN_ASSET_ADDRESSES[requirement.asset] ?? KNOWN_ASSET_ADDRESSES[requirement.asset.toLowerCase()];
+  return void 0;
 }
 function atomicToDecimal(atomic, decimals) {
   if (!/^\d+$/.test(atomic)) throw new TypeError(`invalid atomic amount: ${atomic}`);
@@ -413,49 +778,33 @@ function atomicToDecimal(atomic, decimals) {
   const fracPart = digits.slice(digits.length - decimals).replace(/0+$/, "");
   return fracPart.length > 0 ? `${intPart}.${fracPart}` : intPart;
 }
-function requirementDecimals(requirement) {
+function requirementDecimals(requirement, asset) {
+  if (asset) return ASSET_DECIMALS[asset];
   const decimals = requirement.extra?.["decimals"];
   return typeof decimals === "number" && Number.isInteger(decimals) && decimals >= 0 ? decimals : 6;
 }
-var CAIP2_ALIASES = {
-  base: "eip155:8453",
-  "base-sepolia": "eip155:84532",
-  polygon: "eip155:137",
-  "polygon-amoy": "eip155:80002",
-  bnb: "eip155:56",
-  bsc: "eip155:56",
-  solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
-  "solana-devnet": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1"
-};
-function caip2Of(network) {
-  const key = network.toLowerCase();
-  return CAIP2_ALIASES[key] ?? key;
-}
-function sameNetwork(a, b) {
-  return caip2Of(a) === caip2Of(b);
-}
-var PaymentRequirementsV2 = z2.object({
-  scheme: z2.string(),
+var PaymentRequirementsV2 = z3.object({
+  scheme: z3.string(),
   /** CAIP-2, e.g. "eip155:84532". */
-  network: z2.string(),
+  network: z3.string(),
   /** Atomic units — v2's rename of v1's maxAmountRequired. */
-  amount: z2.string().regex(/^\d+$/, "atomic amount must be an integer string"),
-  asset: z2.string().min(1),
-  payTo: z2.string().min(1),
-  maxTimeoutSeconds: z2.number().optional(),
-  extra: z2.record(z2.unknown()).optional()
+  amount: z3.string().regex(/^\d+$/, "atomic amount must be an integer string"),
+  asset: z3.string().min(1),
+  payTo: z3.string().min(1),
+  maxTimeoutSeconds: z3.number().optional(),
+  extra: z3.record(z3.unknown()).optional()
 });
-var ResourceInfoV2 = z2.object({
-  url: z2.string(),
-  description: z2.string().optional(),
-  mimeType: z2.string().optional()
+var ResourceInfoV2 = z3.object({
+  url: z3.string(),
+  description: z3.string().optional(),
+  mimeType: z3.string().optional()
 });
-var PaymentRequiredV2 = z2.object({
-  x402Version: z2.literal(2),
-  error: z2.string().optional(),
+var PaymentRequiredV2 = z3.object({
+  x402Version: z3.literal(2),
+  error: z3.string().optional(),
   resource: ResourceInfoV2.optional(),
-  accepts: z2.array(PaymentRequirementsV2).min(1),
-  extensions: z2.record(z2.unknown()).optional()
+  accepts: z3.array(PaymentRequirementsV2).min(1),
+  extensions: z3.record(z3.unknown()).optional()
 });
 function v2Requirements(requirement) {
   return {
@@ -468,7 +817,7 @@ function v2Requirements(requirement) {
     ...requirement.extra ? { extra: requirement.extra } : {}
   };
 }
-function buildPaymentRequiredV2(requirement, error) {
+function buildPaymentRequiredV2(requirement, error, extensions = {}) {
   return {
     x402Version: 2,
     error,
@@ -480,17 +829,17 @@ function buildPaymentRequiredV2(requirement, error) {
       }
     } : {},
     accepts: [v2Requirements(requirement)],
-    extensions: {}
+    extensions
   };
 }
 function encodeBase64Json(value) {
   return Buffer.from(JSON.stringify(value)).toString("base64");
 }
-var V1Envelope = z2.object({
-  x402Version: z2.literal(1),
-  scheme: z2.string(),
-  network: z2.string(),
-  payload: z2.record(z2.unknown())
+var V1Envelope = z3.object({
+  x402Version: z3.literal(1),
+  scheme: z3.string(),
+  network: z3.string(),
+  payload: z3.record(z3.unknown())
 });
 
 // src/errors.ts
@@ -504,35 +853,35 @@ var FacilitatorError = class extends Error {
 };
 
 // src/payload.ts
-import { z as z3 } from "zod";
-var MockExactPayload = z3.object({
-  from: z3.string().min(1),
-  to: z3.string().min(1),
+import { z as z4 } from "zod";
+var MockExactPayload = z4.object({
+  from: z4.string().min(1),
+  to: z4.string().min(1),
   /** Atomic-unit amount, mirroring the requirement's maxAmountRequired. */
-  value: z3.string().regex(/^\d+$/, "atomic amount must be an integer string"),
-  asset: z3.string().min(1),
+  value: z4.string().regex(/^\d+$/, "atomic amount must be an integer string"),
+  asset: z4.string().min(1),
   /**
    * Rein linkage: the guard's payer stamps the intent id here, the facilitator
    * memos it onto the ledger entry, and the indexer reconciles exactly. A real
    * x402 transfer authorization carries a nonce that serves the same role.
    */
-  intentId: z3.string().optional(),
-  nonce: z3.string().optional()
+  intentId: z4.string().optional(),
+  nonce: z4.string().optional()
 });
-var MockPaymentHeader = z3.object({
-  x402Version: z3.literal(1),
-  scheme: z3.string(),
-  network: z3.string(),
+var MockPaymentHeader = z4.object({
+  x402Version: z4.literal(1),
+  scheme: z4.string(),
+  network: z4.string(),
   payload: MockExactPayload
 });
-var MockPaymentHeaderV2 = z3.object({
-  x402Version: z3.literal(2),
-  accepted: z3.object({
-    scheme: z3.string(),
-    network: z3.string(),
-    amount: z3.string().regex(/^\d+$/, "atomic amount must be an integer string"),
-    asset: z3.string().min(1),
-    payTo: z3.string().min(1)
+var MockPaymentHeaderV2 = z4.object({
+  x402Version: z4.literal(2),
+  accepted: z4.object({
+    scheme: z4.string(),
+    network: z4.string(),
+    amount: z4.string().regex(/^\d+$/, "atomic amount must be an integer string"),
+    asset: z4.string().min(1),
+    payTo: z4.string().min(1)
   }).passthrough(),
   payload: MockExactPayload
 }).passthrough();
@@ -578,12 +927,12 @@ function decodePaymentHeader(raw) {
     payload: parsed.data.payload
   };
 }
-var SettlementResponse = z3.object({
-  success: z3.boolean(),
+var SettlementResponse = z4.object({
+  success: z4.boolean(),
   /** The tx hash on the mock ledger (the guard surfaces this on the receipt). */
-  transaction: z3.string(),
-  network: z3.string(),
-  payer: z3.string().optional()
+  transaction: z4.string(),
+  network: z4.string(),
+  payer: z4.string().optional()
 });
 function encodeSettlementHeader(response) {
   return Buffer.from(JSON.stringify(response)).toString("base64");