@reinconsole/graph 0.1.0

package/dist/index.js

@@ -0,0 +1,910 @@
+// ../../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 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);
+}
+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 REGISTRY_PATTERN = /^0x[0-9a-fA-F]{40}$/;
+var ID_PATTERN = /^eip155:(\d+):(0x[0-9a-fA-F]{40})\/(\d+)$/;
+function formatErc8004Id(ref) {
+  if (!Number.isSafeInteger(ref.chainId) || ref.chainId < 1) {
+    throw new RangeError(`erc8004: bad chainId ${ref.chainId}`);
+  }
+  if (!REGISTRY_PATTERN.test(ref.registry)) {
+    throw new RangeError(`erc8004: bad registry address ${ref.registry}`);
+  }
+  if (typeof ref.tokenId !== "bigint" || ref.tokenId < 0n) {
+    throw new RangeError(`erc8004: bad tokenId ${ref.tokenId}`);
+  }
+  return `eip155:${ref.chainId}:${ref.registry.toLowerCase()}/${ref.tokenId}`;
+}
+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()
+});
+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/evidence.ts
+function normalizeSubject(subject) {
+  if (subject.id.startsWith("eip155:")) {
+    const ref = parseErc8004Id(subject.id);
+    if (ref) return { kind: subject.kind, id: formatErc8004Id(ref) };
+  }
+  const id = subject.kind === "vendor" || subject.id.startsWith("0x") || subject.id.startsWith("0X") ? subject.id.toLowerCase() : subject.id;
+  return { kind: subject.kind, id };
+}
+function subjectKey(subject) {
+  const normal = normalizeSubject(subject);
+  return `${normal.kind}:${normal.id}`;
+}
+var EvidenceLedger = class {
+  records = /* @__PURE__ */ new Map();
+  recordAttempt(subject, atMs) {
+    this.touch(subject, atMs).attempts += 1;
+  }
+  recordSettlement(a, b, amount, atMs) {
+    for (const [subject, other] of [
+      [a, b],
+      [b, a]
+    ]) {
+      const ev = this.touch(subject, atMs);
+      ev.settled += 1;
+      ev.volume = sumDecimal([ev.volume, amount]);
+      const key = subjectKey(other);
+      const line = ev.counterparties.get(key) ?? { settled: 0, volume: "0" };
+      line.settled += 1;
+      line.volume = sumDecimal([line.volume, amount]);
+      ev.counterparties.set(key, line);
+    }
+  }
+  recordRefusal(subject, code, atMs) {
+    const ev = this.touch(subject, atMs);
+    ev.refusals[code] = (ev.refusals[code] ?? 0) + 1;
+  }
+  recordShadowSpend(subject, atMs) {
+    this.touch(subject, atMs).shadowSpends += 1;
+  }
+  recordDispute(subject, atMs) {
+    this.touch(subject, atMs).disputes += 1;
+  }
+  recordEndorsement(subject, atMs) {
+    this.touch(subject, atMs).endorsements += 1;
+  }
+  merge(canonical, alias) {
+    const aliasKey = subjectKey(alias);
+    const canonicalKey = subjectKey(canonical);
+    const from = this.records.get(aliasKey);
+    if (!from || aliasKey === canonicalKey) return;
+    const into = this.records.get(canonicalKey) ?? this.touch(canonical, from.firstSeenMs);
+    into.firstSeenMs = Math.min(into.firstSeenMs, from.firstSeenMs);
+    into.lastSeenMs = Math.max(into.lastSeenMs, from.lastSeenMs);
+    into.attempts += from.attempts;
+    into.settled += from.settled;
+    into.volume = sumDecimal([into.volume, from.volume]);
+    for (const [code, count] of Object.entries(from.refusals)) {
+      into.refusals[code] = (into.refusals[code] ?? 0) + count;
+    }
+    into.shadowSpends += from.shadowSpends;
+    into.disputes += from.disputes;
+    into.endorsements += from.endorsements;
+    for (const [peerKey, line] of from.counterparties) {
+      if (peerKey === canonicalKey) continue;
+      const existing = into.counterparties.get(peerKey) ?? { settled: 0, volume: "0" };
+      existing.settled += line.settled;
+      existing.volume = sumDecimal([existing.volume, line.volume]);
+      into.counterparties.set(peerKey, existing);
+      const peer = this.records.get(peerKey);
+      const held = peer?.counterparties.get(aliasKey);
+      if (peer && held) {
+        peer.counterparties.delete(aliasKey);
+        const reverse = peer.counterparties.get(canonicalKey) ?? { settled: 0, volume: "0" };
+        reverse.settled += held.settled;
+        reverse.volume = sumDecimal([reverse.volume, held.volume]);
+        peer.counterparties.set(canonicalKey, reverse);
+      }
+    }
+    into.counterparties.delete(aliasKey);
+    this.records.delete(aliasKey);
+  }
+  get(subject) {
+    return this.records.get(subjectKey(subject));
+  }
+  getByKey(key) {
+    return this.records.get(key);
+  }
+  all() {
+    return this.records.values();
+  }
+  get size() {
+    return this.records.size;
+  }
+  /**
+   * Insert a fully-formed record verbatim — the hydration primitive a durable
+   * store uses to rebuild the working set on open. Bypasses the live counters
+   * (the record already holds its accumulated state and timestamps).
+   */
+  load(record) {
+    this.records.set(subjectKey(record.subject), record);
+  }
+  /** Get-or-create the record for a subject and stamp first/last seen. */
+  touch(subject, atMs) {
+    const key = subjectKey(subject);
+    let record = this.records.get(key);
+    if (!record) {
+      record = {
+        subject: normalizeSubject(subject),
+        firstSeenMs: atMs,
+        lastSeenMs: atMs,
+        attempts: 0,
+        settled: 0,
+        volume: "0",
+        refusals: {},
+        shadowSpends: 0,
+        disputes: 0,
+        endorsements: 0,
+        counterparties: /* @__PURE__ */ new Map()
+      };
+      this.records.set(key, record);
+    }
+    if (atMs < record.firstSeenMs) record.firstSeenMs = atMs;
+    if (atMs > record.lastSeenMs) record.lastSeenMs = atMs;
+    return record;
+  }
+};
+
+// src/intents.ts
+var DEFAULT_CORRELATION_LIMIT = 1e4;
+var InMemoryIntentStore = class {
+  constructor(limit = DEFAULT_CORRELATION_LIMIT) {
+    this.limit = limit;
+  }
+  limit;
+  intents = /* @__PURE__ */ new Map();
+  remember(intentId, facts) {
+    if (!this.intents.has(intentId) && this.intents.size >= this.limit) {
+      const oldest = this.intents.keys().next().value;
+      if (oldest !== void 0) this.intents.delete(oldest);
+    }
+    this.intents.set(intentId, facts);
+  }
+  peek(intentId) {
+    return this.intents.get(intentId);
+  }
+  take(intentId) {
+    const facts = this.intents.get(intentId);
+    if (facts) this.intents.delete(intentId);
+    return facts;
+  }
+  get size() {
+    return this.intents.size;
+  }
+};
+
+// src/scoring.ts
+var DEFAULT_WEIGHTS = {
+  settlementReliability: 0.3,
+  disputeRate: 0.3,
+  volume: 0.15,
+  counterpartyQuality: 0.15,
+  longevity: 0.1
+};
+var DAY_MS = 864e5;
+var BADNESS = { dispute: 4, shadowSpend: 4, replay: 3, refusal: 1, endorsementCredit: 2 };
+var REPLAY_CODES = /* @__PURE__ */ new Set(["payment_replayed", "decision_replayed"]);
+function clamp(value, lo, hi) {
+  return Math.min(hi, Math.max(lo, value));
+}
+function refusalCounts(ev) {
+  let replays = 0;
+  let others = 0;
+  for (const [code, count] of Object.entries(ev.refusals)) {
+    if (REPLAY_CODES.has(code)) replays += count;
+    else others += count;
+  }
+  return { replays, others };
+}
+function volumeComponent(ev) {
+  return 100 * (1 - Math.exp(-ev.settled / 20));
+}
+function longevityComponent(ev, nowMs) {
+  const knownDays = Math.max(0, nowMs - ev.firstSeenMs) / DAY_MS;
+  return 100 * Math.min(1, knownDays / 30);
+}
+function disputeComponent(ev) {
+  const { replays, others } = refusalCounts(ev);
+  const badness = Math.max(
+    0,
+    ev.disputes * BADNESS.dispute + ev.shadowSpends * BADNESS.shadowSpend + replays * BADNESS.replay + others * BADNESS.refusal - ev.endorsements * BADNESS.endorsementCredit
+  );
+  const interactions = Math.max(1, ev.attempts + ev.disputes + ev.endorsements);
+  return 100 * Math.max(0, 1 - badness / interactions);
+}
+function reliabilityComponent(ev) {
+  if (ev.attempts === 0) return 50;
+  return 100 * Math.min(1, ev.settled / ev.attempts);
+}
+function confidence(ev, nowMs) {
+  const { replays, others } = refusalCounts(ev);
+  const observations = ev.attempts + ev.disputes + ev.endorsements + ev.shadowSpends + replays + others;
+  const depth = 1 - Math.exp(-observations / 10);
+  const knownDays = Math.max(0, nowMs - ev.firstSeenMs) / DAY_MS;
+  const age = 0.4 + 0.6 * Math.min(1, knownDays / 7);
+  return clamp(depth * age, 0, 1);
+}
+function blend(components, weights) {
+  const total = components.volume * weights.volume + components.longevity * weights.longevity + components.disputeRate * weights.disputeRate + components.counterpartyQuality * weights.counterpartyQuality + components.settlementReliability * weights.settlementReliability;
+  return clamp(Math.round(total), 0, 100);
+}
+function blendBase(ev, nowMs, weights) {
+  const remaining = weights.volume + weights.longevity + weights.disputeRate + weights.settlementReliability;
+  if (remaining <= 0) return 50;
+  const total = volumeComponent(ev) * weights.volume + longevityComponent(ev, nowMs) * weights.longevity + disputeComponent(ev) * weights.disputeRate + reliabilityComponent(ev) * weights.settlementReliability;
+  return clamp(total / remaining, 0, 100);
+}
+
+// src/graph.ts
+var NO_FAULT_GATE_CODES = /* @__PURE__ */ new Set([
+  "rate_limited",
+  "velocity_exceeded",
+  "rails_unavailable",
+  "settle_unknown"
+]);
+var ReputationGraph = class {
+  ledger;
+  intents;
+  weights;
+  now;
+  /** aliasKey -> canonical subject. Links are derived state (an agent registry
+   * or ERC-8004 lookup knows them) — re-assert at boot; merges are idempotent. */
+  aliases = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.weights = { ...DEFAULT_WEIGHTS, ...options.weights };
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.ledger = options.ledger ?? new EvidenceLedger();
+    this.intents = options.intents ?? new InMemoryIntentStore(options.correlationLimit ?? DEFAULT_CORRELATION_LIMIT);
+  }
+  /** Subscribe to a bus. Returns `this` so construction chains. */
+  observe(source) {
+    source.onEvent((event) => this.ingest(event));
+    return this;
+  }
+  /**
+   * Fire-and-forget a port write: bus handlers cannot await, and a rejecting
+   * durable write must never become an unhandled rejection (Node kills the
+   * process). Failures are the port's to surface — flush() throws them.
+   */
+  fire(write) {
+    try {
+      void Promise.resolve(write()).catch(() => void 0);
+    } catch {
+    }
+  }
+  /**
+   * Declare that `alias` is the same real-world party as `canonical` (the
+   * ERC-8004 identity story: one identity, many addresses/ids — an engine
+   * agent's ULID and its paying wallet, or a vendor's host and its payTo
+   * address). Everything already known about the alias is folded into the
+   * canonical subject, and all future evidence and lookups for the alias
+   * resolve to it. Idempotent — re-asserting known links at boot is free.
+   */
+  link(canonical, alias) {
+    const target = normalizeSubject(this.resolve(canonical));
+    const aliasKey = subjectKey(alias);
+    if (subjectKey(target) === aliasKey) return;
+    this.aliases.set(aliasKey, target);
+    for (const [key, resolved] of this.aliases) {
+      if (subjectKey(resolved) === aliasKey) this.aliases.set(key, target);
+    }
+    this.fire(() => this.ledger.merge(target, alias));
+  }
+  /** The canonical subject for a possibly-aliased one. */
+  resolve(subject) {
+    return this.aliases.get(subjectKey(subject)) ?? subject;
+  }
+  ingest(event) {
+    const atMs = event.at.getTime();
+    switch (event.type) {
+      case "intent.created": {
+        this.fire(
+          () => this.intents.remember(event.intent.id, {
+            agentId: event.intent.agentId,
+            host: event.intent.vendor.host,
+            amount: event.intent.amount
+          })
+        );
+        return;
+      }
+      case "decision.made": {
+        if (event.decision.outcome !== "allow") return;
+        const facts = this.intents.peek(event.decision.intentId);
+        if (!facts) return;
+        this.fire(() => this.ledger.recordAttempt(this.resolve({ kind: "agent", id: facts.agentId }), atMs));
+        this.fire(() => this.ledger.recordAttempt(this.resolve({ kind: "vendor", id: facts.host }), atMs));
+        return;
+      }
+      case "payment.settled": {
+        const facts = this.intents.take(event.payment.intentId);
+        if (!facts) return;
+        const agent = this.resolve({ kind: "agent", id: facts.agentId });
+        const vendor = this.resolve({ kind: "vendor", id: facts.host });
+        this.fire(() => this.ledger.recordSettlement(agent, vendor, facts.amount, atMs));
+        return;
+      }
+      case "shadow.spend": {
+        this.fire(() => this.ledger.recordShadowSpend(this.resolve({ kind: "agent", id: event.agentId }), atMs));
+        return;
+      }
+      case "signature.refused": {
+        const agentId = event.agentId;
+        if (!agentId) return;
+        this.fire(
+          () => this.ledger.recordRefusal(this.resolve({ kind: "agent", id: agentId }), event.code, atMs)
+        );
+        return;
+      }
+      case "gate.settled": {
+        const payer = this.resolve({ kind: "agent", id: event.receipt.payer });
+        const recipient = this.resolve({ kind: "vendor", id: event.receipt.payTo });
+        this.fire(() => this.ledger.recordAttempt(payer, atMs));
+        this.fire(() => this.ledger.recordAttempt(recipient, atMs));
+        this.fire(() => this.ledger.recordSettlement(payer, recipient, event.receipt.amount, atMs));
+        return;
+      }
+      case "gate.refused": {
+        if (!event.payer || NO_FAULT_GATE_CODES.has(event.code)) return;
+        const payer = this.resolve({ kind: "agent", id: event.payer });
+        this.fire(() => this.ledger.recordAttempt(payer, atMs));
+        this.fire(() => this.ledger.recordRefusal(payer, event.code, atMs));
+        return;
+      }
+      // signature.released and gate.quoted carry no evidence the engine-side
+      // events don't already: released duplicates the allow that preceded it,
+      // and a quote names no payer.
+      case "signature.released":
+      case "gate.quoted":
+        return;
+    }
+  }
+  /**
+   * Agent-side alternative to observing the engine bus: feed the SDK guard's
+   * onReceipt straight in. Connect events OR receipts per side, not both —
+   * a receipt restates the decision/settlement the bus already carried.
+   */
+  ingestReceipt(receipt) {
+    if (receipt.outcome !== "allow") return;
+    const atMs = receipt.createdAt.getTime();
+    const agent = this.resolve({ kind: "agent", id: receipt.agentId });
+    const vendor = this.resolve({ kind: "vendor", id: receipt.vendorHost });
+    this.fire(() => this.ledger.recordAttempt(agent, atMs));
+    this.fire(() => this.ledger.recordAttempt(vendor, atMs));
+    if (receipt.settlement?.txHash) {
+      this.fire(() => this.ledger.recordSettlement(agent, vendor, receipt.amount, atMs));
+    }
+  }
+  /** Record an out-of-band dispute or endorsement against a subject. */
+  report(input) {
+    const atMs = (input.at ?? this.now()).getTime();
+    const subject = this.resolve(input.subject);
+    if (input.kind === "dispute") this.fire(() => this.ledger.recordDispute(subject, atMs));
+    else this.fire(() => this.ledger.recordEndorsement(subject, atMs));
+  }
+  /** Await any pending durable writes (no-op for in-memory stores). */
+  async flush() {
+    await this.ledger.flush?.();
+    await this.intents.flush?.();
+  }
+  /** The score for one subject, or undefined when nothing is known (fairness).
+   *  Aliased subjects resolve to their canonical identity — a linked wallet
+   *  answers with the merged history, on both sides of the wire. */
+  score(subject) {
+    const ev = this.ledger.get(this.resolve(subject));
+    return ev && this.scoreOf(ev);
+  }
+  /** All known scores, best first. */
+  scores(kind) {
+    const out = [];
+    for (const ev of this.ledger.all()) {
+      if (kind && ev.subject.kind !== kind) continue;
+      out.push(this.scoreOf(ev));
+    }
+    return out.sort((a, b) => b.score - a.score);
+  }
+  /** The score plus the raw evidence behind it. */
+  explain(subject) {
+    const ev = this.ledger.get(this.resolve(subject));
+    if (!ev) return void 0;
+    return {
+      score: this.scoreOf(ev),
+      weights: this.weights,
+      evidence: {
+        attempts: ev.attempts,
+        settled: ev.settled,
+        volume: ev.volume,
+        refusals: { ...ev.refusals },
+        shadowSpends: ev.shadowSpends,
+        disputes: ev.disputes,
+        endorsements: ev.endorsements,
+        firstSeen: new Date(ev.firstSeenMs),
+        lastSeen: new Date(ev.lastSeenMs),
+        counterparties: [...ev.counterparties.entries()].map(([key, line]) => {
+          const [kind, ...id] = key.split(":");
+          return {
+            subject: { kind, id: id.join(":") },
+            settled: line.settled,
+            volume: line.volume
+          };
+        })
+      }
+    };
+  }
+  /**
+   * Push every vendor score that clears the confidence floor into the engine's
+   * spend store (or any sink). Returns what was pushed. Low-confidence scores
+   * are withheld so `vendorReputationLt` keeps treating thin histories as
+   * unknown — the evaluator's no-data-no-trigger rule stays intact end to end.
+   */
+  async syncVendors(sink, options = {}) {
+    const minConfidence = options.minConfidence ?? 0.3;
+    const pushed = [];
+    for (const ev of this.ledger.all()) {
+      if (ev.subject.kind !== "vendor") continue;
+      const score = this.scoreOf(ev);
+      if (score.confidence < minConfidence) continue;
+      await sink.setVendorReputation(ev.subject.id, score.score);
+      pushed.push({ host: ev.subject.id, score: score.score, confidence: score.confidence });
+    }
+    return pushed;
+  }
+  /** Number of subjects with evidence. */
+  subjects() {
+    return this.ledger.size;
+  }
+  scoreOf(ev) {
+    const nowMs = this.now().getTime();
+    const components = {
+      volume: volumeComponent(ev),
+      longevity: longevityComponent(ev, nowMs),
+      disputeRate: disputeComponent(ev),
+      counterpartyQuality: this.counterpartyQuality(ev, nowMs),
+      settlementReliability: reliabilityComponent(ev)
+    };
+    return ReputationScore.parse({
+      subject: ev.subject,
+      score: blend(components, this.weights),
+      components,
+      confidence: confidence(ev, nowMs),
+      asOf: new Date(nowMs)
+    });
+  }
+  /** One-hop mean of the counterparties' base scores; neutral 50 when alone. */
+  counterpartyQuality(ev, nowMs) {
+    if (ev.counterparties.size === 0) return 50;
+    let total = 0;
+    for (const key of ev.counterparties.keys()) {
+      const other = this.ledger.getByKey(key);
+      total += other ? blendBase(other, nowMs, this.weights) : 50;
+    }
+    return total / ev.counterparties.size;
+  }
+};
+function payerCheck(graph, options = {}) {
+  const denyBelow = options.denyBelow ?? 40;
+  const minConfidence = options.minConfidence ?? 0.3;
+  return (payer) => {
+    const score = graph.score({ kind: "agent", id: payer });
+    if (!score || score.confidence < minConfidence) return void 0;
+    if (score.score >= denyBelow) return void 0;
+    return `payer reputation ${score.score} is below this gate's floor of ${denyBelow}`;
+  };
+}
+
+// src/server.ts
+import { fileURLToPath } from "url";
+import { realpathSync } from "fs";
+import Fastify from "fastify";
+import { z as z2 } from "zod";
+var ReportInput = z2.object({
+  subject: ReputationSubject,
+  kind: z2.enum(["dispute", "endorsement"]),
+  at: z2.coerce.date().optional(),
+  note: z2.string().max(500).optional()
+});
+var ScoresQuery = z2.object({ kind: z2.enum(["agent", "vendor"]).optional() });
+var LinkInput = z2.object({
+  canonical: ReputationSubject,
+  alias: ReputationSubject
+}).refine((l) => l.canonical.kind === l.alias.kind, {
+  message: "canonical and alias must be the same kind"
+});
+function buildGraphServer(graph = new ReputationGraph()) {
+  const app = Fastify({ logger: false });
+  app.setErrorHandler((err, _req, reply) => {
+    if (err instanceof z2.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", subjects: graph.subjects() }));
+  app.post("/v1/events", async (req) => {
+    const events = z2.union([ReinEvent.transform((e) => [e]), z2.array(ReinEvent)]).parse(req.body);
+    for (const event of events) graph.ingest(event);
+    await graph.flush();
+    return { ingested: events.length };
+  });
+  app.post("/v1/reports", async (req) => {
+    const input = ReportInput.parse(req.body);
+    graph.report(input);
+    await graph.flush();
+    return graph.score(input.subject);
+  });
+  app.post("/v1/links", async (req) => {
+    const links = z2.union([LinkInput.transform((l) => [l]), z2.array(LinkInput)]).parse(req.body);
+    for (const link of links) graph.link(link.canonical, link.alias);
+    await graph.flush();
+    return { linked: links.length };
+  });
+  app.get("/v1/scores", (req) => {
+    const { kind } = ScoresQuery.parse(req.query);
+    return graph.scores(kind);
+  });
+  app.get("/v1/scores/:kind/:id", (req, reply) => {
+    const subject = ReputationSubject.parse(req.params);
+    const explanation = graph.explain(subject);
+    if (!explanation) {
+      return reply.status(404).send({ error: "not_found", message: `no evidence for ${subject.kind} ${subject.id}` });
+    }
+    return explanation;
+  });
+  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 ?? 8788);
+  const host = process.env.HOST ?? "0.0.0.0";
+  const app = buildGraphServer();
+  app.listen({ port, host }).then(() => console.log(`[rein] graph listening on http://${host}:${port}`)).catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}
+export {
+  DEFAULT_CORRELATION_LIMIT,
+  DEFAULT_WEIGHTS,
+  EvidenceLedger,
+  InMemoryIntentStore,
+  ReputationGraph,
+  blend,
+  blendBase,
+  buildGraphServer,
+  confidence,
+  disputeComponent,
+  longevityComponent,
+  normalizeSubject,
+  payerCheck,
+  reliabilityComponent,
+  subjectKey,
+  volumeComponent
+};
+//# sourceMappingURL=index.js.map