cordon-mcp 0.1.0

package/dist/cordon-mcp.js

@@ -0,0 +1,3651 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../daemon/src/config.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// ../fixtures/src/gates.gen.ts
+var GATE_RUNS = {
+  "G1": { "id": "G1", "status": "green", "tests": 66, "passed": 66, "recordedAt": "2026-09-11" },
+  "G2": { "id": "G2", "status": "green", "tests": 8, "passed": 8, "recordedAt": "2026-09-11" },
+  "G3": { "id": "G3", "status": "green", "tests": 5, "passed": 5, "recordedAt": "2026-09-10" },
+  "G4": { "id": "G4", "status": "green", "tests": 1, "passed": 1, "recordedAt": "2026-09-08" },
+  "G5": { "id": "G5", "status": "green", "tests": 12, "passed": 12, "recordedAt": "2026-09-08" },
+  "G6": { "id": "G6", "status": "green", "tests": 14, "passed": 14, "recordedAt": "2026-09-08" },
+  "G7": { "id": "G7", "status": "green", "tests": 10, "passed": 10, "recordedAt": "2026-09-09" }
+};
+
+// ../fixtures/src/search.gen.ts
+var SEARCH = {
+  strategies: 1200,
+  draws: 45360,
+  released: 33327,
+  refused: 12033,
+  passedABound: 0,
+  closestToBudget6: 100000000n,
+  budget6: 100000000n,
+  releasedAmount6: 67783468046n,
+  recordedAt: "2026-09-08"
+};
+
+// ../fixtures/src/deployment.gen.ts
+var DEPLOYMENT = {
+  chainId: 5042002,
+  registry: "0xf86de085e63b00c9fba300b19807c883deb961e9",
+  vault: "0x00ab57acd260c594a661b6101bdf7e92267af135",
+  record: "0x2a8361ac23f5ffcfde9f0d7bc7618178770332d0",
+  fromBlock: "61265318",
+  commit: "ee3955b82fb0b6f7786bbfb5b2f5ebc2b174f8cc",
+  deployedAt: "2026-09-09T17:24:22.882Z"
+};
+
+// ../fixtures/src/drill.gen.ts
+var DRILL_RUN = {
+  recordedAt: "2026-09-10T20:56:30.337Z",
+  node: "0x92d7ae3dbcc740cdcdc5fb8cd911fc9bebcbd35b742e5d517941f8660d51d6de",
+  authorised6: 20000n,
+  lifetimeCap6: 20000n,
+  trancheCap6: 1000n,
+  spent6: 7000n,
+  requests: 9,
+  nodesInSubtree: 1,
+  refusals: [
+    {
+      "id": "6",
+      "reason": "concentration",
+      "node": "0x92d7ae3dbcc740cdcdc5fb8cd911fc9bebcbd35b742e5d517941f8660d51d6de",
+      "breachedAt": "0x92d7ae3dbcc740cdcdc5fb8cd911fc9bebcbd35b742e5d517941f8660d51d6de",
+      "tx": "0x425071b1d6af400d5b2efb8d228a60dea1b3608655212872ef27c7bc5ec4e822"
+    },
+    {
+      "id": "7",
+      "reason": "concentration",
+      "node": "0x92d7ae3dbcc740cdcdc5fb8cd911fc9bebcbd35b742e5d517941f8660d51d6de",
+      "breachedAt": "0x92d7ae3dbcc740cdcdc5fb8cd911fc9bebcbd35b742e5d517941f8660d51d6de",
+      "tx": "0x81b956ff8769fe3b045edf0f3bf07ddc4893975af356abdfff7da3da17b4ecfb"
+    }
+  ]
+};
+
+// ../fixtures/src/index.ts
+var ARC = {
+  chainId: 5042002,
+  name: "Arc testnet",
+  rpc: "https://rpc.testnet.arc.io",
+  explorer: "https://testnet.arcscan.app",
+  faucet: "https://faucet.circle.com",
+  /** Gas token is USDC, native, 18 decimals. */
+  nativeDecimals: 18,
+  /**
+   * The ERC-20 view of the same balance. balanceOf truncates below 1e-6.
+   *
+   * This predeploy is a real FiatTokenV2, confirmed against the live chain on
+   * 8 Sep 2026: it answers `DOMAIN_SEPARATOR()`, `authorizationState` and
+   * `nonces`, and `transferWithAuthorization` reverts with its own
+   * "FiatTokenV2: authorization is expired". An unknown selector reverts, so
+   * none of that is a fallback answering yes to everything. Its separator is
+   * what name "USDC" at version "2" on this chain hashes to, which is why
+   * x402 `exact` can settle here at all. No figure from that run is written
+   * down: `attest/src/collect.ts` reads the domain off the token at startup
+   * and is the only authority on it, because a domain one character out fails
+   * at settlement and looks like the payer's fault.
+   */
+  erc20: "0x3600000000000000000000000000000000000000",
+  erc20Decimals: 6,
+  /**
+   * Multicall3, at the address it has on every chain that has one.
+   *
+   * Not ours and not deployed by us, so it belongs here beside the USDC
+   * predeploy rather than in `deployments/`. Confirmed on Arc testnet on
+   * 12 Sep 2026: the address carries code and `getBlockNumber()` answers
+   * 61598855.
+   *
+   * The console reads a tree of mandates node by node, four views each. Packed
+   * through this, a whole level of the descent is one request; without it, a
+   * thirteen-node tree was a hundred and twenty calls to the public RPC and a
+   * third of them came back 429.
+   */
+  multicall3: "0xcA11bde05977b3631167028862bE2a173976CA11",
+  mainnetLaunched: false
+};
+var ERC8004 = {
+  identity: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
+  reputation: "0x8004B663056A597Dffe9eCcC1965A193B7388713",
+  /** eth_getCode against Arc testnet returned 130 bytes for both. */
+  bytesOnArc: 130,
+  liveSince: "2026-01-29",
+  chains: 40,
+  registeredAgents: 173441,
+  /** The identity metadata key a spawned agent's stated purpose is written
+   *  under. The spawner's description of the agent, never a bound: the
+   *  contract reads nothing from it. */
+  purposeKey: "cordon.purpose",
+  /** One line, long enough to say what an agent is for and short enough to show. */
+  purposeMaxLength: 140
+};
+var GATEWAY = {
+  verifiedOn: "2026-09-08",
+  /** GatewayWallet on Arc testnet. An ERC-1967 proxy; the implementation is
+   *  22,818 bytes and carries the deposit selectors below. */
+  wallet: "0x0077777d7EBA4688BDeF3E311b846F25870A19B9",
+  implementation: "0xa33d52b46964495ea6e2bb09ce85faed05776e28",
+  /**
+   * RISK 4, ANSWERED — and favourably.
+   *
+   * `depositFor(address token, address depositor, uint256 value)` credits the
+   * `depositor` parameter, not `msg.sender`. Verified on Arc: the call reaches
+   * the allowance check rather than failing dispatch, so the selector is live.
+   * The vault can therefore fund a beneficiary's Gateway balance directly, and
+   * the plan's fallback — routing through the daemon's own address — is not
+   * needed.
+   */
+  depositForCreditsBeneficiary: true,
+  /**
+   * RISK 4b, THE ONE NOBODY ASKED.
+   *
+   * The seller is named in `destinationRecipient`, a field of the TransferSpec
+   * inside a burn intent that is signed OFF CHAIN by the depositor and handed
+   * to Circle's API. GatewayWallet never sees it, and no contract can.
+   *
+   * So a Gateway balance is spendable to anyone its depositor chooses, with
+   * one off-chain signature and no on-chain step for Cordon to sit in. Any
+   * bound that names a counterparty — concentration, above all — cannot be
+   * enforced against money that already sits in a Gateway balance. It can only
+   * be enforced at the moment the balance is topped up, or measured afterwards
+   * from settlement records.
+   */
+  sellerIsOffChainOnly: true,
+  sellerField: "destinationRecipient",
+  /**
+   * RISK 5, STILL OPEN.
+   *
+   * The plan lists `GET /search-x402transfers` as the way the meter reads a
+   * buyer's own settled transfers. It could not be confirmed: Circle's public
+   * Gateway technical guide documents no x402 endpoints at all, and unauthed
+   * probes of the obvious hosts answered 404, which proves nothing either way.
+   * Until a key confirms it, the meter has no verified buyer-side source.
+   */
+  searchX402Transfers: "unverified",
+  /* ---------------------------------------------------------------- */
+  /* Settlement, answered on 2026-09-11 by doing it                    */
+  /* ---------------------------------------------------------------- */
+  /**
+   * The two facts that were missing, and are not missing any more.
+   *
+   * `settle.ts` used to refuse on the grounds that the burn-intent EIP-712
+   * definition was unpublished and that submission needed a Circle key.
+   * Neither is true: the domain is `{ name: "GatewayWallet", version: "1" }`
+   * with the types the daemon now carries, and
+   * `https://gateway-api-testnet.circle.com` answers `/v1/info`,
+   * `/v1/balances` and `/v1/transfer` with no credential at all.
+   */
+  api: "https://gateway-api-testnet.circle.com",
+  /** Gateway's own id for Arc testnet, from `/v1/info`. */
+  domain: 26,
+  /** GatewayMinter on Arc. The mint is the call that lands the money. */
+  minter: "0x0022222ABE238Cc2C7Bb1f21003F0a260052475B",
+  /**
+   * RISK 6, AND THE ONE THAT DECIDES THE RAIL.
+   *
+   * Circle's fee for a same-chain Gateway transfer on Arc, in base units:
+   * **$0.0035**, quoted by the API itself and charged **on top of** the value
+   * — a burn of $0.0065 against a $0.0100 balance is accepted, a burn of
+   * $0.0100 against it is refused for `required 0.0135`. So a tranche can
+   * only pay for its own settlement when it is larger than this.
+   *
+   * The alternative is `withdrawalDelay` on GatewayWallet, which reads
+   * 1,209,600 — fourteen days. Neither is compatible with a payment of a
+   * tenth of a cent, and that is a fact about the rail rather than about us.
+   */
+  baseFee6: 3500n,
+  withdrawalDelaySeconds: 1209600,
+  /** Gas the mint itself cost on Arc, measured: 0.002975 of one balance. */
+  mintGas6: 2975n,
+  settlementVerifiedOn: "2026-09-11"
+};
+var PENDING_ADDRESS = "pending \u2014 written by the deploy script";
+var PENDING_MANDATE = "pending \u2014 no mandate signed yet";
+var MANDATE = {
+  /** No mandate is open yet. The owner signs the first one from their own
+   *  wallet, and nothing here may stand in for a signature nobody gave. */
+  id: PENDING_MANDATE,
+  /** TreeVault.windowBudget(root) — base units, 6 dp. What may be drawn in
+   *  any one window. It resets, which is why the cap below exists. */
+  budget6: 20000000n,
+  /** TreeVault.lifetimeSpent(node) — base units, 6 dp, and it never resets.
+   *
+   *  A window budget alone is a rate, not a total: a mandate left running for
+   *  a week authorises seven windows. This is the total the owner signed for,
+   *  and the binding limit is whichever of the two is reached first. Larger
+   *  than one window on purpose, so both bounds are reachable and a reader can
+   *  see they are different things. */
+  lifetimeCap6: 50000000n,
+  /** Equal at every depth by construction. A shorter child window resets faster. */
+  windowSeconds: 86400,
+  /** MandateRegistry.maxDepth() */
+  maxDepth: 3,
+  /** TreeVault.trancheCap() */
+  tranche6: 1000000n,
+  /** TreeVault.concentrationBound() — share of the window to one counterparty. */
+  concentrationBoundPct: 35,
+  /** The one on chain, never a literal. */
+  vault: DEPLOYMENT?.vault ?? PENDING_ADDRESS,
+  /** The owner is whoever opens the mandate, and nobody has. */
+  owner: PENDING_MANDATE
+};
+var STRENGTH = {
+  budget: "enforced",
+  headroom: "enforced",
+  treeBar: "enforced",
+  refusal: "enforced",
+  depth: "enforced",
+  tranche: "enforced",
+  lifetime: "enforced",
+  release: "enforced",
+  revoke: "enforced",
+  record: "enforced",
+  /* `depositFor` credits the depositor parameter, checked on chain, so the
+     top-up itself is enforced. What is declared is who the operator then pays
+     out of that balance, and that is the `concentration` row below. */
+  gatewayTopUp: "enforced",
+  concentration: "declared"
+};
+var ENFORCED_BY = {
+  budget: "TreeVault.windowSpent(node)",
+  headroom: "TreeVault.headroom(node)",
+  treeBar: "TreeVault.ancestorDebit(node, amount)",
+  refusal: "TreeVault.evaluate(node, amount) -> Refused",
+  gatewayTopUp: "GatewayWallet.depositFor(usdc, operator, amount)",
+  /** Bounds the counterparty the daemon declared, not the one it paid. */
+  concentration: "TreeVault.concentrationBound(node, counterparty)",
+  depth: "MandateRegistry.maxDepth()",
+  tranche: "TreeVault.trancheCap()",
+  lifetime: "TreeVault.lifetimeSpent(node)",
+  release: "TreeVault.release(refusalId), owner signature",
+  revoke: "MandateRegistry.revoke(node), subtree",
+  record: "ReputationRegistry.giveFeedback(agentId, score, tags, uri)"
+};
+var STRENGTH_BY_FN = Object.fromEntries(
+  Object.entries(ENFORCED_BY).map(([key, fn]) => [fn, STRENGTH[key] ?? "declared"])
+);
+var GATE_DEFINITIONS = [
+  { id: "G1", name: "tree arithmetic", ends: "every draw debits every ancestor, exactly" },
+  { id: "G2", name: "live on Arc", ends: "four-agent tree, no agent holds a key, refusal on arcscan" },
+  { id: "G3", name: "the hostile drill", ends: "an unrestricted agent is told to spend, and the number is published" },
+  { id: "G4", name: "bounded search", ends: "thousands of strategies scored by the contract, none passes a bound" },
+  { id: "G5", name: "the refusal survives us", ends: "no admin key, no proxy, reversal fails as the deployer" },
+  { id: "G6", name: "the record cannot be forged", ends: "every record names its draw transaction; nobody else can write one" },
+  { id: "G7", name: "the work still gets done", ends: "one task, two conditions, three runs each, and the brief completes under the fence" }
+];
+var GATES = GATE_DEFINITIONS.map((g) => {
+  const run = GATE_RUNS[g.id];
+  return {
+    ...g,
+    status: run ? run.status : "pending",
+    tests: run ? run.tests : null,
+    recordedAt: run ? run.recordedAt : null
+  };
+});
+var DRILL = {
+  status: "run",
+  /** What the drill was measured against: the window its own mandate signed. */
+  ceiling6: DRILL_RUN.authorised6,
+  reached6: DRILL_RUN.spent6,
+  /** Of the ceiling, in basis points. 10,000 would be the treasury reached. */
+  reachedBps: Number(DRILL_RUN.spent6 * 10000n / DRILL_RUN.authorised6),
+  /** Every reason that stopped it, in the order the chain recorded them. */
+  stoppedBy: [...new Set(DRILL_RUN.refusals.map((refusal) => refusal.reason))],
+  run: DRILL_RUN
+};
+var REASONS = [
+  "none",
+  "revoked",
+  "tranche-cap",
+  "window-budget",
+  "concentration",
+  "vault-balance",
+  "lifetime-cap"
+];
+var UNRECOGNISED = "unrecognised-reason";
+var REASON_MEANING = {
+  revoked: "the mandate for this branch was cut",
+  "tranche-cap": "the purchase is larger than one draw may be",
+  "window-budget": "the window is spent, on this node or an ancestor",
+  "lifetime-cap": "the total this mandate was signed for is spent, and it does not come back",
+  concentration: "this recipient has taken its share of the window",
+  "vault-balance": "the bounds passed and the treasury is empty"
+};
+var SEARCH_CLEAN = SEARCH.passedABound === 0;
+var share = (bps) => MANDATE.budget6 * BigInt(bps) / 10000n;
+var COUNTERFACTUAL = {
+  kind: "illustration",
+  steps: [
+    { draw: 1, without6: share(12700), with6: share(4700), refused: false },
+    { draw: 2, without6: share(28400), with6: share(8300), refused: false },
+    { draw: 3, without6: share(45100), with6: MANDATE.budget6, refused: true },
+    { draw: 4, without6: share(61200), with6: MANDATE.budget6, refused: true },
+    { draw: 5, without6: share(84700), with6: MANDATE.budget6, refused: true }
+  ]
+};
+var STRUCTURING_CALLS = 2e3;
+var STRUCTURING_UNIT = 8e-3;
+var STRUCTURING = {
+  calls: STRUCTURING_CALLS,
+  unitPrice: STRUCTURING_UNIT,
+  total: STRUCTURING_CALLS * STRUCTURING_UNIT,
+  refusedBy: ENFORCED_BY.concentration
+};
+
+// ../daemon/src/config.ts
+var ConfigError = class extends Error {
+};
+var ENV = {
+  required: {
+    CORDON_VAULT: "TreeVault address, from deployments/<chainId>.json",
+    CORDON_REGISTRY: "MandateRegistry address, from the same file",
+    "CORDON_NODE_<label>": "the mandate node this daemon acts for",
+    "CORDON_KEY_<label>": "the operator key for that node. The agent never sees it"
+  },
+  optional: {
+    CORDON_RECORD: "ConductRecord, from deployments/<chainId>.json. Without it, refusals are enforced but never published",
+    CORDON_IDENTITY: `ERC-8004 Identity; defaults to ${ERC8004.identity}`,
+    CORDON_RPC: `defaults to ${ARC.rpc}`,
+    CORDON_CHAIN_ID: `defaults to ${ARC.chainId}`,
+    CORDON_USDC: "the 6-decimal ERC-20 view; defaults to Arc's",
+    CORDON_NETWORKS: "CAIP-2 ids this daemon will settle on",
+    CORDON_ASSETS: "assets it will pay in",
+    CORDON_PORT: "defaults to 8402",
+    CORDON_POLL_MS: "receipt polling interval; defaults to 250, matched to Arc's finality rather than to viem's 4,000",
+    CORDON_KEY_FILE: "where a spawned child's key is written, before the spawn is sent; defaults to ~/.cordon/cordon.env"
+  }
+};
+function required(env, name) {
+  const v = env[name];
+  if (!v) throw new ConfigError(`${name} is not set`);
+  return v;
+}
+function address(env, name) {
+  const v = required(env, name);
+  if (!/^0x[0-9a-fA-F]{40}$/.test(v)) throw new ConfigError(`${name} is not an address: ${v}`);
+  return v;
+}
+function load(env = process.env) {
+  const keys = [];
+  for (const [name, value] of Object.entries(env)) {
+    if (!name.startsWith("CORDON_NODE_") || !value) continue;
+    const label = name.slice("CORDON_NODE_".length);
+    if (!/^0x[0-9a-fA-F]{64}$/.test(value)) {
+      throw new ConfigError(`${name} is not a node id: ${value}`);
+    }
+    const keyEnv = `CORDON_KEY_${label}`;
+    if (!env[keyEnv]) throw new ConfigError(`${name} is set but ${keyEnv} is not`);
+    keys.push({ node: value, keyEnv });
+  }
+  if (keys.length === 0) throw new ConfigError("no CORDON_NODE_<label> is set");
+  return {
+    rpcUrl: env.CORDON_RPC ?? ARC.rpc,
+    chainId: Number(env.CORDON_CHAIN_ID ?? ARC.chainId),
+    vault: address(env, "CORDON_VAULT"),
+    registry: address(env, "CORDON_REGISTRY"),
+    usdc: env.CORDON_USDC ?? ARC.erc20,
+    record: env.CORDON_RECORD ? address(env, "CORDON_RECORD") : void 0,
+    identity: env.CORDON_IDENTITY ?? ERC8004.identity,
+    networks: (env.CORDON_NETWORKS ?? `eip155:${ARC.chainId}`).split(",").map((s) => s.trim()),
+    assets: (env.CORDON_ASSETS ?? ARC.erc20).split(",").map((s) => s.trim()),
+    port: Number(env.CORDON_PORT ?? 8402),
+    pollMs: Number(env.CORDON_POLL_MS ?? 250),
+    keys,
+    keyFile: env.CORDON_KEY_FILE ?? join(homedir(), ".cordon", "cordon.env")
+  };
+}
+
+// ../daemon/src/gate.ts
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  defineChain,
+  decodeEventLog
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+
+// ../daemon/src/abi.gen.ts
+var TreeVaultAbi = [
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "usdc_",
+        "type": "address",
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "registry_",
+        "type": "address",
+        "internalType": "contract MandateRegistry"
+      },
+      {
+        "name": "gateway_",
+        "type": "address",
+        "internalType": "contract IGatewayWallet"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "ancestorDebit",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "amount6",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "nodes",
+        "type": "bytes32[]",
+        "internalType": "bytes32[]"
+      },
+      {
+        "name": "spentAfter6",
+        "type": "uint128[]",
+        "internalType": "uint128[]"
+      },
+      {
+        "name": "budget6",
+        "type": "uint128[]",
+        "internalType": "uint128[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "concentrationBound",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "counterparty",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "spent6",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "limit6",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "draw",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "counterparty",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount6",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "released",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "refusalId",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reason",
+        "type": "uint8",
+        "internalType": "enum TreeVault.Reason"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "evaluate",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "counterparty",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount6",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "reason",
+        "type": "uint8",
+        "internalType": "enum TreeVault.Reason"
+      },
+      {
+        "name": "breachedAt",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "fund",
+    "inputs": [
+      {
+        "name": "root",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "amount6",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "gateway",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IGatewayWallet"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "headroom",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "available6",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "boundBy",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "lifetimeSpent",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "refusal",
+    "inputs": [
+      {
+        "name": "id",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "tuple",
+        "internalType": "struct TreeVault.Refusal",
+        "components": [
+          {
+            "name": "node",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "breachedAt",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "counterparty",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount6",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "reason",
+            "type": "uint8",
+            "internalType": "enum TreeVault.Reason"
+          },
+          {
+            "name": "at",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "released",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "refusalCount",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "registry",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract MandateRegistry"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "release",
+    "inputs": [
+      {
+        "name": "refusalId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "treasury6",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "usdc",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IERC20"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "windowSpent",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "withdraw",
+    "inputs": [
+      {
+        "name": "root",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount6",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "AncestorDebited",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "ancestor",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "amount6",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "spent6",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "budget6",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Drawn",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "counterparty",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "beneficiary",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "amount6",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "root",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Funded",
+    "inputs": [
+      {
+        "name": "root",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount6",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Refused",
+    "inputs": [
+      {
+        "name": "refusalId",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "node",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "breachedAt",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "counterparty",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "amount6",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "reason",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "enum TreeVault.Reason"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Released",
+    "inputs": [
+      {
+        "name": "refusalId",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "by",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "counterparty",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount6",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Withdrawn",
+    "inputs": [
+      {
+        "name": "root",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount6",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "AlreadyReleased",
+    "inputs": [
+      {
+        "name": "id",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "InsufficientTreasury",
+    "inputs": [
+      {
+        "name": "root",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "have",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "want",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "NotARoot",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "NotOperator",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "caller",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "NotOwner",
+    "inputs": [
+      {
+        "name": "root",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "caller",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "TransferFailed",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "UnknownRefusal",
+    "inputs": [
+      {
+        "name": "id",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "ZeroAmount",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ZeroCounterparty",
+    "inputs": []
+  }
+];
+var MandateRegistryAbi = [
+  {
+    "type": "function",
+    "name": "BPS",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint16",
+        "internalType": "uint16"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "exists",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isLive",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "mandate",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "tuple",
+        "internalType": "struct MandateRegistry.Mandate",
+        "components": [
+          {
+            "name": "parent",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "root",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "owner",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "operator",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "budget6",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "lifetimeCap6",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "windowSeconds",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "trancheCap6",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "concentrationBps",
+            "type": "uint16",
+            "internalType": "uint16"
+          },
+          {
+            "name": "depth",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "maxDepth",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "revoked",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "exists",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "createdAt",
+            "type": "uint64",
+            "internalType": "uint64"
+          }
+        ]
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "open",
+    "inputs": [
+      {
+        "name": "p",
+        "type": "tuple",
+        "internalType": "struct MandateRegistry.Params",
+        "components": [
+          {
+            "name": "operator",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "budget6",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "lifetimeCap6",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "windowSeconds",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "trancheCap6",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "concentrationBps",
+            "type": "uint16",
+            "internalType": "uint16"
+          },
+          {
+            "name": "maxDepth",
+            "type": "uint8",
+            "internalType": "uint8"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "path",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "out",
+        "type": "bytes32[]",
+        "internalType": "bytes32[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "revoke",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "revokedAt",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "spawn",
+    "inputs": [
+      {
+        "name": "parent",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "p",
+        "type": "tuple",
+        "internalType": "struct MandateRegistry.Params",
+        "components": [
+          {
+            "name": "operator",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "budget6",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "lifetimeCap6",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "windowSeconds",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "trancheCap6",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "concentrationBps",
+            "type": "uint16",
+            "internalType": "uint16"
+          },
+          {
+            "name": "maxDepth",
+            "type": "uint8",
+            "internalType": "uint8"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "MandateOpened",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "operator",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "budget6",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "lifetimeCap6",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "windowSeconds",
+        "type": "uint64",
+        "indexed": false,
+        "internalType": "uint64"
+      },
+      {
+        "name": "maxDepth",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "uint8"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "MandateRevoked",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "by",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "MandateSpawned",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "parent",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "operator",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "budget6",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "lifetimeCap6",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "depth",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "uint8"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "ConcentrationOutOfRange",
+    "inputs": [
+      {
+        "name": "bps",
+        "type": "uint16",
+        "internalType": "uint16"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "DepthExceeded",
+    "inputs": [
+      {
+        "name": "attempted",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "max",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "NotNarrowing",
+    "inputs": [
+      {
+        "name": "field",
+        "type": "string",
+        "internalType": "string"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "NotOwner",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NotParentOperator",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ParentRevoked",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "UnknownMandate",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "WindowMustEqualParent",
+    "inputs": [
+      {
+        "name": "child",
+        "type": "uint64",
+        "internalType": "uint64"
+      },
+      {
+        "name": "parent",
+        "type": "uint64",
+        "internalType": "uint64"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "ZeroBudget",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ZeroLifetimeCap",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ZeroOperator",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ZeroTrancheCap",
+    "inputs": []
+  }
+];
+var ConductRecordAbi = [
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault_",
+        "type": "address",
+        "internalType": "contract TreeVault"
+      },
+      {
+        "name": "identity_",
+        "type": "address",
+        "internalType": "contract IIdentityRegistry"
+      },
+      {
+        "name": "reputation_",
+        "type": "address",
+        "internalType": "contract IReputationRegistry"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "RECORD_BASE",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "agentIdOf",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "attest",
+    "inputs": [
+      {
+        "name": "refusalId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "feedbackIndex",
+        "type": "uint64",
+        "internalType": "uint64"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "attestRelease",
+    "inputs": [
+      {
+        "name": "refusalId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "attested",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "bind",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "agentId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "feedbackIndexOf",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint64",
+        "internalType": "uint64"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "identity",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IIdentityRegistry"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "nodeOfAgent",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "reasonTag",
+    "inputs": [
+      {
+        "name": "reason",
+        "type": "uint8",
+        "internalType": "enum TreeVault.Reason"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "recordUri",
+    "inputs": [
+      {
+        "name": "refusalId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "refusalHash",
+    "inputs": [
+      {
+        "name": "refusalId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "refusalHash",
+    "inputs": [
+      {
+        "name": "refusalId",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "r",
+        "type": "tuple",
+        "internalType": "struct TreeVault.Refusal",
+        "components": [
+          {
+            "name": "node",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "breachedAt",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "counterparty",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount6",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "reason",
+            "type": "uint8",
+            "internalType": "enum TreeVault.Reason"
+          },
+          {
+            "name": "at",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "released",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "registry",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract MandateRegistry"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "releaseAttested",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "reputation",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IReputationRegistry"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "vault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract TreeVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "Attested",
+    "inputs": [
+      {
+        "name": "refusalId",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "node",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "agentId",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "recordHash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Bound",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "agentId",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "operator",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ReleaseAttested",
+    "inputs": [
+      {
+        "name": "refusalId",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "agentId",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "recordHash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "AgentAlreadyBound",
+    "inputs": [
+      {
+        "name": "agentId",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "AlreadyAttested",
+    "inputs": [
+      {
+        "name": "refusalId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "IdentityNotHeldByOperator",
+    "inputs": [
+      {
+        "name": "agentId",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "holder",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "operator",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "NodeAlreadyBound",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "agentId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "NodeNotBound",
+    "inputs": [
+      {
+        "name": "node",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "NotAttested",
+    "inputs": [
+      {
+        "name": "refusalId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "NotReleased",
+    "inputs": [
+      {
+        "name": "refusalId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  }
+];
+
+// ../daemon/src/record.ts
+import { hexToString, stringToHex } from "viem";
+var IDENTITY_ABI = [
+  {
+    type: "function",
+    name: "register",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "agentURI", type: "string" }],
+    outputs: [{ name: "agentId", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "getMetadata",
+    stateMutability: "view",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "metadataKey", type: "string" }
+    ],
+    outputs: [{ name: "", type: "bytes" }]
+  },
+  {
+    type: "function",
+    name: "setMetadata",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "metadataKey", type: "string" },
+      { name: "metadataValue", type: "bytes" }
+    ],
+    outputs: []
+  }
+];
+var Recorder = class {
+  deps;
+  /**
+   * How to sign as a node. The gate owns the keys and keeps owning them — this
+   * is a function it lends, not a copy of its map, so there is still exactly
+   * one place in the process where an operator key lives.
+   */
+  walletFor;
+  constructor(deps, walletFor) {
+    this.deps = deps;
+    this.walletFor = walletFor;
+  }
+  get enabled() {
+    return Boolean(this.deps.record);
+  }
+  /**
+   * Give a node an ERC-8004 identity and bind it to the seat.
+   *
+   * Registration is done with the node's operator key, so the token belongs to
+   * the agent. `bind` then checks — on chain, in the contract — that the
+   * identity's holder really is that node's operator. Nobody has to be trusted
+   * for the link to be true.
+   *
+   * Returns the agent id, or null when there is nothing to write into.
+   */
+  async enrol(node2) {
+    const record = this.deps.record;
+    if (!record) return null;
+    const existing = await this.deps.publicClient.readContract({
+      address: record,
+      abi: ConductRecordAbi,
+      functionName: "agentIdOf",
+      args: [node2]
+    });
+    if (existing !== 0n) return existing;
+    const wallet = this.walletFor(node2);
+    const base = this.deps.agentUriBase ?? "https://getcordon.xyz/agent/";
+    const registered = await wallet.writeContract({
+      address: this.deps.identity,
+      abi: IDENTITY_ABI,
+      functionName: "register",
+      args: [`${base}${node2}`],
+      chain: this.deps.chain,
+      account: wallet.account
+    });
+    const receipt = await this.deps.publicClient.waitForTransactionReceipt({ hash: registered });
+    const agentId = await this.lastRegistered(wallet.account.address, receipt.blockNumber);
+    if (agentId === null) return null;
+    const bound = await wallet.writeContract({
+      address: record,
+      abi: ConductRecordAbi,
+      functionName: "bind",
+      args: [node2, agentId],
+      chain: this.deps.chain,
+      account: wallet.account
+    });
+    await this.deps.publicClient.waitForTransactionReceipt({ hash: bound });
+    return agentId;
+  }
+  /**
+   * Write what a node is for onto its own identity.
+   *
+   * Signed with the node's operator key, because the registry lets only an
+   * identity's holder set its metadata. It is a statement by whoever spawned
+   * the node and nothing reads it back as a bound: the contract has never seen
+   * it, and a surface that shows it says so.
+   *
+   * Returns the transaction, or null when the node has no identity to write to.
+   */
+  async describe(node2, purpose) {
+    const record = this.deps.record;
+    if (!record) return null;
+    const agentId = await this.deps.publicClient.readContract({
+      address: record,
+      abi: ConductRecordAbi,
+      functionName: "agentIdOf",
+      args: [node2]
+    });
+    if (agentId === 0n) return null;
+    const wallet = this.walletFor(node2);
+    const hash = await wallet.writeContract({
+      address: this.deps.identity,
+      abi: IDENTITY_ABI,
+      functionName: "setMetadata",
+      args: [agentId, ERC8004.purposeKey, stringToHex(purpose)],
+      chain: this.deps.chain,
+      account: wallet.account
+    });
+    await this.deps.publicClient.waitForTransactionReceipt({ hash });
+    return hash;
+  }
+  /**
+   * What this node's identity already says it is for, if anything.
+   *
+   * Read before writing, so a daemon that republishes on every start sends a
+   * transaction only for the nodes that are actually missing one. `null` means
+   * the node has no identity at all, which is a different thing from an
+   * identity that says nothing.
+   */
+  async statedPurpose(node2) {
+    const record = this.deps.record;
+    if (!record) return null;
+    const agentId = await this.deps.publicClient.readContract({
+      address: record,
+      abi: ConductRecordAbi,
+      functionName: "agentIdOf",
+      args: [node2]
+    });
+    if (agentId === 0n) return null;
+    const raw = await this.deps.publicClient.readContract({
+      address: this.deps.identity,
+      abi: IDENTITY_ABI,
+      functionName: "getMetadata",
+      args: [agentId, ERC8004.purposeKey]
+    });
+    return raw === "0x" ? "" : hexToString(raw).trim();
+  }
+  /**
+   * Publish one refusal.
+   *
+   * `attest` takes an id and nothing else: the amount, the node, the reason and
+   * the bound that stopped it are all read out of the vault inside the call, so
+   * this cannot report something that did not happen even if it wanted to.
+   *
+   * Anyone may call it, so the daemon uses whichever key it has for the node —
+   * the record does not depend on who paid the gas.
+   */
+  async attest(node2, refusalId) {
+    const record = this.deps.record;
+    if (!record || refusalId === 0n) return null;
+    const wallet = this.walletFor(node2);
+    const hash = await wallet.writeContract({
+      address: record,
+      abi: ConductRecordAbi,
+      functionName: "attest",
+      args: [refusalId],
+      chain: this.deps.chain,
+      account: wallet.account
+    });
+    await this.deps.publicClient.waitForTransactionReceipt({ hash });
+    return hash;
+  }
+  /** The most recent identity this address registered, from the registry's own
+   *  event. Reading it back is the only way to learn an id the registry chose.
+   *  `fromBlock` is the block the registration landed in, not a guess. */
+  async lastRegistered(owner, fromBlock) {
+    const logs = await this.deps.publicClient.getLogs({
+      address: this.deps.identity,
+      event: {
+        type: "event",
+        name: "Registered",
+        inputs: [
+          { name: "agentId", type: "uint256", indexed: true },
+          { name: "agentURI", type: "string", indexed: false },
+          { name: "owner", type: "address", indexed: true }
+        ]
+      },
+      args: { owner },
+      fromBlock,
+      toBlock: "latest"
+    });
+    const last = logs[logs.length - 1];
+    return last ? last.args.agentId ?? null : null;
+  }
+};
+
+// ../fixtures/src/serial.ts
+function serialiseByKey() {
+  const tails = /* @__PURE__ */ new Map();
+  return (key, work) => {
+    const id = key.toLowerCase();
+    const previous = tails.get(id) ?? Promise.resolve();
+    const next = previous.then(work, work);
+    tails.set(
+      id,
+      next.then(
+        () => void 0,
+        () => void 0
+      )
+    );
+    return next;
+  };
+}
+
+// ../daemon/src/gate.ts
+var SpawnRefused = class extends Error {
+  broadcast = false;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SpawnRefused";
+  }
+};
+var Gate = class {
+  publicClient;
+  wallets = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  config;
+  chain;
+  /**
+   * One send at a time per operator key.
+   *
+   * An agent's purchases are concurrent by design — that is what a tree of
+   * them is for — and every draw for one node signs with one EOA. Two that
+   * overlap between reading the pending nonce and sending ask for the same
+   * one, and the second is refused for `nonce too low` after its simulation
+   * said it was in bounds. Keyed by node, so two nodes still draw at once.
+   */
+  inTurn = serialiseByKey();
+  /**
+   * The record. It borrows this gate's signer rather than holding a copy of a
+   * key, so there is still exactly one place in the process where an operator
+   * key lives.
+   */
+  recorder;
+  constructor(config2) {
+    this.config = config2;
+    const chain = defineChain({
+      id: config2.chainId,
+      name: `chain-${config2.chainId}`,
+      nativeCurrency: { name: "USDC", symbol: "USDC", decimals: 18 },
+      rpcUrls: { default: { http: [config2.rpcUrl] } }
+    });
+    this.chain = chain;
+    this.publicClient = createPublicClient({
+      chain,
+      transport: http(config2.rpcUrl),
+      pollingInterval: config2.pollMs
+    });
+    this.recorder = new Recorder(
+      { publicClient: this.publicClient, chain, record: config2.record, identity: config2.identity },
+      (node2) => this.walletFor(node2)
+    );
+    for (const { node: node2, keyEnv } of config2.keys) {
+      const secret = process.env[keyEnv];
+      if (!secret) throw new Error(`${keyEnv} is not set`);
+      this.wallets.set(
+        node2.toLowerCase(),
+        createWalletClient({
+          account: privateKeyToAccount(secret),
+          chain,
+          transport: http(config2.rpcUrl),
+          pollingInterval: config2.pollMs
+        })
+      );
+    }
+  }
+  /** The reader the settler shares, so one process holds one connection to
+   *  the chain rather than two that can disagree about its head. */
+  get publicClientForSettlement() {
+    return this.publicClient;
+  }
+  /** The nodes this daemon can act for. It holds no other key. */
+  nodes() {
+    return [...this.wallets.keys()];
+  }
+  /**
+   * Take custody of a key for a node spawned at run time.
+   *
+   * A sub-agent created mid-run needs an operator, and the claim is that the
+   * daemon holds it and the agent holds none. The key stays in this process's
+   * memory: it is never returned to a caller, never logged, and never written
+   * to disk. A key an agent could read is a key it holds.
+   *
+   * The node is bound after the fact, once the registry has assigned it, which
+   * is why this takes the key and `bindOperator` takes the node.
+   */
+  addOperator(secret) {
+    const account = privateKeyToAccount(secret);
+    this.pending.set(account.address.toLowerCase(), secret);
+    return account.address;
+  }
+  /** Attach a previously added key to the node the registry gave it. */
+  bindOperator(node2, operator) {
+    const secret = this.pending.get(operator.toLowerCase());
+    if (!secret) throw new Error(`no key held for operator ${operator}`);
+    this.wallets.set(
+      node2.toLowerCase(),
+      createWalletClient({
+        account: privateKeyToAccount(secret),
+        chain: this.chain,
+        transport: http(this.config.rpcUrl)
+      })
+    );
+    this.pending.delete(operator.toLowerCase());
+  }
+  /**
+   * Lend this node's signer.
+   *
+   * The settler needs to sign a burn intent and an EIP-3009 authorisation as
+   * the operator, and borrowing the signer keeps the key in one place rather
+   * than handing a copy of it out — the same arrangement the recorder has.
+   */
+  signerFor(node2) {
+    return this.walletFor(node2);
+  }
+  walletFor(node2) {
+    const wallet = this.wallets.get(node2.toLowerCase());
+    if (!wallet) throw new Error(`this daemon holds no key for ${node2}`);
+    return wallet;
+  }
+  /**
+   * What a draw would do, without doing it. Free, and the honest thing to show
+   * an operator before they ask for money.
+   */
+  async evaluate(node2, counterparty, amount) {
+    const [reason, breachedAt] = await this.publicClient.readContract({
+      address: this.config.vault,
+      abi: TreeVaultAbi,
+      functionName: "evaluate",
+      args: [node2, counterparty, amount]
+    });
+    return {
+      released: reason === 0,
+      reason: REASONS[reason] ?? UNRECOGNISED,
+      breachedAt: reason === 0 ? void 0 : breachedAt
+    };
+  }
+  /** What this node may still draw in total, and which node is the reason. */
+  async headroom(node2) {
+    const [available, boundBy] = await this.publicClient.readContract({
+      address: this.config.vault,
+      abi: TreeVaultAbi,
+      functionName: "headroom",
+      args: [node2]
+    });
+    return { available, boundBy };
+  }
+  async refusalCount() {
+    return await this.publicClient.readContract({
+      address: this.config.vault,
+      abi: TreeVaultAbi,
+      functionName: "refusalCount"
+    });
+  }
+  /** One refusal as the vault holds it, including whether the owner released it. */
+  async refusal(id) {
+    return await this.publicClient.readContract({
+      address: this.config.vault,
+      abi: TreeVaultAbi,
+      functionName: "refusal",
+      args: [id]
+    });
+  }
+  /** False when this node or any ancestor has been revoked. */
+  async isLive(node2) {
+    return await this.publicClient.readContract({
+      address: this.config.registry,
+      abi: MandateRegistryAbi,
+      functionName: "isLive",
+      args: [node2]
+    });
+  }
+  async mandate(node2) {
+    return this.publicClient.readContract({
+      address: this.config.registry,
+      abi: MandateRegistryAbi,
+      functionName: "mandate",
+      args: [node2]
+    });
+  }
+  /**
+   * Register a child mandate under a node this daemon holds the key for.
+   *
+   * No owner signature: spawns happen in seconds while the owner sleeps. The
+   * contract refuses a child wider than its parent no matter who asks, so the
+   * safety is structural rather than procedural. The narrowing is not checked
+   * here on purpose — a second copy of that rule is a second place for it to
+   * be wrong.
+   */
+  async spawn(parent, params) {
+    return this.inTurn(parent, () => this.spawnInTurn(parent, params));
+  }
+  async spawnInTurn(parent, params) {
+    const wallet = this.walletFor(parent);
+    const inherited = await this.mandate(parent);
+    let request;
+    try {
+      ({ request } = await this.publicClient.simulateContract({
+        address: this.config.registry,
+        abi: MandateRegistryAbi,
+        functionName: "spawn",
+        args: [
+          parent,
+          {
+            operator: params.operator,
+            budget6: params.budget6,
+            lifetimeCap6: params.lifetimeCap6 ?? inherited.lifetimeCap6,
+            windowSeconds: inherited.windowSeconds,
+            trancheCap6: params.trancheCap6,
+            concentrationBps: params.concentrationBps,
+            maxDepth: inherited.maxDepth
+          }
+        ],
+        account: wallet.account
+      }));
+    } catch (error) {
+      throw new SpawnRefused(error.message, { cause: error });
+    }
+    const txHash = await wallet.writeContract(request);
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash: txHash });
+    for (const log of receipt.logs) {
+      if (log.address.toLowerCase() !== this.config.registry.toLowerCase()) continue;
+      try {
+        const event = decodeEventLog({ abi: MandateRegistryAbi, data: log.data, topics: log.topics });
+        if (event.eventName === "MandateSpawned") {
+          const node2 = event.args.node;
+          if (this.pending.has(params.operator.toLowerCase())) {
+            this.bindOperator(node2, params.operator);
+            const enrolled = await this.enrol(node2) !== null;
+            if (params.purpose) {
+              return {
+                node: node2,
+                txHash,
+                enrolled,
+                purposePublished: enrolled ? await this.describe(node2, params.purpose) : false
+              };
+            }
+            return { node: node2, txHash, enrolled };
+          }
+          return { node: node2, txHash, ...params.purpose ? { purposePublished: false } : {} };
+        }
+      } catch {
+        continue;
+      }
+    }
+    throw new Error(`spawn ${txHash} emitted no MandateSpawned`);
+  }
+  /**
+   * Ask for a tranche, sized to the purchase, declaring who it is for.
+   *
+   * A refusal is a returned value rather than a revert, so this resolves in
+   * both cases and the caller reads `released`. It never throws to mean "no".
+   */
+  async draw(node2, counterparty, amount) {
+    return this.inTurn(node2, () => this.drawInTurn(node2, counterparty, amount));
+  }
+  async drawInTurn(node2, counterparty, amount) {
+    const wallet = this.walletFor(node2);
+    const { request, result } = await this.publicClient.simulateContract({
+      address: this.config.vault,
+      abi: TreeVaultAbi,
+      functionName: "draw",
+      args: [node2, counterparty, amount],
+      account: wallet.account
+    });
+    const [wouldRelease] = result;
+    const txHash = await wallet.writeContract(request);
+    const outcome = { ...await this.outcomeFrom(txHash), txHash };
+    if (!wouldRelease) {
+      await this.publish(node2, outcome);
+    }
+    return outcome;
+  }
+  /**
+   * Write a node's stated purpose onto its identity. Best-effort, like `enrol`:
+   * a purpose that fails to publish costs a description and no control.
+   */
+  /**
+   * Publish the purposes this key file remembers and the chain has not.
+   *
+   * A child spawned by an operator with no gas is enrolled by nobody, so its
+   * purpose is written to the key file and never to its identity — and
+   * `describe` only ever ran at spawn, so funding that operator afterwards
+   * healed nothing. The name existed in a file on one laptop and the agent
+   * stayed anonymous everywhere else.
+   *
+   * Called at start, after enrolment, so a restart is the whole recovery
+   * rather than half of it. It reads before it writes: a node whose identity
+   * already carries its purpose costs one call and no transaction.
+   */
+  async describeRemembered(remembered) {
+    if (!this.recorder.enabled || remembered.size === 0) return 0;
+    let published = 0;
+    for (const node2 of this.nodes()) {
+      const purpose = remembered.get(node2.toLowerCase());
+      if (!purpose) continue;
+      try {
+        const already = await this.recorder.statedPurpose(node2);
+        if (already === null || already === purpose) continue;
+        if (await this.describe(node2, purpose)) published += 1;
+      } catch (error) {
+        console.error(`${node2}'s purpose stays unpublished: ${error.message}`);
+      }
+    }
+    return published;
+  }
+  async describe(node2, purpose) {
+    if (!this.recorder.enabled) return false;
+    try {
+      return await this.recorder.describe(node2, purpose) !== null;
+    } catch (error) {
+      console.error(`${node2}'s purpose stays unpublished: ${error.message}`);
+      return false;
+    }
+  }
+  /**
+   * Give a node an ERC-8004 identity, if there is a seat to bind it to.
+   *
+   * Idempotent and best-effort. A node that fails to enrol still draws and is
+   * still refused; what it loses is the ability to have those refusals
+   * published, which is a loss of publicity and never a loss of control.
+   */
+  async enrol(node2) {
+    if (!this.recorder.enabled) return null;
+    try {
+      return await this.recorder.enrol(node2);
+    } catch (error) {
+      console.error(`${node2} has no identity, so its refusals stay unpublished: ${error.message}`);
+      return null;
+    }
+  }
+  /**
+   * Put the refusal on the public record.
+   *
+   * Deliberately after the fact and deliberately unable to fail loudly: the
+   * bound has already been enforced and the refusal is already on chain by the
+   * time this runs, so a seat that is unreachable, unfunded or absent costs the
+   * record its completeness and costs the enforcement nothing. There is no
+   * filter — every refusal is published, because a daemon that chose which
+   * ones to report would be writing an opinion.
+   */
+  async publish(node2, outcome) {
+    if (outcome.released || !outcome.refusalId || !this.recorder.enabled) return;
+    try {
+      await this.recorder.attest(node2, outcome.refusalId);
+    } catch (error) {
+      console.error(
+        `refusal ${outcome.refusalId} is on chain but was not published: ${error.message}`
+      );
+    }
+  }
+  /** Read what actually happened out of the log, not out of the simulation. */
+  async outcomeFrom(txHash) {
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash: txHash });
+    for (const log of receipt.logs) {
+      if (log.address.toLowerCase() !== this.config.vault.toLowerCase()) continue;
+      let event;
+      try {
+        event = decodeEventLog({ abi: TreeVaultAbi, data: log.data, topics: log.topics });
+      } catch {
+        continue;
+      }
+      if (event.eventName === "Drawn") {
+        const args = event.args;
+        return { released: true, reason: "none", beneficiary: args.beneficiary, txHash };
+      }
+      if (event.eventName === "Refused") {
+        const args = event.args;
+        return {
+          released: false,
+          reason: REASONS[args.reason] ?? UNRECOGNISED,
+          breachedAt: args.breachedAt,
+          refusalId: args.refusalId,
+          txHash
+        };
+      }
+    }
+    throw new Error(`draw ${txHash} emitted neither Drawn nor Refused`);
+  }
+};
+
+// ../daemon/src/settle.ts
+import { parseAbi as parseAbi2 } from "viem";
+
+// ../daemon/src/gateway.ts
+import { pad, toHex, parseAbi } from "viem";
+var GATEWAY_EIP712_DOMAIN = { name: "GatewayWallet", version: "1" };
+var BURN_INTENT_TYPES = {
+  TransferSpec: [
+    { name: "version", type: "uint32" },
+    { name: "sourceDomain", type: "uint32" },
+    { name: "destinationDomain", type: "uint32" },
+    { name: "sourceContract", type: "bytes32" },
+    { name: "destinationContract", type: "bytes32" },
+    { name: "sourceToken", type: "bytes32" },
+    { name: "destinationToken", type: "bytes32" },
+    { name: "sourceDepositor", type: "bytes32" },
+    { name: "destinationRecipient", type: "bytes32" },
+    { name: "sourceSigner", type: "bytes32" },
+    { name: "destinationCaller", type: "bytes32" },
+    { name: "value", type: "uint256" },
+    { name: "salt", type: "bytes32" },
+    { name: "hookData", type: "bytes" }
+  ],
+  BurnIntent: [
+    { name: "maxBlockHeight", type: "uint256" },
+    { name: "maxFee", type: "uint256" },
+    { name: "spec", type: "TransferSpec" }
+  ]
+};
+var GATEWAY_MINTER_ABI = parseAbi([
+  "function gatewayMint(bytes attestationPayload, bytes signature)"
+]);
+var b32 = (address2) => pad(address2.toLowerCase(), { size: 32 });
+var ZERO = "0x0000000000000000000000000000000000000000";
+function buildBurnIntent(terms) {
+  return {
+    maxBlockHeight: terms.maxBlockHeight,
+    maxFee: terms.maxFee,
+    spec: {
+      version: 1,
+      sourceDomain: terms.domain,
+      destinationDomain: terms.domain,
+      sourceContract: b32(terms.wallet),
+      destinationContract: b32(terms.minter),
+      sourceToken: b32(terms.token),
+      destinationToken: b32(terms.token),
+      sourceDepositor: b32(terms.depositor),
+      /* The recipient is the depositor, and that is the whole shape of this
+         step: the tranche is brought back out of Gateway into the operator's
+         own balance so an x402 `exact` payment — an EIP-3009 authorisation
+         over that balance — can be signed against it. Naming the seller here
+         would pay them Gateway-side and leave the seller's own 402 unanswered. */
+      destinationRecipient: b32(terms.depositor),
+      sourceSigner: b32(terms.depositor),
+      /* Anyone may submit the mint. We do, immediately. */
+      destinationCaller: b32(ZERO),
+      value: terms.value,
+      salt: terms.salt ?? toHex(crypto.getRandomValues(new Uint8Array(32))),
+      hookData: "0x"
+    }
+  };
+}
+var GatewayError = class extends Error {
+};
+var GatewayApi = class {
+  base;
+  fetchImpl;
+  constructor(options = {}) {
+    this.base = options.base ?? GATEWAY.api;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  /** The window a burn intent must expire inside, read per call because it
+   *  moves with the chain: an intent built against a stale height is refused
+   *  with `maxBlockHeight is too low`. */
+  async expirationHeight(domain) {
+    const res = await this.fetchImpl(`${this.base}/v1/info`);
+    if (!res.ok) throw new GatewayError(`gateway /v1/info answered ${res.status}`);
+    const body = await res.json();
+    const found = body.domains.find((d) => d.domain === domain);
+    if (!found) throw new GatewayError(`gateway does not serve domain ${domain}`);
+    return BigInt(found.burnIntentExpirationHeight);
+  }
+  async balance(domain, depositor) {
+    const res = await this.fetchImpl(`${this.base}/v1/balances`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ token: "USDC", sources: [{ domain, depositor }] })
+    });
+    if (!res.ok) throw new GatewayError(`gateway /v1/balances answered ${res.status}`);
+    const body = await res.json();
+    return body.balances?.[0]?.balance ?? "0";
+  }
+  async transfer(intent, signature) {
+    const body = JSON.stringify(
+      [{ burnIntent: intent, signature }],
+      (_k, v) => typeof v === "bigint" ? v.toString() : v
+    );
+    const res = await this.fetchImpl(`${this.base}/v1/transfer`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body
+    });
+    const text2 = await res.text();
+    if (!res.ok) {
+      let message = text2;
+      try {
+        message = JSON.parse(text2).message ?? text2;
+      } catch {
+      }
+      throw new GatewayError(`Circle refused the burn intent: ${message}`);
+    }
+    const parsed = JSON.parse(text2);
+    return {
+      attestation: parsed.attestation,
+      signature: parsed.signature,
+      transferId: parsed.transferId,
+      feeTotal: parsed.fees?.total ?? "unstated"
+    };
+  }
+};
+async function mint(clients, minter, accepted) {
+  const { request } = await clients.publicClient.simulateContract({
+    address: minter,
+    abi: GATEWAY_MINTER_ABI,
+    functionName: "gatewayMint",
+    args: [accepted.attestation, accepted.signature],
+    account: clients.wallet.account
+  });
+  const hash = await clients.wallet.writeContract(request);
+  await clients.publicClient.waitForTransactionReceipt({ hash });
+  return hash;
+}
+
+// ../daemon/src/settle.ts
+var TRANSFER_WITH_AUTHORIZATION_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+var SettlementError = class extends Error {
+};
+var ERC20 = parseAbi2(["function balanceOf(address account) view returns (uint256)"]);
+var CircleSettler = class {
+  options;
+  api;
+  constructor(options) {
+    this.options = options;
+    this.api = options.api ?? new GatewayApi();
+  }
+  async settle(node2, payment) {
+    const wallet = this.options.walletFor(node2);
+    const operator = wallet.account.address;
+    const token = tokenDomain(payment, this.options.chainId);
+    if (payment.value <= GATEWAY.baseFee6) {
+      throw new SettlementError(
+        `this purchase is ${payment.value} base units and Circle's Gateway fee on Arc is ${GATEWAY.baseFee6} \u2014 a tranche at or below the fee cannot pay for its own release. The alternative rail, GatewayWallet.withdraw, has a ${GATEWAY.withdrawalDelaySeconds}-second delay. Neither settles a payment this small, and that is a fact about the rail.`
+      );
+    }
+    const released = payment.value - GATEWAY.baseFee6;
+    const debited = released + GATEWAY.baseFee6;
+    await this.awaitBalance(operator, debited);
+    const intent = buildBurnIntent({
+      depositor: operator,
+      wallet: GATEWAY.wallet,
+      minter: GATEWAY.minter,
+      token: payment.asset,
+      domain: GATEWAY.domain,
+      value: released,
+      maxFee: GATEWAY.baseFee6,
+      maxBlockHeight: await this.api.expirationHeight(GATEWAY.domain) + (this.options.heightMargin ?? 5000n)
+    });
+    const signature = await wallet.signTypedData({
+      account: wallet.account,
+      domain: GATEWAY_EIP712_DOMAIN,
+      types: BURN_INTENT_TYPES,
+      primaryType: "BurnIntent",
+      message: intent
+    });
+    const accepted = await this.api.transfer(intent, signature);
+    const submit = this.options.mint ?? ((w, minter, a) => mint({ publicClient: this.options.publicClient, wallet: w }, minter, a));
+    const txHash = await submit(wallet, GATEWAY.minter, accepted);
+    await this.assertCanPay(payment, operator);
+    const proof = await this.authorise(wallet, operator, payment, token);
+    return { proof, txHash };
+  }
+  /**
+   * Wait until Circle's own view of the balance covers what the intent will
+   * debit — its value and the fee together, which is the tranche.
+   *
+   * `needed` is passed in rather than derived here. Deriving it twice is how
+   * this came to wait for a balance a draw does not produce.
+   */
+  async awaitBalance(operator, needed) {
+    const deadline = (this.options.now?.() ?? Date.now()) + (this.options.balanceWaitMs ?? 6e4);
+    let seen = "0";
+    for (; ; ) {
+      seen = await this.api.balance(GATEWAY.domain, operator);
+      if (baseUnits(seen) >= needed) return;
+      if ((this.options.now?.() ?? Date.now()) >= deadline) {
+        throw new SettlementError(
+          `Circle still reports ${seen} for ${operator} after waiting, and this intent debits ${needed} base units \u2014 its value and the fee charged on top of it. The draw has already happened, so the window is debited and the money is in the Gateway balance.`
+        );
+      }
+      await new Promise((done) => setTimeout(done, this.options.balancePollMs ?? 3e3));
+    }
+  }
+  /**
+   * Does the operator hold what it is about to authorise?
+   *
+   * An EIP-3009 authorisation is checked against the balance at the moment the
+   * seller submits it, not the moment it is signed, so this cannot be a
+   * guarantee. It is the difference between a failure the daemon can name and
+   * one that surfaces as a seller's revert against a signature that verified.
+   */
+  async assertCanPay(payment, operator) {
+    const read = this.options.balanceOf ?? ((token, holder) => this.options.publicClient.readContract({
+      address: token,
+      abi: ERC20,
+      functionName: "balanceOf",
+      args: [holder]
+    }));
+    const held = await read(payment.asset, operator);
+    if (held >= payment.value) return;
+    throw new SettlementError(
+      `${operator} holds ${held} base units and this purchase authorises ${payment.value}. The burn returned the price less Circle's ${GATEWAY.baseFee6} fee, so an operator needs that difference in its own float \u2014 the same place its gas comes from, and outside the mandate either way. The draw has already happened, so the window is debited.`
+    );
+  }
+  /** The x402 `exact` payload: an EIP-3009 authorisation the seller submits. */
+  async authorise(wallet, operator, payment, token) {
+    const now = Math.floor((this.options.now?.() ?? Date.now()) / 1e3);
+    const authorization = {
+      from: operator,
+      to: payment.to,
+      value: payment.value,
+      validAfter: 0n,
+      validBefore: BigInt(now + (payment.maxTimeoutSeconds ?? 300)),
+      nonce: this.options.nonce?.() ?? randomNonce()
+    };
+    const signature = await wallet.signTypedData({
+      account: wallet.account,
+      domain: token,
+      types: TRANSFER_WITH_AUTHORIZATION_TYPES,
+      primaryType: "TransferWithAuthorization",
+      message: authorization
+    });
+    return Buffer.from(
+      JSON.stringify({
+        x402Version: 2,
+        scheme: "exact",
+        network: payment.network,
+        asset: payment.asset,
+        payload: {
+          signature,
+          authorization: {
+            ...authorization,
+            value: authorization.value.toString(),
+            validAfter: authorization.validAfter.toString(),
+            validBefore: authorization.validBefore.toString()
+          }
+        }
+      }),
+      "utf8"
+    ).toString("base64");
+  }
+};
+function tokenDomain(payment, chainId) {
+  const extra = payment.extra ?? {};
+  const name = typeof extra.name === "string" ? extra.name : void 0;
+  const version = typeof extra.version === "string" ? extra.version : void 0;
+  if (!name || !version) {
+    throw new SettlementError(
+      "the seller's offer carries no EIP-712 name and version in `extra`, and a payer that guesses them signs an authorisation the token will not verify"
+    );
+  }
+  return { name, version, chainId, verifyingContract: payment.asset };
+}
+function baseUnits(decimal) {
+  const [whole = "0", fraction = ""] = decimal.trim().split(".");
+  const padded = (fraction + "000000").slice(0, 6);
+  const sign = whole.startsWith("-") ? -1n : 1n;
+  return sign * (BigInt(whole.replace("-", "") || "0") * 1000000n + BigInt(padded || "0"));
+}
+function randomNonce() {
+  const bytes = crypto.getRandomValues(new Uint8Array(32));
+  return `0x${Buffer.from(bytes).toString("hex")}`;
+}
+
+// ../daemon/src/keyfile.ts
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+function labelForOperator(operator) {
+  return `CHILD_${operator.slice(2, 10).toUpperCase()}`;
+}
+function cleanPurpose(raw) {
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw !== "string") throw new Error("purpose must be a string");
+  const purpose = raw.trim();
+  if (purpose === "") return void 0;
+  if (/[\u0000-\u001f\u007f]/.test(purpose)) throw new Error("purpose must be a single line");
+  if (purpose.length > ERC8004.purposeMaxLength) {
+    throw new Error(`purpose is ${purpose.length} characters; the most is ${ERC8004.purposeMaxLength}`);
+  }
+  return purpose;
+}
+function keyFileAt(path) {
+  return {
+    path,
+    remember(secret, operator, purpose) {
+      const label = labelForOperator(operator);
+      mkdirSync(dirname(path), { recursive: true, mode: 448 });
+      const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
+      if (new RegExp(`^CORDON_KEY_${label}=`, "m").test(existing)) {
+        throw new Error(`${path} already holds a key labelled ${label}`);
+      }
+      const lead = existing !== "" && !existing.endsWith("\n") ? "\n" : "";
+      appendFileSync(
+        path,
+        `${lead}
+# Spawned ${(/* @__PURE__ */ new Date()).toISOString()} for operator ${operator}.
+` + (purpose ? `# Purpose: ${cleanPurpose(purpose)}
+` : "") + `# Private key: never commit this file, never paste its contents.
+CORDON_KEY_${label}=${secret}
+CORDON_NODE_${label}=
+`,
+        { mode: 384 }
+      );
+      chmodSync(path, 384);
+      return label;
+    },
+    forget(label) {
+      const current = existsSync(path) ? readFileSync(path, "utf8") : "";
+      const block = new RegExp(
+        `
+*^# Spawned [^
+]*for operator [^
+]*
+(?:^#[^
+]*
+)*^CORDON_KEY_${label}=[^
+]*
+^CORDON_NODE_${label}=$
+?`,
+        "m"
+      );
+      if (!block.test(current)) return;
+      const staging = `${path}.tmp-${process.pid}`;
+      writeFileSync(staging, current.replace(block, "\n"), { mode: 384 });
+      chmodSync(staging, 384);
+      renameSync(staging, path);
+    },
+    purposes() {
+      const found = /* @__PURE__ */ new Map();
+      if (!existsSync(path)) return found;
+      const lines = readFileSync(path, "utf8").split("\n");
+      let said;
+      for (const line of lines) {
+        const purpose = /^# Purpose: (.+)$/.exec(line);
+        if (purpose) {
+          said = purpose[1].trim();
+          continue;
+        }
+        const node2 = /^CORDON_NODE_[A-Za-z0-9_]+=(0x[0-9a-fA-F]{64})$/.exec(line);
+        if (node2) {
+          if (said) found.set(node2[1].toLowerCase(), said);
+          said = void 0;
+          continue;
+        }
+        if (!/^CORDON_KEY_/.test(line) && line.trim() !== "" && !line.startsWith("#")) said = void 0;
+      }
+      return found;
+    },
+    bind(label, node2) {
+      const current = readFileSync(path, "utf8");
+      const empty = new RegExp(`^CORDON_NODE_${label}=$`, "m");
+      if (!empty.test(current)) {
+        throw new Error(`${path} has no empty CORDON_NODE_${label} to fill`);
+      }
+      const next = current.replace(empty, `CORDON_NODE_${label}=${node2}`);
+      const staging = `${path}.tmp-${process.pid}`;
+      writeFileSync(staging, next, { mode: 384 });
+      chmodSync(staging, 384);
+      renameSync(staging, path);
+    }
+  };
+}
+
+// ../daemon/src/released.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var ChainReleases = class {
+  options;
+  spent;
+  constructor(options) {
+    this.options = options;
+    this.spent = existsSync2(options.file) ? new Set(JSON.parse(readFileSync2(options.file, "utf8")).map(String)) : /* @__PURE__ */ new Set();
+  }
+  async claim(node2, payTo, amount6) {
+    const count = await this.options.count();
+    const scan = BigInt(this.options.scan ?? 256);
+    const floor = count > scan ? count - scan : 0n;
+    for (let id = count; id > floor; id--) {
+      const key = id.toString();
+      if (this.spent.has(key)) continue;
+      const row = await this.options.read(id);
+      if (!row.released) continue;
+      if (row.node.toLowerCase() !== node2.toLowerCase()) continue;
+      if (row.counterparty.toLowerCase() !== payTo.toLowerCase()) continue;
+      if (row.amount6 !== amount6) continue;
+      if (!await this.options.live(node2)) return null;
+      this.spent.add(key);
+      this.save();
+      return id;
+    }
+    return null;
+  }
+  unclaim(refusalId) {
+    if (this.spent.delete(refusalId.toString())) this.save();
+  }
+  save() {
+    mkdirSync2(dirname2(this.options.file), { recursive: true });
+    writeFileSync2(this.options.file, JSON.stringify([...this.spent], null, 2) + "\n");
+  }
+};
+
+// src/main.ts
+import { dirname as dirname3, join as join2 } from "node:path";
+
+// src/server.ts
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { generatePrivateKey } from "viem/accounts";
+
+// ../daemon/src/challenge.ts
+var ChallengeError = class extends Error {
+};
+var ADDRESS = /^0x[0-9a-fA-F]{40}$/;
+var CAIP2 = /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}$/;
+function parseChallenge(status, body) {
+  if (status !== 402) return null;
+  if (typeof body !== "object" || body === null) {
+    throw new ChallengeError("402 with no JSON body");
+  }
+  const raw = body;
+  const version = raw.x402Version;
+  if (typeof version !== "number") {
+    throw new ChallengeError("402 body has no x402Version");
+  }
+  const accepts = raw.accepts;
+  if (!Array.isArray(accepts) || accepts.length === 0) {
+    throw new ChallengeError("402 body offers no way to pay");
+  }
+  return { x402Version: version, offers: accepts.map(parseOffer) };
+}
+function parseOffer(input, index) {
+  if (typeof input !== "object" || input === null) {
+    throw new ChallengeError(`accepts[${index}] is not an object`);
+  }
+  const o = input;
+  const scheme = str(o.scheme, `accepts[${index}].scheme`);
+  const network = str(o.network, `accepts[${index}].network`);
+  if (!CAIP2.test(network)) {
+    throw new ChallengeError(`accepts[${index}].network is not a CAIP-2 id: ${network}`);
+  }
+  const payTo = str(o.payTo, `accepts[${index}].payTo`);
+  const asset = str(o.asset, `accepts[${index}].asset`);
+  const amountRaw = o.amount;
+  if (typeof amountRaw !== "string" || !/^\d+$/.test(amountRaw)) {
+    throw new ChallengeError(`accepts[${index}].amount is not a base-unit string`);
+  }
+  const amount = BigInt(amountRaw);
+  if (amount <= 0n) {
+    throw new ChallengeError(`accepts[${index}].amount is not positive`);
+  }
+  return {
+    scheme,
+    network,
+    asset,
+    payTo,
+    amount,
+    maxTimeoutSeconds: typeof o.maxTimeoutSeconds === "number" ? o.maxTimeoutSeconds : void 0,
+    extra: typeof o.extra === "object" && o.extra !== null ? o.extra : void 0
+  };
+}
+function str(v, where) {
+  if (typeof v !== "string" || v.length === 0) {
+    throw new ChallengeError(`${where} is missing`);
+  }
+  return v;
+}
+function selectOffer(challenge, ok) {
+  const scheme = ok.scheme ?? "exact";
+  const networks = new Set(ok.networks);
+  const assets = new Set(ok.assets.map((a) => a.toLowerCase()));
+  const match = challenge.offers.find(
+    (o) => o.scheme === scheme && networks.has(o.network) && assets.has(o.asset.toLowerCase())
+  );
+  if (!match) {
+    throw new ChallengeError(
+      `no offer this daemon can settle: seller accepts ${challenge.offers.map((o) => `${o.scheme}/${o.network}`).join(", ")}`
+    );
+  }
+  if (match.network.startsWith("eip155:") && !ADDRESS.test(match.payTo)) {
+    throw new ChallengeError(`payTo is not an address: ${match.payTo}`);
+  }
+  return match;
+}
+
+// ../daemon/src/egress.ts
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+var EgressError = class extends Error {
+};
+function isPrivateV4(address2) {
+  const [a = 0, b = 0] = address2.split(".").map(Number);
+  if (a === 10) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 127) return true;
+  if (a === 0) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a >= 224) return true;
+  return false;
+}
+function isPrivateV6(address2) {
+  const plain = address2.toLowerCase().split("%")[0];
+  if (plain === "::1" || plain === "::") return true;
+  if (plain.startsWith("fc") || plain.startsWith("fd")) return true;
+  if (plain.startsWith("fe8") || plain.startsWith("fe9")) return true;
+  if (plain.startsWith("fea") || plain.startsWith("feb")) return true;
+  if (plain.startsWith("ff")) return true;
+  const mapped = plain.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+  if (mapped) return isPrivateV4(mapped[1]);
+  return false;
+}
+function isPrivateAddress(address2) {
+  const family = isIP(address2);
+  if (family === 4) return isPrivateV4(address2);
+  if (family === 6) return isPrivateV6(address2);
+  return true;
+}
+var resolveAll = async (hostname) => {
+  const answers = await lookup(hostname, { all: true, verbatim: true });
+  return answers.map((answer) => answer.address);
+};
+async function assertPublicUrl(raw, options = {}) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new EgressError(`${raw} is not a URL`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new EgressError(
+      `${url.protocol} is not a scheme this daemon fetches. A purchase is an HTTP request answered with 402, and nothing else here needs a network.`
+    );
+  }
+  const host = url.hostname.replace(/^\[|\]$/g, "");
+  const addresses = isIP(host) ? [host] : await (options.resolve ?? resolveAll)(host).catch(() => []);
+  if (addresses.length === 0) {
+    throw new EgressError(`${url.hostname} does not resolve, so there is nothing to ask`);
+  }
+  for (const address2 of addresses) {
+    if (isPrivateAddress(address2)) {
+      throw new EgressError(
+        `${url.hostname} resolves to ${address2}, which is on this machine or its private network. The daemon runs beside the meter and the attest endpoint, both of which listen on loopback because they trust it, and a URL is the only thing an agent can hand this tool.`
+      );
+    }
+  }
+  return url;
+}
+
+// ../daemon/src/fetch.ts
+async function cordonFetch(request, deps) {
+  const { gate: gate2, settler, acceptable, transport } = deps;
+  const method = request.method ?? "GET";
+  const headers = { ...request.headers };
+  const first = await transport(request.url, { method, headers, body: request.body });
+  const challenge = parseChallenge(first.status, first.body);
+  if (!challenge) {
+    return { paid: false, free: true, status: first.status, headers: first.headers, body: first.body };
+  }
+  const offer = selectOffer(challenge, acceptable);
+  const releasedFrom = deps.released ? await deps.released.claim(request.node, offer.payTo, offer.amount) : null;
+  const draw = releasedFrom !== null ? { released: true, reason: "none", refusalId: releasedFrom } : await gate2.draw(request.node, offer.payTo, offer.amount);
+  if (!draw.released) {
+    return { paid: false, free: false, refusal: draw, offer };
+  }
+  let settlement;
+  try {
+    settlement = await settler.settle(request.node, {
+      to: offer.payTo,
+      value: offer.amount,
+      asset: offer.asset,
+      network: offer.network,
+      /* The seller's own terms for the signature it will submit: the token's
+         EIP-712 name and version, and how long the authorisation must stay
+         valid. Both come from the challenge, neither from us. */
+      extra: offer.extra,
+      maxTimeoutSeconds: offer.maxTimeoutSeconds
+    });
+  } catch (error) {
+    if (releasedFrom !== null) deps.released.unclaim(releasedFrom);
+    throw error;
+  }
+  const second = await transport(request.url, {
+    method,
+    headers: { ...headers, "PAYMENT-SIGNATURE": settlement.proof },
+    body: request.body
+  });
+  return {
+    paid: true,
+    status: second.status,
+    headers: second.headers,
+    body: second.body,
+    draw,
+    offer,
+    settlementTx: settlement.txHash,
+    ...releasedFrom !== null ? { releasedRefusal: releasedFrom } : {}
+  };
+}
+var MAX_REDIRECTS = 3;
+var httpTransport = (url, init) => httpTransportWith(assertPublicUrl)(url, init);
+var httpTransportWith = (assert) => async (url, init) => {
+  let target = await assert(url);
+  const origin = target.origin;
+  const carriesPayment = Object.keys(init.headers).some(
+    (name) => name.toLowerCase() === "payment-signature" || name.toLowerCase() === "x-payment"
+  );
+  for (let hop = 0; ; hop++) {
+    const response = await fetch(target, {
+      method: init.method,
+      headers: init.headers,
+      body: init.body,
+      /* Followed below instead, so each hop is checked. */
+      redirect: "manual",
+      signal: AbortSignal.timeout(3e4)
+    });
+    const location = response.headers.get("location");
+    if (response.status < 300 || response.status >= 400 || !location) {
+      const text2 = await response.text();
+      let body = text2;
+      try {
+        body = JSON.parse(text2);
+      } catch {
+      }
+      return {
+        status: response.status,
+        headers: Object.fromEntries(response.headers.entries()),
+        body
+      };
+    }
+    if (hop >= MAX_REDIRECTS) {
+      throw new EgressError(`${url} redirected more than ${MAX_REDIRECTS} times`);
+    }
+    const next = await assert(new URL(location, target).toString());
+    if (carriesPayment && next.origin !== origin) {
+      throw new EgressError(
+        `${target.origin} redirected a paid request to ${next.origin}. The authorisation in it is signed and bearer, and it was priced against the first of those two.`
+      );
+    }
+    target = next;
+  }
+};
+
+// src/render.ts
+var usdc = (base6) => {
+  const whole = base6 / 1000000n;
+  const frac = (base6 % 1000000n).toString().padStart(6, "0").replace(/0+$/, "") || "0";
+  return `$${whole}.${frac}`;
+};
+var short = (id) => `${id.slice(0, 10)}\u2026${id.slice(-6)}`;
+var WHY = REASON_MEANING;
+function renderRefusal(outcome, offer, explorer) {
+  const lines = [
+    `REFUSED \u2014 ${WHY[outcome.reason] ?? outcome.reason}.`,
+    "",
+    `The purchase        ${usdc(offer.amount)} to ${offer.payTo}`,
+    `The bound that hit  ${outcome.reason}`
+  ];
+  if (outcome.breachedAt) {
+    lines.push(`Enforced at         ${short(outcome.breachedAt)}`);
+  }
+  if (outcome.refusalId !== void 0) {
+    lines.push(`On the record as    refusal #${outcome.refusalId}`);
+  }
+  if (outcome.txHash) {
+    lines.push(`Transaction         ${outcome.txHash}`);
+    if (explorer) lines.push(`                    ${explorer}/tx/${outcome.txHash}`);
+  }
+  lines.push(
+    "",
+    "Nothing was paid and no budget was consumed. This is a decision the",
+    "contract made; it cannot be retried past the bound that produced it."
+  );
+  return lines.join("\n");
+}
+function renderPaid(outcome, offer, body) {
+  const text2 = typeof body === "string" ? body : JSON.stringify(body, null, 2);
+  return [
+    `Paid ${usdc(offer.amount)} to ${offer.payTo} on ${offer.network}.`,
+    !outcome.txHash && outcome.refusalId !== void 0 ? `Paid out of the owner's release of refusal ${outcome.refusalId}. No draw was sent; the bound did not move.` : "",
+    outcome.beneficiary ? `Tranche credited to ${outcome.beneficiary}.` : "",
+    outcome.txHash ? `Draw ${outcome.txHash}` : "",
+    "",
+    text2
+  ].filter(Boolean).join("\n");
+}
+
+// src/server.ts
+var text = (s) => ({ content: [{ type: "text", text: s }] });
+function createMcpServer(deps) {
+  const server2 = new McpServer(
+    { name: "cordon", version: "0.1.0" },
+    {
+      instructions: "Cordon bounds what this agent can spend. Use cordon_fetch for any URL that may charge; it pays through a contract that can refuse. There is no tool here that sends money to an address, and a refusal is a final answer rather than an error to retry."
+    }
+  );
+  const transport = deps.transport ?? httpTransport;
+  const newKey = deps.newOperatorKey ?? generatePrivateKey;
+  server2.registerTool(
+    "cordon_fetch",
+    {
+      description: "Fetch a URL. If it answers 402, pay for it through Cordon and return the body. The recipient and the price come from the seller's own challenge, not from you. May return a refusal, which is final.",
+      inputSchema: {
+        url: z.string().url().describe("The URL to fetch."),
+        method: z.string().optional().describe("HTTP method. Defaults to GET."),
+        body: z.string().optional().describe("Request body, for POST and friends.")
+      }
+    },
+    async ({ url, method, body }) => {
+      const result = await cordonFetch(
+        { node: deps.node, url, method, body },
+        { gate: deps.gate, settler: deps.settler, acceptable: deps.acceptable, transport, released: deps.released }
+      );
+      if ("free" in result && result.free) {
+        const shown = typeof result.body === "string" ? result.body : JSON.stringify(result.body, null, 2);
+        return text(`${url} charged nothing.
+
+${shown}`);
+      }
+      if (!result.paid) {
+        const refused = result;
+        return text(renderRefusal(refused.refusal, refused.offer, deps.explorer));
+      }
+      const paid = result;
+      return text(renderPaid(paid.draw, paid.offer, paid.body));
+    }
+  );
+  server2.registerTool(
+    "cordon_spawn",
+    {
+      description: "Register a child mandate under this one for a sub-agent. The child can only ever be narrower than its parent; the contract refuses a wider one whoever asks. The key for the child is held here, not by any agent.",
+      inputSchema: {
+        label: z.string().describe(
+          "What this sub-agent is for, in one line. Written beside its key and onto its ERC-8004 identity as a stated purpose. A description, not a bound."
+        ),
+        budgetUsdc: z.string().describe('Window budget in USDC, e.g. "25.00".'),
+        trancheUsdc: z.string().optional().describe("Per-draw cap. Defaults to the parent's."),
+        concentrationPct: z.number().optional().describe("Percent of the window one counterparty may take.")
+      }
+    },
+    async ({ label, budgetUsdc, trancheUsdc, concentrationPct }) => {
+      const parent = await deps.gate.mandate(deps.node);
+      const purpose = cleanPurpose(label);
+      const key = newKey();
+      const operator = deps.gate.addOperator(key);
+      const keyLabel = deps.keyFile?.remember(key, operator, purpose);
+      const { node: node2, txHash, purposePublished } = await deps.gate.spawn(deps.node, {
+        operator,
+        budget6: toBase6(budgetUsdc),
+        trancheCap6: trancheUsdc ? toBase6(trancheUsdc) : parent.trancheCap6,
+        concentrationBps: concentrationPct !== void 0 ? Math.round(concentrationPct * 100) : parent.concentrationBps,
+        purpose
+      });
+      let nodeIdSaved = false;
+      if (deps.keyFile && keyLabel) {
+        try {
+          deps.keyFile.bind(keyLabel, node2);
+          nodeIdSaved = true;
+        } catch {
+          nodeIdSaved = false;
+        }
+      }
+      return text(
+        [
+          `Spawned "${label}".`,
+          `  node       ${node2}`,
+          `  operator   ${operator}`,
+          `  budget     ${budgetUsdc} USDC`,
+          purpose ? purposePublished ? "  purpose    on its ERC-8004 identity \u2014 stated, not enforced" : "  purpose    kept beside its key; not published to its identity" : "",
+          keyLabel ? nodeIdSaved ? `  key        saved under ${keyLabel} in the operator's key file` : `  key        saved under ${keyLabel}; its node id could not be written beside it` : "  key        held in memory only \u2014 lost if this server restarts",
+          txHash ? `  tx         ${txHash}` : "",
+          "",
+          "Every draw this child makes also debits this mandate and every one",
+          "above it. It cannot be widened later."
+        ].filter(Boolean).join("\n")
+      );
+    }
+  );
+  server2.registerTool(
+    "cordon_status",
+    {
+      description: "What this mandate may still spend, and which node in the tree is the limit. The answer is often an ancestor rather than this node.",
+      inputSchema: {}
+    },
+    async () => {
+      const { available, boundBy } = await deps.gate.headroom(deps.node);
+      const own = boundBy.toLowerCase() === deps.node.toLowerCase();
+      return text(
+        [
+          `Can still draw   ${fromBase6(available)} USDC`,
+          `Limited by       ${own ? "this mandate" : boundBy}`,
+          own ? "" : "An ancestor is the binding constraint, not this node's own budget."
+        ].filter(Boolean).join("\n")
+      );
+    }
+  );
+  return server2;
+}
+function toBase6(usdc2) {
+  const match = /^(\d+)(?:\.(\d{1,6}))?$/.exec(usdc2.trim());
+  if (!match) throw new Error(`not a USDC amount: ${usdc2}`);
+  return BigInt(match[1]) * 1000000n + BigInt((match[2] ?? "").padEnd(6, "0"));
+}
+function fromBase6(base6) {
+  return `${base6 / 1000000n}.${(base6 % 1000000n).toString().padStart(6, "0").slice(0, 2)}`;
+}
+
+// src/main.ts
+var envFiles = (process.env.CORDON_ENV_FILE ?? "").split(",").map((file) => file.trim()).filter(Boolean);
+for (const file of envFiles) {
+  try {
+    process.loadEnvFile(file);
+  } catch (error) {
+    console.error(`cordon: CORDON_ENV_FILE names ${file}, which could not be read: ${error.message}`);
+    process.exit(1);
+  }
+}
+if (envFiles.length > 0) process.env.CORDON_KEY_FILE ??= envFiles[envFiles.length - 1];
+if (DEPLOYMENT) {
+  process.env.CORDON_VAULT ??= DEPLOYMENT.vault;
+  process.env.CORDON_REGISTRY ??= DEPLOYMENT.registry;
+  process.env.CORDON_RECORD ??= DEPLOYMENT.record;
+}
+var config = load(process.env);
+var gate = new Gate(config);
+var configured = gate.nodes();
+var asked = process.env.CORDON_MCP_NODE?.toLowerCase();
+var node = asked ? configured.find((n) => n.toLowerCase() === asked) : configured[0];
+if (!node) {
+  console.error(
+    asked ? `cordon: CORDON_MCP_NODE is ${asked} and this process holds no key for it. It holds: ${configured.join(", ") || "none"}` : "cordon: no node configured; set CORDON_NODE_<label> and CORDON_KEY_<label>"
+  );
+  process.exit(1);
+}
+var server = createMcpServer({
+  gate,
+  keyFile: keyFileAt(config.keyFile),
+  /* The same file the daemon keeps, so a release spent through one surface is
+     not spent again through the other. */
+  released: new ChainReleases({
+    count: () => gate.refusalCount(),
+    read: (id) => gate.refusal(id),
+    live: (node2) => gate.isLive(node2),
+    file: join2(dirname3(config.keyFile), "released-spent.json")
+  }),
+  settler: new CircleSettler({
+    publicClient: gate.publicClientForSettlement,
+    walletFor: (node2) => gate.signerFor(node2),
+    chainId: config.chainId
+  }),
+  acceptable: { networks: config.networks, assets: config.assets },
+  node,
+  explorer: config.chainId === ARC.chainId ? ARC.explorer : void 0
+});
+console.error(`cordon mcp: node ${node} on chain ${config.chainId}`);
+await server.connect(new StdioServerTransport());