@ostraagent/mcp 0.1.11 → 0.1.13

package/dist/ostra-mcp.js

@@ -18,7 +18,7 @@ var __export = (target, all) => {
 var define_OSTRA_PACKAGED_default;
 var init_define_OSTRA_PACKAGED = __esm({
   "<define:OSTRA_PACKAGED>"() {
-    define_OSTRA_PACKAGED_default = { version: "0.1.11", deployment: { version: 1, chainId: 4663, fromBlock: "91991509", token: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168", batchSettlement: "0x4020074e9dF2ce1deE5A9C1b5c3f541D02a10003", vaultImplementation: "0xec0ca4A1393D91c42cA809F7F9dd82Bd597E8E58", vaultBeacon: "0xE9F525B9EaeE48d13AEd28fE146F48f2832a18a0", vaultFactory: "0x043a15c514CFE2c797d33520bFF91a5DCdbf2979", poolImplementation: "0xC04d4a222dC1C966640B977608bE29949b0648ec", poolBeacon: "0x30669Ca534921038a531BBE27116d85bB7406fFF", pool: "0x6ea80F2462e5Fd783B0Ec3B2c7BaC96795980CD6", splitFactory: "0xAAf54A483B2c7c2c5ecFc1eDED5ed1619C1bA882", beaconOwner: "0x55533a51d9bd9b06F2D179d919BB31995EF96E5e", registry: "0xcE6Cc1f93744f4090DA1444Bb8590d9206157506", vaultModule: "0x55A89fF907f5F5756470e2ec5Dc5E4E1C54Da770", launchpad: { hook: "0x63A784afb8905452aDceC471a45E555F5caE68cC", fees: "0x8e79671DC9729476614C78aFcf2345D4c1963801", launchpad: "0xfC57162C0e3f9773F97fEa8d276e957d7c43A6C5", creatorSplit: "0x987994dE6A1d5303B9e3F50977cB0321BA4D033B", dispatcher: "0x44Bb65164b2855f8E80B142d5Fb9bDb72E869986", locker: "0xb593812363bAd70Ee381c7B54c4FC82b0BA3A4A7", devBuy: "0x0e1Fd799E136dcfEcad5695B07Ac5DAc5B2fF4bc", vesting: "0xadD9C1995910457312c156E7D8120D1b447E179a", airdrop: "0xBC798D956aF4c2B104FFC6106d5322294Bc103bb", owner: "0x6569E27A95a6A3E92A311B4Cc6600fed56aA50A2" }, breaker: "0x2E33244dE6A64007204f763e9ef81FC33F1a8e01" }, swapDeployment: { chainId: 4663, fromBlock: "94940585", router: "0x5b9686f384A5Fb768B2360cF0B893F0d1E960B01", stake: "0xaDA4FaB9c8aB9165bf4d6cD9d4Da6d6b32Bb4BC6", buyback: "0xd86083031b7Af66ecD5C9c5e90D4C6d8E661F3f5", spendVerifier: "0x0a0E28a81DE6289e5044950163FfE95b37180e3B", privatePool: "0xe4250895Da2499602Cee4e178Fb46A0cF39F5b76" }, prover: { wasm: "0xd5f3069334ab49a2f955e4b4be9493b80c3f7b2a85f4ff2073a327ef5fbc2747", glue: "0x4bc8bef7c755c83daaf833623f85473a20a7c40b390d8d639d9e4353618a0537" }, relayerUrl: "https://relayer.ostraagent.xyz", keeperUrl: "https://keeper.ostraagent.xyz", aggregatorUrl: "https://aggregator.ostraagent.xyz", aiUrl: "https://ai.ostraagent.xyz" };
+    define_OSTRA_PACKAGED_default = { version: "0.1.13", deployment: { version: 1, chainId: 4663, fromBlock: "91991509", token: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168", batchSettlement: "0x4020074e9dF2ce1deE5A9C1b5c3f541D02a10003", vaultImplementation: "0xec0ca4A1393D91c42cA809F7F9dd82Bd597E8E58", vaultBeacon: "0xE9F525B9EaeE48d13AEd28fE146F48f2832a18a0", vaultFactory: "0x043a15c514CFE2c797d33520bFF91a5DCdbf2979", poolImplementation: "0xC04d4a222dC1C966640B977608bE29949b0648ec", poolBeacon: "0x30669Ca534921038a531BBE27116d85bB7406fFF", pool: "0x6ea80F2462e5Fd783B0Ec3B2c7BaC96795980CD6", splitFactory: "0xAAf54A483B2c7c2c5ecFc1eDED5ed1619C1bA882", beaconOwner: "0x55533a51d9bd9b06F2D179d919BB31995EF96E5e", registry: "0xcE6Cc1f93744f4090DA1444Bb8590d9206157506", vaultModule: "0x55A89fF907f5F5756470e2ec5Dc5E4E1C54Da770", launchpad: { hook: "0x63A784afb8905452aDceC471a45E555F5caE68cC", fees: "0x8e79671DC9729476614C78aFcf2345D4c1963801", launchpad: "0xfC57162C0e3f9773F97fEa8d276e957d7c43A6C5", creatorSplit: "0x987994dE6A1d5303B9e3F50977cB0321BA4D033B", dispatcher: "0x44Bb65164b2855f8E80B142d5Fb9bDb72E869986", locker: "0xb593812363bAd70Ee381c7B54c4FC82b0BA3A4A7", devBuy: "0x0e1Fd799E136dcfEcad5695B07Ac5DAc5B2fF4bc", vesting: "0xadD9C1995910457312c156E7D8120D1b447E179a", airdrop: "0xBC798D956aF4c2B104FFC6106d5322294Bc103bb", owner: "0x6569E27A95a6A3E92A311B4Cc6600fed56aA50A2" }, breaker: "0x2E33244dE6A64007204f763e9ef81FC33F1a8e01" }, swapDeployment: { chainId: 4663, fromBlock: "94940585", router: "0x5b9686f384A5Fb768B2360cF0B893F0d1E960B01", stake: "0xaDA4FaB9c8aB9165bf4d6cD9d4Da6d6b32Bb4BC6", buyback: "0xd86083031b7Af66ecD5C9c5e90D4C6d8E661F3f5", spendVerifier: "0x0a0E28a81DE6289e5044950163FfE95b37180e3B", privatePool: "0xe4250895Da2499602Cee4e178Fb46A0cF39F5b76" }, prover: { wasm: "0xd5f3069334ab49a2f955e4b4be9493b80c3f7b2a85f4ff2073a327ef5fbc2747", glue: "0x4bc8bef7c755c83daaf833623f85473a20a7c40b390d8d639d9e4353618a0537" }, relayerUrl: "https://relayer.ostraagent.xyz", keeperUrl: "https://keeper.ostraagent.xyz", aggregatorUrl: "https://aggregator.ostraagent.xyz", aiUrl: "https://ai.ostraagent.xyz" };
   }
 });
 
@@ -13581,6 +13581,14 @@ var init_abi = __esm({
   }
 });
 
+// ../sdk/src/agent-card.ts
+var init_agent_card = __esm({
+  "../sdk/src/agent-card.ts"() {
+    "use strict";
+    init_define_OSTRA_PACKAGED();
+  }
+});
+
 // ../sdk/src/hash.ts
 import { keccak_256 } from "@noble/hashes/sha3.js";
 import { sha256 as sha256Hash } from "@noble/hashes/sha2.js";
@@ -15445,7 +15453,7 @@ var init_morpho = __esm({
 });
 
 // ../sdk/src/borro.ts
-import { getAddress as getAddress5, parseAbi as parseAbi2, zeroAddress as zeroAddress4 } from "viem";
+import { getAbiItem, getAddress as getAddress5, parseAbi as parseAbi2, zeroAddress as zeroAddress4 } from "viem";
 function borroStocks() {
   return BORRO_STOCKS.map((s) => {
     const market2 = { loanToken: USDG, collateralToken: s.vault, oracle: s.oracle, irm: BORRO_IRM, lltv: s.lltv };
@@ -15466,6 +15474,26 @@ function halfLltvMaxDebt(collateral, price, lltv) {
   const value = collateral * price / 10n ** 36n;
   return value * lltv * VAULT_MAX_LTV_OF_LLTV_BPS / (10n ** 18n * 10000n);
 }
+async function readHashApprovals(client, logsClient, vault, fromBlock) {
+  const version = Number(await client.readContract({ address: vault, abi: ostraVaultAbi, functionName: "VERSION" }));
+  if (version < VAULT_V3) return [];
+  const event = getAbiItem({ abi: ostraVaultModuleAbi, name: "HashApproved" });
+  const logs = await getLogsChunked(logsClient, { address: vault, event, fromBlock, toBlock: await logsClient.getBlockNumber({ cacheTime: 0 }) });
+  const head = await blockTime(client);
+  const hashes = [];
+  for (const l of logs) {
+    const h = l.args.hash.toLowerCase();
+    if (!hashes.includes(h)) hashes.push(h);
+  }
+  const out = [];
+  for (const hash of hashes) {
+    const validFrom = BigInt(
+      await client.readContract({ address: vault, abi: ostraVaultAbi, functionName: "hashValidFrom", args: [hash], blockNumber: head.blockNumber })
+    );
+    if (validFrom !== 0n) out.push({ hash, validFrom, valid: head.timestamp >= validFrom });
+  }
+  return out;
+}
 async function readVaultGuard(client, vault) {
   const version = Number(await client.readContract({ address: vault, abi: ostraVaultAbi, functionName: "VERSION" }));
   const off = { withdrawal: zeroAddress4, delay: 0, dailyLimit: 0n };
@@ -15652,21 +15680,54 @@ var init_breaker = __esm({
 
 // ../sdk/src/chain.ts
 import { BaseError as BaseError2, createPublicClient, defineChain, http } from "viem";
-function invalidParams(e) {
-  const code = (x) => x.code === -32602;
-  return e instanceof BaseError2 ? e.walk(code) !== null : code(e);
+function laggingRead(e) {
+  const lag = (x) => {
+    const o = x;
+    if (o.code === -32602) return true;
+    return o.code === -32e3 && /unsupported block number/i.test(`${String(o.details ?? "")} ${String(o.message ?? "")}`);
+  };
+  return e instanceof BaseError2 ? e.walk(lag) !== null : lag(e);
+}
+function transient(e) {
+  const o = e;
+  if (o === null || typeof o !== "object") return true;
+  if (o.name === "AbortError") return false;
+  if (typeof o.code === "number") return [-1, -32005, -32603, 429, -32007].includes(o.code);
+  if (typeof o.status === "number" && o.status !== 0) return [403, 408, 413, 429, 500, 502, 503, 504].includes(o.status);
+  return true;
 }
-function retryingHttp(url) {
-  const base = http(url, { retryCount: 8, retryDelay: 1e3, timeout: 3e4 });
+function failureText(e, url) {
+  const o = e;
+  const parts = [o?.shortMessage ?? o?.name ?? String(e)];
+  if (typeof o?.code === "number") parts.push(`code ${o.code}`);
+  if (typeof o?.status === "number" && o.status !== 0) parts.push(`HTTP ${o.status}`);
+  if (typeof o?.details === "string" && o.details !== "" && o.details !== parts[0]) parts.push(o.details);
+  return redact(parts.join("; "), url).slice(0, 300);
+}
+function retryingHttp(url, o) {
+  const own = o !== void 0;
+  const base = own ? http(url, { retryCount: 0, timeout: o.timeoutMs ?? RPC_TIMEOUT_MS }) : http(url, { retryCount: RPC_RETRIES, retryDelay: RPC_RETRY_WAIT_MS, timeout: RPC_TIMEOUT_MS });
+  const retries = o?.retryCount ?? RPC_RETRIES;
   return ((params) => {
     const t = base(params);
     const request = (async (args, options) => {
-      for (let attempt = 0; ; attempt++) {
+      let lagging = 0;
+      let failed = 0;
+      for (; ; ) {
         try {
           return await t.request(args, options);
         } catch (e) {
-          if (attempt >= INVALID_PARAMS_RETRIES || !IDEMPOTENT_READS.has(args.method) || !invalidParams(e)) throw e;
-          await new Promise((r) => setTimeout(r, INVALID_PARAMS_WAIT_MS * 2 ** attempt));
+          let wait;
+          if (lagging < INVALID_PARAMS_RETRIES && IDEMPOTENT_READS.has(args.method) && laggingRead(e)) {
+            wait = INVALID_PARAMS_WAIT_MS * 2 ** lagging;
+            lagging++;
+          } else if (own && failed < retries && transient(e)) {
+            const after = e.headers?.get?.("Retry-After");
+            wait = after !== null && after !== void 0 && /^[0-9]+$/.test(after) ? Math.min(Number(after) * 1e3, RETRY_AFTER_MAX_MS) : RPC_RETRY_WAIT_MS * 2 ** failed;
+            failed++;
+          } else throw e;
+          o?.onRetry?.({ method: args.method, retry: lagging + failed, waitMs: wait, error: failureText(e, url) });
+          await new Promise((r) => setTimeout(r, wait));
         }
       }
     });
@@ -15683,7 +15744,7 @@ async function assertRobinhoodChain(client) {
 function redact(text3, secret2) {
   return secret2 === "" ? text3 : text3.split(secret2).join("<rpc>");
 }
-var robinhoodChain, IDEMPOTENT_READS, INVALID_PARAMS_RETRIES, INVALID_PARAMS_WAIT_MS;
+var robinhoodChain, IDEMPOTENT_READS, INVALID_PARAMS_RETRIES, INVALID_PARAMS_WAIT_MS, RPC_RETRIES, RPC_RETRY_WAIT_MS, RPC_TIMEOUT_MS, RETRY_AFTER_MAX_MS;
 var init_chain = __esm({
   "../sdk/src/chain.ts"() {
     "use strict";
@@ -15700,6 +15761,10 @@ var init_chain = __esm({
     IDEMPOTENT_READS = /* @__PURE__ */ new Set(["eth_call", "eth_getCode", "eth_getStorageAt", "eth_getBalance", "eth_getBlockByNumber", "eth_getBlockByHash", "eth_blockNumber", "eth_chainId", "eth_getTransactionReceipt", "eth_getTransactionByHash", "eth_getTransactionCount", "eth_gasPrice"]);
     INVALID_PARAMS_RETRIES = 4;
     INVALID_PARAMS_WAIT_MS = 1e3;
+    RPC_RETRIES = 8;
+    RPC_RETRY_WAIT_MS = 1e3;
+    RPC_TIMEOUT_MS = 3e4;
+    RETRY_AFTER_MAX_MS = 1e4;
   }
 });
 
@@ -19135,7 +19200,7 @@ var init_relayer = __esm({
     init_messages();
     init_external_abi();
     RELAYER_MARGIN_BPS = 1000n;
-    RELAYER_QUOTE_TOLERANCE_BPS = 200n;
+    RELAYER_QUOTE_TOLERANCE_BPS = 1000n;
     ETH_USD_DEVIATION_BPS = 50n;
     ETH_USD_MAX_AGE_SECONDS = 90000n;
     MAX_RELAY_CALLS = 8;
@@ -19873,6 +19938,7 @@ var init_browser = __esm({
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_abi();
+    init_agent_card();
     init_aggregator();
     init_airdrop();
     init_backup();
@@ -20406,9 +20472,11 @@ var init_relay = __esm({
       }
     };
     PendingSpendUnpaidError = class extends Error {
-      constructor(message) {
+      onCredit;
+      constructor(message, onCredit) {
         super(message);
         this.name = "PendingSpendUnpaidError";
+        this.onCredit = onCredit;
       }
     };
     RelayerError = class extends Error {
@@ -20705,6 +20773,7 @@ var init_relay = __esm({
       async #post(calls, extra, headers = {}) {
         const body2 = { calls: calls.map((c) => ({ to: getAddress17(c.to), data: c.data })) };
         if (extra.prepay === true) body2.prepay = true;
+        if (extra.onCredit === true) body2.onCredit = true;
         if (extra.payer !== null) body2.payer = extra.payer;
         if (extra.allowFailedSwaps === true) body2.allowFailedSwaps = true;
         return this.#http("POST", "/v1/relay", JSON.stringify(body2), headers);
@@ -20899,9 +20968,11 @@ var init_relay = __esm({
       }
       async send(calls, options = {}) {
         await this.facts();
+        const credit = options.onCredit === true;
+        const post2 = async () => this.#post(calls, { prepay: options.prepay === true, payer: credit ? null : await this.#payer(), allowFailedSwaps: options.allowFailedSwaps === true, onCredit: credit });
         let notSent = "";
         for (let resend = 0; resend < MAX_RESENDS; resend++) {
-          let answer = await this.#post(calls, { prepay: options.prepay === true, payer: await this.#payer(), allowFailedSwaps: options.allowFailedSwaps === true });
+          let answer = await post2();
           let again = false;
           for (let step2 = 0; step2 < MAX_STEPS && !again; step2++) {
             const b = answer.body;
@@ -20911,14 +20982,15 @@ var init_relay = __esm({
               await this.#landed(hash);
               return hash;
             }
+            if (answer.status === 402 && credit) throw new RelayerError(402, "no_credit", "the relayer does not send this spend on credit (it asks for payment); nothing was sent");
             if (answer.status === 402) {
               answer = await this.#pay(calls, answer, options);
               continue;
             }
             if (answer.status === 403 && (error === "vault_in_debt" || error === "open_unpaid")) {
-              if (options.reservation !== void 0 && options.reservation !== null) throw new RelayerError(403, error, String(b?.message ?? error));
+              if (credit || options.reservation !== void 0 && options.reservation !== null) throw new RelayerError(403, error, String(b?.message ?? error));
               await this.#ensureChannel(1n, options.openChannel, null);
-              answer = await this.#post(calls, { prepay: options.prepay === true, payer: await this.#payer(), allowFailedSwaps: options.allowFailedSwaps === true });
+              answer = await post2();
               continue;
             }
             if (answer.status === 409 && error === "not_sent") {
@@ -21463,10 +21535,14 @@ var init_vault = __esm({
        * Runs `fn` with what a vault spend needs to be paid. With the relayer: a
        * reservation of unused relayer channel deposit for its price (a channel is
        * opened first if none has room), released once `fn` is done. When a spend
-       * signed earlier waits and no relayer channel can pay for it, the local fee
-       * payer sends it if it holds the ETH. `moves` is what the spend takes out
-       * of this vault: a relayer channel opened from the buyer vault for it
-       * leaves that much in the buyer vault.
+       * signed earlier waits and no relayer channel can pay for it (its key is
+       * the one a new channel's open needs), the relayer is asked to send it on
+       * credit, as the vault's debt, and the channel opened next pays that debt
+       * with its first voucher; `fn` then runs as usual and its result names what
+       * was sent first (`sentFirst`). Only when the relayer does not send it so,
+       * the local fee payer sends it if it holds the ETH. `moves` is what the
+       * spend takes out of this vault: a relayer channel opened from the buyer
+       * vault for it leaves that much in the buyer vault.
        */
       async #paidSpend(sender, fn, moves = 0n, gas = VAULT_SPEND_GAS, extraWei = 0n) {
         await this.#finishRecoveryFirst(sender);
@@ -21478,10 +21554,30 @@ var init_vault = __esm({
           reservation = await sender.reserve(gas, sender === this.#sender ? this.#opener() : void 0, this.#paysRelayer() ? moves : 0n, extraWei);
         } catch (err) {
           if (!(err instanceof PendingSpendUnpaidError)) throw err;
+          let refused = "";
+          const credit = err.onCredit;
+          if (sender.relayed && credit !== void 0) {
+            let sentFirst = null;
+            try {
+              sentFirst = await (credit.owner === this ? credit.unqueued() : credit.queued());
+            } catch (e) {
+              if (!(e instanceof RelayerError)) throw e;
+              refused = `; the relayer did not send it on credit (${e.message})`;
+            }
+            if (refused === "") {
+              const again = await sender.reserve(gas, sender === this.#sender ? this.#opener() : void 0, this.#paysRelayer() ? moves : 0n, extraWei);
+              try {
+                const r = await fn(sender, again);
+                return sentFirst !== null && r !== null && typeof r === "object" ? { ...r, sentFirst } : r;
+              } finally {
+                sender.release(again);
+              }
+            }
+          }
           const local = new LocalSender(this.#client, this.#transport, this.#keys.feePayer, this.#keys.escrow);
           const need = gas * await this.#client.getGasPrice() * ETH_HEADROOM + extraWei;
           if (await ethBalance(this.#client, this.#keys.feePayer.address) < need) {
-            throw new Error(`${err.message}; send at least ${formatEth(need)} ETH to the fee payer ${this.#keys.feePayer.address} and call again: it sends that operation itself`);
+            throw new Error(`${err.message}${refused}; send at least ${formatEth(need)} ETH to the fee payer ${this.#keys.feePayer.address} and call again: it sends that operation itself`);
           }
           return fn(local, null);
         }
@@ -21491,6 +21587,25 @@ var init_vault = __esm({
           sender.release(reservation);
         }
       }
+      /**
+       * Sends the spend signed earlier through the relayer on credit (SendOptions.onCredit): the vault owes its price, which
+       * the first voucher of the channel opened next pays. Returns what was sent, or null when nothing waits any more.
+       */
+      async #sendPendingOnCredit() {
+        const sender = this.#sender;
+        if (!sender.relayed) return null;
+        const vault = await this.vaultAddress();
+        const v = await this.#read(vault);
+        if (v === null) return null;
+        const credit = {
+          relayed: true,
+          payer: () => sender.payer(),
+          send: (calls, o = {}) => sender.send(calls, { ...o, reservation: null, onCredit: true }),
+          reserve: async () => null,
+          release: () => void 0
+        };
+        return this.#sendPending(vault, v, credit, null);
+      }
       /**
        * Version 3 vaults: the spend is run first with a throwaway key (sdk simulateVaultSpend) and refused before it is
        * signed when it would revert, or land as a failure (a SupportRecovery the other vault refuses). A signed spend that
@@ -21720,7 +21835,11 @@ the signed channel open is kept; the next open_channel or withdraw call sends it
         const v = await this.#read(vault);
         if (v === null) throw new Error(this.#missing());
         if (await this.#pending(v) !== null) {
-          throw new PendingSpendUnpaidError("a vault operation signed earlier waits to be sent and no channel to the relayer has deposit left to pay for it");
+          throw new PendingSpendUnpaidError("a vault operation signed earlier waits to be sent and no channel to the relayer has deposit left to pay for it", {
+            owner: this,
+            queued: () => this.#serial(() => this.#sendPendingOnCredit()),
+            unqueued: () => this.#sendPendingOnCredit()
+          });
         }
         await this.#notFrozen(vault, "the vault");
         const balance = await this.#balance(vault);
@@ -22292,6 +22411,26 @@ var init_borro2 = __esm({
         const at = await this.#address(vault, what.toUpperCase());
         return { vault: at, ...await readVaultGuard(this.#p.client, at) };
       }
+      /**
+       * The lock's status (guard) with the hashes the vault approves for EIP-1271 now (sdk readHashApprovals): of the vault
+       * of `what`, or, given `otherText`, of any Ostra vault (a guardian watching the vault it guards). Read only.
+       */
+      async lockStatus(what, otherText) {
+        let at;
+        if (otherText === void 0) {
+          const { vault } = this.#vaultOf(what);
+          at = await this.#address(vault, what.toUpperCase());
+        } else {
+          if (!isAddress8(otherText, { strict: false })) throw new RangeError(`${otherText} is not an address`);
+          at = getAddress19(otherText);
+          if (await readVault(this.#p.client, this.#p.config.deployment, at) === null) throw new Error(`${at} is not an Ostra vault`);
+        }
+        const [g, approvals] = await Promise.all([
+          readVaultGuard(this.#p.client, at),
+          readHashApprovals(this.#p.client, this.#p.logsClient ?? this.#p.client, at, BigInt(this.#p.config.deployment.fromBlock))
+        ]);
+        return { vault: at, ...g, approvals };
+      }
       /**
        * Turns the withdrawal lock of the vault of `what` on (a withdrawal address, a delay, a daily limit in the vault's
        * token) or changes it; `withdrawal` "off" turns it off (that waits the delay). The withdrawal address must keep
@@ -22375,11 +22514,27 @@ var init_borro2 = __esm({
         const names = ["cancel", "revoke", "sweep", "redeem", "withdraw collateral"];
         return this.#spend(this.#p.buyer, VAULT_ACTION.GUARD, guardParams(target, call), `guard (${names[call.op] ?? call.op}) of ${target}`);
       }
-      /** Approves (or withdraws) `hash` for EIP-1271 on the buyer vault: under the lock an approval waits its delay. */
+      /**
+       * Approves (or withdraws) `hash` for EIP-1271 on the buyer vault: under the lock an approval waits its delay. For this
+       * package's own digests only (Raeto's login message, OstraBreaker's limits), which it builds and checks itself: an
+       * approved hash makes the vault answer isValidSignature for it, and USDG takes such an answer for a permit and for a
+       * transfer authorization, so a hash from anywhere else could hand the vault's funds out. No tool approves a hash it is
+       * given (withdrawApproval only withdraws).
+       */
       async approveHash(hash, approved) {
         if (!/^0x[0-9a-fA-F]{64}$/.test(hash) || /^0x0{64}$/.test(hash)) throw new RangeError("the hash is 32 bytes of 0x hex, not zero");
         return this.#spend(this.#p.buyer, VAULT_ACTION.APPROVE_HASH, approveHashParams({ hash, approved }), approved ? "EIP-1271 approval" : "EIP-1271 approval withdrawal");
       }
+      /**
+       * Withdraws the EIP-1271 approval of `hash` by the vault of `what` ("USDG", the buyer vault, or a Borro stock's
+       * vault): lands when there is none (nothing to do). Withdrawing is at once, under the lock too.
+       */
+      async withdrawApproval(what, hash) {
+        if (!/^0x[0-9a-fA-F]{64}$/.test(hash) || /^0x0{64}$/.test(hash)) throw new RangeError("the hash is 32 bytes of 0x hex, not zero");
+        const { vault } = this.#vaultOf(what);
+        await this.#address(vault, what.toUpperCase());
+        return this.#spend(vault, VAULT_ACTION.APPROVE_HASH, approveHashParams({ hash, approved: false }), `EIP-1271 approval withdrawal (${what.toUpperCase()} vault)`);
+      }
     };
   }
 });
@@ -23548,24 +23703,17 @@ function imageUri(value) {
   return value;
 }
 function profileFile(p) {
-  const services = [];
-  const website = link2(p.website, "website");
-  const x = link2(p.x, "x");
-  const telegram = link2(p.telegram, "telegram");
-  if (website !== void 0) services.push({ name: "web", endpoint: website });
-  if (x !== void 0) services.push({ name: "X", endpoint: x });
-  if (telegram !== void 0) services.push({ name: "Telegram", endpoint: telegram });
-  services.push({ name: "agentWallet", endpoint: `eip155:${ROBINHOOD_CHAIN_ID}:${p.vault}` });
+  const id = p.agentId === void 0 || p.agentId === null ? null : p.agentId;
+  if (id !== null && !/^(0|[1-9][0-9]{0,29})$/.test(id)) throw new RangeError("an agent id is a decimal number");
   const image = imageUri(p.image);
-  const description = text2(p.description, "description", 1e3);
   return {
     type: "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
-    name: text2(p.name, "name", 64),
-    ...description === void 0 ? {} : { description },
+    name: id === null ? AGENT_NAME : `${AGENT_NAME} #${id}`,
+    description: AGENT_DESCRIPTION,
     ...image === void 0 ? {} : { image },
-    services,
+    services: [{ name: "agentWallet", endpoint: `eip155:${ROBINHOOD_CHAIN_ID}:${p.vault}` }],
     active: true,
-    registrations: p.agentId === void 0 || p.agentId === null ? [] : [{ agentId: Number(p.agentId), agentRegistry: `eip155:${ROBINHOOD_CHAIN_ID}:${ERC8004_IDENTITY_REGISTRY}` }]
+    registrations: id === null ? [] : [{ agentId: Number(id), agentRegistry: `eip155:${ROBINHOOD_CHAIN_ID}:${ERC8004_IDENTITY_REGISTRY}` }]
   };
 }
 function tokenMetadataFile(m) {
@@ -23604,6 +23752,9 @@ function uploaderUrl(relayerUrl) {
 function uploadJson(relayerUrl, value) {
   return post(`${uploaderUrl(relayerUrl)}/json`, JSON.stringify(value), "application/json");
 }
+function agentCardUri(relayerUrl, agentId) {
+  return post(`${uploaderUrl(relayerUrl)}/agent-card`, JSON.stringify({ agentId }), "application/json");
+}
 function uploadImage(relayerUrl, bytes) {
   const base = uploaderUrl(relayerUrl);
   if (bytes.length === 0 || bytes.length > MAX_UPLOAD_IMAGE_BYTES) throw new RangeError(`the image must be 1 to ${MAX_UPLOAD_IMAGE_BYTES} bytes (it is ${bytes.length})`);
@@ -23611,13 +23762,15 @@ function uploadImage(relayerUrl, bytes) {
   if (type === null) throw new RangeError("the image is not a PNG, JPEG, WebP or GIF");
   return post(`${base}/image`, new Blob([new Uint8Array(bytes)], { type }), type);
 }
-var MAX_UPLOAD_IMAGE_BYTES;
+var MAX_UPLOAD_IMAGE_BYTES, AGENT_NAME, AGENT_DESCRIPTION;
 var init_publish = __esm({
   "../core/src/publish.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_src();
     MAX_UPLOAD_IMAGE_BYTES = 1048576;
+    AGENT_NAME = "Ostra Agent";
+    AGENT_DESCRIPTION = "An AI agent with an Ostra post-quantum privacy vault on Robinhood Chain. Its earnings and payments stay in its own vault, signed with one-time keys.";
   }
 });
 
@@ -23652,7 +23805,7 @@ function simulatedGas(gasUsed) {
   const g = gasUsed * 5n / 4n + SPEND_GAS_HEADROOM2;
   return g > VAULT_SPEND_GAS ? g : VAULT_SPEND_GAS;
 }
-var LAUNCHPAD_DIR, CREATE_VAULT_GAS2, LAUNCH_GAS_HEADROOM, PAIRS_READ_CONCURRENCY, SPEND_GAS_HEADROOM2, DAY, TOKEN_LIST_MAX, METADATA_MAX_BYTES, launchedEvent, POOL_SETTING_NAMES, WOTS_GAS_SPREAD, STAND_IN_URI, LaunchpadService;
+var LAUNCHPAD_DIR, CREATE_VAULT_GAS2, LAUNCH_GAS_HEADROOM, PAIRS_READ_CONCURRENCY, SPEND_GAS_HEADROOM2, DAY, LOGS_CATCH_UP_SECONDS, TOKEN_LIST_MAX, METADATA_MAX_BYTES, launchedEvent, POOL_SETTING_NAMES, WOTS_GAS_SPREAD, STAND_IN_URI, LaunchpadService;
 var init_launchpad = __esm({
   "../core/src/launchpad.ts"() {
     "use strict";
@@ -23673,6 +23826,7 @@ var init_launchpad = __esm({
     PAIRS_READ_CONCURRENCY = 6;
     SPEND_GAS_HEADROOM2 = 100000n;
     DAY = 86400;
+    LOGS_CATCH_UP_SECONDS = 30;
     TOKEN_LIST_MAX = 50;
     METADATA_MAX_BYTES = 65536;
     launchedEvent = parseAbiItem5("event Launched(bytes32 indexed poolId, address indexed token, address indexed creatorVault, address quote)");
@@ -23692,6 +23846,7 @@ var init_launchpad = __esm({
     STAND_IN_URI = `ipfs://bafkrei${"a".repeat(52)}`;
     LaunchpadService = class {
       #client;
+      #logsClient;
       #transport;
       #config;
       #keys;
@@ -23706,6 +23861,7 @@ var init_launchpad = __esm({
       constructor(p) {
         if (p.creator.kind !== "creator" || p.buyer.kind !== "buyer") throw new Error("the launchpad takes the agent's buyer and creator vaults");
         this.#client = p.client;
+        this.#logsClient = p.logsClient ?? p.client;
         this.#transport = p.transport;
         this.#config = p.config;
         this.#keys = p.keys;
@@ -24494,6 +24650,71 @@ var init_launchpad = __esm({
         const text3 = await this.#folder.read("agent.json");
         return text3 === void 0 ? null : JSON.parse(text3);
       }
+      /**
+       * The agent's registration read from the chain when agent.json does not hold it: an identity its creator vault
+       * registered (the Identity Registry's Registered events from the deployment's first block) and still owns. A
+       * registration that landed after its call stopped (the relayer refused the send and a later operation sent the kept
+       * spend, or the process stopped before agent.json was written) is found here and written to agent.json, so the agent
+       * is never registered twice. An identity someone else registered and sent to the creator vault (an ERC-721 transfer
+       * the vault accepts) is no registration of this agent: with no Registered event of the vault, this is null. A
+       * registration sent again just now is read from its receipt instead (#recordFromReceipt), not from logs that may lag.
+       * The vault's identities are counted at the chain's head and the events read up to that same block, after the logs
+       * RPC has reached it: a registration the count holds is never missed because the logs RPC was behind (which would
+       * register the agent twice); when the logs RPC does not reach that block soon, this throws before anything is signed.
+       */
+      async #recoverAgentRecord() {
+        const vault = getAddress24(await this.#creator.vaultAddress());
+        const head = await this.#client.getBlockNumber({ cacheTime: 0 });
+        const owned = await this.#client.readContract({ address: ERC8004_IDENTITY_REGISTRY, abi: identityRegistryAbi, functionName: "balanceOf", args: [vault], blockNumber: head });
+        if (owned === 0n) return null;
+        for (let waited = 0; await this.#logsClient.getBlockNumber({ cacheTime: 0 }) < head; waited++) {
+          if (waited >= LOGS_CATCH_UP_SECONDS) throw new Error(`the logs RPC has not reached block ${head} of the chain RPC after ${LOGS_CATCH_UP_SECONDS} seconds, so the creator vault's ERC-8004 registration cannot be read yet: call again shortly; nothing was signed`);
+          await new Promise((r) => setTimeout(r, 1e3));
+        }
+        const logs = await getLogsChunked(this.#logsClient, { address: ERC8004_IDENTITY_REGISTRY, event: agentRegisteredEvent, args: { owner: vault }, fromBlock: BigInt(this.#config.deployment.fromBlock), toBlock: head });
+        for (const log2 of logs) {
+          const { agentId, agentURI } = log2.args;
+          const who = await readAgentIdentity(this.#client, agentId);
+          if (who === null || getAddress24(who.owner) !== vault) continue;
+          const record = { agentId: agentId.toString(), uri: agentURI, txHash: log2.transactionHash, at: Math.floor(Date.now() / 1e3) };
+          await this.#folder.write("agent.json", JSON.stringify(record, null, 2));
+          return record;
+        }
+        return null;
+      }
+      /**
+       * The registration transaction `txHash` of the creator vault, read from its receipt (the vault's AgentRegistered
+       * event) and written to agent.json; null when it registered nothing. The file it registered with is the Identity
+       * Registry's Registered event's agentURI in that receipt (a registration signed by an earlier call carries that
+       * call's file); `uri` only when the receipt has no such event.
+       */
+      async #recordFromReceipt(txHash, uri2) {
+        const vault = getAddress24(await this.#creator.vaultAddress());
+        const receipt = await this.#client.getTransactionReceipt({ hash: txHash });
+        let agentId;
+        for (const log2 of receipt.logs) {
+          if (getAddress24(log2.address) !== vault) continue;
+          try {
+            const e = decodeEventLog3({ abi: ostraVaultAbi, data: log2.data, topics: log2.topics });
+            if (e.eventName === "AgentRegistered") agentId = e.args.agentId.toString();
+          } catch {
+          }
+        }
+        if (agentId === void 0) return null;
+        let registered;
+        for (const log2 of receipt.logs) {
+          if (getAddress24(log2.address) !== getAddress24(ERC8004_IDENTITY_REGISTRY)) continue;
+          try {
+            const e = decodeEventLog3({ abi: [agentRegisteredEvent], data: log2.data, topics: log2.topics });
+            const a = e.args;
+            if (a.agentId.toString() === agentId && getAddress24(a.owner) === vault) registered = a.agentURI;
+          } catch {
+          }
+        }
+        const record = { agentId, uri: registered ?? uri2, txHash, at: Math.floor(Date.now() / 1e3) };
+        await this.#folder.write("agent.json", JSON.stringify(record, null, 2));
+        return record;
+      }
       /** The agent's identity: its creator vault, the profile URI it set and its ERC-8004 agent id; or, given `account`, that account's profile URI. */
       async profile(accountText) {
         const account = accountText === void 0 ? await this.#creator.vaultAddress() : address2(accountText, "account");
@@ -24510,32 +24731,21 @@ var init_launchpad = __esm({
       /** Registers the creator vault as an agent in the ERC-8004 Identity Registry, its registration file at `uri`; the vault owns the identity and is its agentWallet. */
       async registerAgent(uri2) {
         checkUri(uri2);
-        const vault = await this.#identityVault();
-        const existing = await this.#agentRecord();
-        if (existing !== null) throw new Error(`this agent is registered already as agent ${existing.agentId}: update it with set_agent_uri; nothing was signed`);
+        await this.#identityVault();
+        const existing = await this.#agentRecord() ?? await this.#recoverAgentRecord();
+        if (existing !== null) throw new Error(`this agent is registered already as agent ${existing.agentId}: publish_profile publishes its profile again; nothing was signed`);
         const r = await this.#simulatedSpend(this.#creator, this.#creatorSender, VAULT_ACTION.REGISTER_AGENT, registerAgentParams(uri2), "agent registration");
         if (r.status !== "sent") return r;
-        const receipt = await this.#client.getTransactionReceipt({ hash: r.txHash });
-        let agentId;
-        for (const log2 of receipt.logs) {
-          if (getAddress24(log2.address) !== vault) continue;
-          try {
-            const e = decodeEventLog3({ abi: ostraVaultAbi, data: log2.data, topics: log2.topics });
-            if (e.eventName === "AgentRegistered") agentId = e.args.agentId.toString();
-          } catch {
-          }
-        }
-        if (agentId === void 0) throw new Error(`the registration ${r.txHash} landed without an AgentRegistered event`);
-        const record = { agentId, uri: uri2, txHash: r.txHash, at: Math.floor(Date.now() / 1e3) };
-        await this.#folder.write("agent.json", JSON.stringify(record, null, 2));
-        return { ...r, agentId };
+        const record = await this.#recordFromReceipt(r.txHash, uri2);
+        if (record === null) throw new Error(`the registration ${r.txHash} landed without an AgentRegistered event`);
+        return { ...r, agentId: record.agentId };
       }
       /** Points the agent's ERC-8004 identity at a new registration file. */
       async setAgentUri(uri2) {
         checkUri(uri2);
         await this.#identityVault();
         const record = await this.#agentRecord();
-        if (record === null) throw new Error("this agent has no ERC-8004 identity yet: register_agent first; nothing was signed");
+        if (record === null) throw new Error("this agent has no ERC-8004 identity yet: publish_profile registers it; nothing was signed");
         const r = await this.#simulatedSpend(this.#creator, this.#creatorSender, VAULT_ACTION.SET_AGENT_URI, setAgentUriParams({ agentId: BigInt(record.agentId), uri: uri2 }), "agent registration file");
         if (r.status === "sent") await this.#folder.write("agent.json", JSON.stringify({ ...record, uri: uri2, at: Math.floor(Date.now() / 1e3) }, null, 2));
         return r;
@@ -24561,15 +24771,39 @@ var init_launchpad = __esm({
         if (version < VAULT_VERSION) throw new Error(`the creator vault ${s.vault} runs version ${version}, not ${VAULT_VERSION}; nothing was signed`);
       }
       /**
-       * Publishes the agent's profile: builds its ERC-8004 registration file (name, description, image, links, the
-       * creator vault as its agentWallet, its registration once it has one), pins it through the uploader, sets it in
-       * OstraRegistry, and points the ERC-8004 identity at it too when the agent is registered.
+       * Publishes the agent's Ostra profile, the same for every Ostra agent (profileFile: its name and number, Ostra's
+       * description, its Ostra card, its creator vault as agentWallet), and registers the agent in ERC-8004 when it is not
+       * registered yet: the profile without a number is published, the creator vault registers the agent with it, and the
+       * profile is published again with the agent's number and card, its ERC-8004 identity pointed at it. Called again, it
+       * carries on from where it stopped (what the chain and agent.json hold decides).
        */
-      async publishProfile(p) {
-        const vault = await this.#identityVault();
+      async publishProfile() {
+        const before = await this.#agentRecord() ?? await this.#recoverAgentRecord();
+        if (before !== null) return { agentId: before.agentId, registration: null, unnumbered: null, ...await this.#publishProfileFile(before) };
+        const first = await this.#publishProfileFile(null);
+        const unnumbered = { uri: first.uri, profile: first.profile };
+        if (first.profile.status !== "sent") {
+          const resent = first.profile.resent;
+          const landed = resent.operation === "vault_spend" && resent.action === VAULT_ACTION.REGISTER_AGENT ? await this.#recordFromReceipt(resent.txHash, first.uri) : null;
+          if (landed !== null) return { agentId: landed.agentId, registration: null, unnumbered, ...await this.#publishProfileFile(landed) };
+          const after = await this.#agentRecord() ?? await this.#recoverAgentRecord();
+          if (after !== null) return { agentId: after.agentId, registration: null, unnumbered, ...await this.#publishProfileFile(after) };
+        }
+        const registration = await this.registerAgent(first.uri);
         const record = await this.#agentRecord();
-        const file = profileFile({ ...p, vault, agentId: record?.agentId ?? null });
+        if (registration.status !== "sent" || record === null) return { agentId: null, registration, unnumbered, ...first };
+        return { agentId: record.agentId, registration, unnumbered, ...await this.#publishProfileFile(record) };
+      }
+      /**
+       * Builds the profile of the agent (`record`: its registration, or null before it has one), pins it through the
+       * uploader, sets it in OstraRegistry (for the creator vaults of the other pairs it launched from too), and points the
+       * ERC-8004 identity at it when the agent is registered.
+       */
+      async #publishProfileFile(record) {
+        const vault = await this.#identityVault();
+        const agentId = record?.agentId ?? null;
         uploaderUrl(this.#config.relayerUrl);
+        const file = profileFile({ vault, agentId, image: await agentCardUri(this.#config.relayerUrl, agentId) });
         const beforeUri = await this.#profileUri(vault);
         const before = await readIpfsJson(beforeUri);
         if (beforeUri !== null && beforeUri.startsWith("ipfs://") && before === null) throw new Error(`the profile published before (${beforeUri}) cannot be read now, so its Ostrapad listing could not be kept: try again later; nothing was signed`);
@@ -24927,7 +25161,7 @@ var init_pad2 = __esm({
       publish(offers) {
         return this.#serial(async () => {
           const { agentId, creatorVault } = await this.#p.identity();
-          if (agentId === null) throw new Error("this agent is not registered in ERC-8004 yet: publish_profile, then register_agent; nothing was signed");
+          if (agentId === null) throw new Error("this agent is not registered in ERC-8004 yet: publish_profile registers it; nothing was signed");
           const vault = await this.#vault();
           const current = await this.#p.currentFile();
           if (current === null) throw new Error("this agent has no published profile yet: publish_profile first; nothing was signed");
@@ -25843,7 +26077,7 @@ var init_raeto = __esm({
           await this.#keepApprovals((await this.#keptApprovals()).filter((h) => h !== hash));
           return { done: true, note };
         }
-        return { done: false, note: `${note}; the approval may still read or land: call raeto login again to withdraw it, or vault_approve_hash ${hash} approved false` };
+        return { done: false, note: `${note}; the approval may still read or land: call raeto login again to withdraw it, or vault_revoke_hash ${hash}` };
       }
       /**
        * Signs the vault in to Raeto as an agent (see the file comment): its own Raeto account and API key, kept here. With a
@@ -26024,10 +26258,10 @@ var init_raeto = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/abi.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/abi.ts
 var ostraRouterAbi, ostraStakeAbi, ostraPrivatePoolAbi, OSTRA_SWAP_ESCROW_CREATION_CODE, OSTRA_SHIELD_ESCROW_CREATION_CODE, ostraQuoteBatchAbi, OSTRA_QUOTE_BATCH_CREATION_CODE;
 var init_abi2 = __esm({
-  "../../ostra-swap/sdk/src/abi.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/abi.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     ostraRouterAbi = [
@@ -28892,10 +29126,10 @@ var init_abi2 = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/constants.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/constants.ts
 var LOG_WINDOW_BLOCKS2, USDG2, WETH2, HUBS, ETH, UNISWAP_V3_FACTORY, UNISWAP_V3_QUOTER_V2, V3_FEE_TIERS, UNISWAP_V4_POOL_MANAGER2, UNISWAP_V4_QUOTER, MULTICALL32, OSTRA_HOOK, PONS_HOOK2, ROUTABLE_HOOKS, FEE_TIERS, COMMAND, V4_ACTION, CONTRACT_BALANCE, MSG_SENDER, ADDRESS_THIS, OPEN_DELTA, QUOTE_GAS_LIMIT, QUOTES_PER_CALL, QUOTE_GAS_LIMIT_RETRY, QUOTES_PER_RETRY_CALL, QUOTE_BATCH_OVERHEAD_GAS, V3_MIN_SQRT_PRICE_LIMIT, V3_MAX_SQRT_PRICE_LIMIT, DEFAULT_SLIPPAGE_BPS, MAX_SLIPPAGE_BPS, DEFAULT_ORDER_TTL_SECONDS;
 var init_constants2 = __esm({
-  "../../ostra-swap/sdk/src/constants.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/constants.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     LOG_WINDOW_BLOCKS2 = 10000000n;
@@ -28937,11 +29171,11 @@ var init_constants2 = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/uniswap.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/uniswap.ts
 import { parseAbi as parseAbi7, parseAbiItem as parseAbiItem6 } from "viem";
 var v3FactoryAbi, v3PoolAbi, quoterV2Abi, poolKeyComponents, v4QuoterAbi, exactInputSingleParam, poolManagerAbi, initializeEvent, erc20Abi, multicall3Abi2;
 var init_uniswap = __esm({
-  "../../ostra-swap/sdk/src/uniswap.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/uniswap.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     v3FactoryAbi = parseAbi7(["function getPool(address tokenA, address tokenB, uint24 fee) view returns (address)"]);
@@ -29033,7 +29267,7 @@ var init_uniswap = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/legs.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/legs.ts
 import { concatHex, encodeAbiParameters as encodeAbiParameters10, encodePacked as encodePacked4, getAddress as getAddress28, toHex as toHex5 } from "viem";
 function legFor(pool, tokenIn, tokenOut, recipient = MSG_SENDER) {
   const inAddr = getAddress28(tokenIn);
@@ -29070,7 +29304,7 @@ function legFor(pool, tokenIn, tokenOut, recipient = MSG_SENDER) {
 }
 var NO_LEG, byte;
 var init_legs = __esm({
-  "../../ostra-swap/sdk/src/legs.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/legs.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_constants2();
@@ -29080,7 +29314,7 @@ var init_legs = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/pools.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/pools.ts
 import { encodeAbiParameters as encodeAbiParameters11, encodeFunctionData as encodeFunctionData12, decodeFunctionResult as decodeFunctionResult3, getAddress as getAddress29, hexToBigInt as hexToBigInt2, keccak256 as keccak25617, toHex as toHex6, zeroAddress as zeroAddress16 } from "viem";
 function stateSlot(id, offset) {
   const base = hexToBigInt2(keccak25617(encodeAbiParameters11([{ type: "bytes32" }, { type: "uint256" }], [id, POOLS_SLOT3])));
@@ -29143,7 +29377,7 @@ async function hubPools(client, logsClient, index, token, hub) {
 }
 var POOLS_SLOT3, LIQUIDITY_OFFSET2, PoolIndex;
 var init_pools2 = __esm({
-  "../../ostra-swap/sdk/src/pools.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/pools.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_constants2();
@@ -29189,7 +29423,7 @@ var init_pools2 = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/route.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/route.ts
 import { decodeAbiParameters as decodeAbiParameters5, decodeFunctionResult as decodeFunctionResult4, encodeDeployData as encodeDeployData2, encodeFunctionData as encodeFunctionData13, getAddress as getAddress30 } from "viem";
 function routedToken(token) {
   const t = getAddress30(token);
@@ -29313,7 +29547,7 @@ function routeLegs(route) {
 }
 var NoRouteError, quoteResults;
 var init_route = __esm({
-  "../../ostra-swap/sdk/src/route.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/route.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_abi2();
@@ -29339,7 +29573,7 @@ var init_route = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/orders.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/orders.ts
 import { encodeAbiParameters as encodeAbiParameters12, encodeFunctionData as encodeFunctionData14, getAddress as getAddress31, getContractAddress as getContractAddress4, isAddress as isAddress14, keccak256 as keccak25618, toHex as toHex7 } from "viem";
 function parseSwapDeployment(json) {
   const r = json;
@@ -29393,7 +29627,7 @@ function executeEscrowData(order, route) {
 }
 var ZERO, MAX_UINT32, MAX_UINT64, MAX_STANDING_ORDER_SECONDS, legParam, orderParam;
 var init_orders = __esm({
-  "../../ostra-swap/sdk/src/orders.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/orders.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_abi2();
@@ -29432,8 +29666,8 @@ var init_orders = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/private.ts
-import { encodeAbiParameters as encodeAbiParameters13, encodeFunctionData as encodeFunctionData15, getAbiItem, getAddress as getAddress32, getContractAddress as getContractAddress5, keccak256 as keccak25619, parseEventLogs, toHex as toHex8 } from "viem";
+// ../../../../../../srv/apps/ostra-swap/sdk/src/private.ts
+import { encodeAbiParameters as encodeAbiParameters13, encodeFunctionData as encodeFunctionData15, getAbiItem as getAbiItem2, getAddress as getAddress32, getContractAddress as getContractAddress5, keccak256 as keccak25619, parseEventLogs, toHex as toHex8 } from "viem";
 function packDigest(elements) {
   if (elements.length !== 8) throw new Error("a digest has 8 field elements");
   let v = 0n;
@@ -29632,7 +29866,7 @@ async function swapOutputNote(prover, sk, outRho, spend, swap, receipt, pool) {
 }
 var FIELD_P, TREE_DEPTH, PRIVATE_SWAP_FEE_BPS, UNSHIELD_DOMAIN, SWAP_DOMAIN, MAX_AMOUNT, MAX_UINT642, ZERO2, noteAddedEvent, PoolTrees;
 var init_private = __esm({
-  "../../ostra-swap/sdk/src/private.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/private.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_abi2();
@@ -29647,7 +29881,7 @@ var init_private = __esm({
     MAX_AMOUNT = 1n << 128n;
     MAX_UINT642 = (1n << 64n) - 1n;
     ZERO2 = "0x0000000000000000000000000000000000000000";
-    noteAddedEvent = getAbiItem({ abi: ostraPrivatePoolAbi, name: "NoteAdded" });
+    noteAddedEvent = getAbiItem2({ abi: ostraPrivatePoolAbi, name: "NoteAdded" });
     PoolTrees = class {
       #data;
       /** The sync running now: syncs run one at a time (each one's rollback assumes no other changes the trees). */
@@ -29748,19 +29982,19 @@ var init_private = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/reads.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/reads.ts
 import { getAddress as getAddress33 } from "viem";
 var init_reads2 = __esm({
-  "../../ostra-swap/sdk/src/reads.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/reads.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_abi2();
   }
 });
 
-// ../../ostra-swap/sdk/src/index.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/index.ts
 var init_src2 = __esm({
-  "../../ostra-swap/sdk/src/index.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/index.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_abi2();
@@ -31437,7 +31671,7 @@ var init_strategy2 = __esm({
           if (who !== null && getAddress37(who.owner) === creatorVault && getAddress37(who.wallet) === creatorVault) return { agentId: id.toString(), creatorVault };
         }
         throw new StrategyGateError(
-          `Ostra's strategies are for agents registered in the ERC-8004 Identity Registry through Ostra: the creator vault ${creatorVault} must own the agent's identity and be its agentWallet${ids.length === 0 ? " (it has none)" : ` (agent ${ids.map(String).join(", ")} is not)`}. Register with register_agent (after publish_profile), then ask again.`
+          `Ostra's strategies are for agents registered in the ERC-8004 Identity Registry through Ostra: the creator vault ${creatorVault} must own the agent's identity and be its agentWallet${ids.length === 0 ? " (it has none)" : ` (agent ${ids.map(String).join(", ")} is not)`}. Register with publish_profile (it registers the agent), then ask again.`
         );
       }
       // -------------------------------------------------------------------------------------------------------------------
@@ -32307,7 +32541,7 @@ var init_strategy2 = __esm({
 });
 
 // ../core/src/swap.ts
-import { decodeErrorResult as decodeErrorResult2, decodeEventLog as decodeEventLog4, getAbiItem as getAbiItem2, getAddress as getAddress38 } from "viem";
+import { decodeErrorResult as decodeErrorResult2, decodeEventLog as decodeEventLog4, getAbiItem as getAbiItem3, getAddress as getAddress38 } from "viem";
 function refusalOf(reason, outDecimals) {
   if (reason === "0x") return "the swap reverted without a reason (out of gas, or a revert with no data)";
   try {
@@ -32336,7 +32570,7 @@ function refusalOf(reason, outDecimals) {
     return `revert data ${reason.slice(0, 2 + 8 * 2)}${reason.length > 18 ? "\u2026" : ""} (not one of OstraRouter's errors: from a pool or the Universal Router)`;
   }
 }
-var SWAP_DIR, ESCROW_SWAP_GAS, DEFAULT_SWAP_SLIPPAGE_BPS, MAX_SWAP_SLIPPAGE_BPS, DEFAULT_SWAP_MAX_IMPACT_BPS, MAX_SWAP_MAX_IMPACT_BPS, SPLIT_MAX_PARTS, SPLIT_INTERVAL_SECONDS, SPLIT_SLACK_SECONDS, POOL_INDEX2, ORDER_PREFIX, SPLIT_PREFIX, address4, SwapService;
+var SWAP_DIR, ESCROW_SWAP_GAS, DEFAULT_SWAP_SLIPPAGE_BPS, MAX_SWAP_SLIPPAGE_BPS, DEFAULT_SWAP_MAX_IMPACT_BPS, MAX_SWAP_MAX_IMPACT_BPS, SPLIT_MAX_PARTS, SPLIT_INTERVAL_SECONDS, SPLIT_SLACK_SECONDS, POOL_INDEX2, ORDER_PREFIX, SPLIT_PREFIX, DONE_PREFIX, DONE_ORDERS_KEPT, address4, SwapService;
 var init_swap = __esm({
   "../core/src/swap.ts"() {
     "use strict";
@@ -32360,6 +32594,8 @@ var init_swap = __esm({
     POOL_INDEX2 = "pool-index.json";
     ORDER_PREFIX = "order-";
     SPLIT_PREFIX = "split-";
+    DONE_PREFIX = "done-";
+    DONE_ORDERS_KEPT = 100;
     address4 = (text3, what) => {
       if (!/^0x[0-9a-fA-F]{40}$/.test(text3)) throw new RangeError(`${what} is not an address`);
       return getAddress38(text3);
@@ -32572,7 +32808,23 @@ var init_swap = __esm({
             const escrow = escrowAddress(this.#p.swap.router, order);
             const execute = executeEscrowData(order, p.route);
             await p.from.checkSpend(VAULT_ACTION.TRANSFER, transferParams({ to: escrow, amount: p.amountIn }), "the swap's transfer to its escrow", this.#p.sender);
-            await this.#keep({ version: 1, hash: orderHash(order), escrow, tokenIn: p.tokenIn, amountIn: p.amountIn.toString(), vaultNonce: v.nonce.toString(), deadline: order.deadline.toString(), execute, at: Date.now() });
+            await this.#keep({
+              version: 1,
+              hash: orderHash(order),
+              escrow,
+              tokenIn: p.tokenIn,
+              amountIn: p.amountIn.toString(),
+              vaultNonce: v.nonce.toString(),
+              deadline: order.deadline.toString(),
+              execute,
+              at: Date.now(),
+              fromBlock: fromBlock.toString(),
+              tokenOut: p.tokenOut,
+              from: vault,
+              to: p.to,
+              inDecimals: p.inDecimals,
+              outDecimals: p.outDecimals
+            });
             await o.onOrder?.(orderHash(order), fromBlock, escrow);
             const signed = await signVaultTransfer(keychain, v, { chainId, to: escrow, amount: p.amountIn });
             const calls = [spendCall(vault, signed), { to: this.#p.swap.router, data: execute }];
@@ -32601,6 +32853,21 @@ var init_swap = __esm({
             note: `the swap landed in ${result.txHash}; what it paid could not be read now (${e.message.split("\n")[0]}): do not send it again, its order ${orderHash(placed2)} is read again later`
           };
         }
+        await this.#keepDone({
+          version: 1,
+          order: orderHash(placed2),
+          txHash: result.txHash,
+          swapped: outcome.swapped,
+          tokenIn: p.tokenIn,
+          tokenOut: p.tokenOut,
+          amountIn: formatUnitsAmount(p.amountIn, p.inDecimals),
+          amountOut: formatUnitsAmount(outcome.amountOut, p.outDecimals),
+          minOut: formatUnitsAmount(p.route.minOut, p.outDecimals),
+          from: p.fromVault,
+          to: p.to,
+          ...outcome.swapped ? {} : { refusal: outcome.why ?? "OstraRouter gave no reason" },
+          at: Date.now()
+        });
         await this.#p.folder.remove(`${ORDER_PREFIX}${orderHash(placed2)}.json`);
         return {
           status: "sent",
@@ -32891,7 +33158,7 @@ var init_swap = __esm({
        */
       async orderResult(order, fromBlock, escrow) {
         const toBlock = await this.#p.logsClient.getBlockNumber({ cacheTime: 0 });
-        const logs = await getLogsChunked(this.#p.logsClient, { address: this.#p.swap.router, event: getAbiItem2({ abi: ostraRouterAbi, name: "EscrowExecuted" }), args: { orderHash: order }, fromBlock, toBlock });
+        const logs = await getLogsChunked(this.#p.logsClient, { address: this.#p.swap.router, event: getAbiItem3({ abi: ostraRouterAbi, name: "EscrowExecuted" }), args: { orderHash: order }, fromBlock, toBlock });
         let spent = 0n;
         let received = 0n;
         let moved = false;
@@ -32937,6 +33204,92 @@ var init_swap = __esm({
         if (swapped) return { swapped, amountOut };
         return { swapped, amountOut: 0n, ...reason === null ? {} : { why: refusalOf(reason, outDecimals) } };
       }
+      /** Keeps a finished order for ostra_swap_orders, and drops the oldest beyond DONE_ORDERS_KEPT. */
+      async #keepDone(d) {
+        await this.#p.folder.ensure();
+        await this.#p.folder.write(`${DONE_PREFIX}${d.order.toLowerCase()}.json`, `${JSON.stringify(d)}
+`);
+        const names = (await this.#p.folder.list()).filter((n) => n.startsWith(DONE_PREFIX) && n.endsWith(".json"));
+        if (names.length <= DONE_ORDERS_KEPT) return;
+        const dated = [];
+        for (const n of names) {
+          const text3 = await this.#p.folder.read(n);
+          dated.push({ name: n, at: text3 === void 0 ? 0 : Number(JSON.parse(text3).at) });
+        }
+        dated.sort((a, b) => a.at - b.at);
+        for (const x of dated.slice(0, dated.length - DONE_ORDERS_KEPT)) await this.#p.folder.remove(x.name);
+      }
+      /**
+       * Keeps what a kept order did once the sweep finishes it: from the transaction that executed it (`tx`), else from
+       * OstraRouter's events from the record's block. Best effort: an order whose events cannot be read now is not kept
+       * (a record from before 0.1.12 has no block to search from).
+       */
+      async #doneFrom(r, tx) {
+        try {
+          let hash = tx;
+          if (hash === null && r.fromBlock !== void 0) {
+            const toBlock = await this.#p.logsClient.getBlockNumber({ cacheTime: 0 });
+            const logs = await getLogsChunked(this.#p.logsClient, { address: this.#p.swap.router, event: getAbiItem3({ abi: ostraRouterAbi, name: "EscrowExecuted" }), args: { orderHash: r.hash }, fromBlock: BigInt(r.fromBlock), toBlock });
+            const moved = logs.find((l) => l.args.received !== 0n);
+            hash = moved === void 0 ? null : moved.transactionHash;
+          }
+          if (hash === null) return;
+          const inDecimals = r.inDecimals ?? await tokenDecimals(this.#p.client, r.tokenIn);
+          const outDecimals = r.outDecimals ?? (r.tokenOut === void 0 ? 18 : await tokenDecimals(this.#p.client, r.tokenOut));
+          const o = await this.#outcome(hash, r.hash, outDecimals);
+          await this.#keepDone({
+            version: 1,
+            order: r.hash,
+            txHash: hash,
+            swapped: o.swapped,
+            tokenIn: r.tokenIn,
+            tokenOut: r.tokenOut ?? null,
+            amountIn: formatUnitsAmount(BigInt(r.amountIn), inDecimals),
+            amountOut: formatUnitsAmount(o.amountOut, outDecimals),
+            minOut: null,
+            from: r.from ?? null,
+            to: r.to ?? null,
+            ...o.swapped ? {} : { refusal: o.why ?? "OstraRouter gave no reason" },
+            at: Date.now()
+          });
+        } catch {
+        }
+      }
+      /**
+       * The agent's orders kept here: those not finished (signed or about to be, or landed and being finished; oldest
+       * first) and the finished ones (newest first, at most `limit`). With `order`, that order alone in either list.
+       */
+      async orders(o = {}) {
+        const want = o.order?.toLowerCase();
+        const open3 = [];
+        const finished = [];
+        for (const name of await this.#p.folder.list()) {
+          const isOrder = name.startsWith(ORDER_PREFIX);
+          if (!isOrder && !name.startsWith(DONE_PREFIX) || !name.endsWith(".json")) continue;
+          if (want !== void 0 && name.slice((isOrder ? ORDER_PREFIX : DONE_PREFIX).length, -".json".length).toLowerCase() !== want) continue;
+          const text3 = await this.#p.folder.read(name);
+          if (text3 === void 0) continue;
+          if (!isOrder) {
+            finished.push(JSON.parse(text3));
+            continue;
+          }
+          const r = JSON.parse(text3);
+          const inDecimals = r.inDecimals ?? await tokenDecimals(this.#p.client, r.tokenIn);
+          const x = { order: r.hash, tokenIn: r.tokenIn, tokenOut: r.tokenOut ?? null, amountIn: formatUnitsAmount(BigInt(r.amountIn), inDecimals), escrow: r.escrow, state: "open", at: r.at };
+          if (r.fromBlock !== void 0) {
+            const res = await this.orderResult(r.hash, BigInt(r.fromBlock), r.escrow);
+            if (res.spent > 0n || res.received > 0n) {
+              x.state = "landed";
+              x.spent = formatUnitsAmount(res.spent, inDecimals);
+              x.received = formatUnitsAmount(res.received, r.outDecimals ?? 18);
+            }
+          }
+          open3.push(x);
+        }
+        open3.sort((a, b) => a.at - b.at);
+        finished.sort((a, b) => b.at - a.at);
+        return { open: open3, finished: finished.slice(0, o.limit ?? 20) };
+      }
       /**
        * Finishes the orders whose escrow was paid without being executed (a signed spend sent again on its own):
        * executeEscrow sends the input along the order's route, or back to its vault past the deadline. Records of orders
@@ -32953,11 +33306,15 @@ var init_swap = __esm({
             const nonce = (await this.#p.vaultFor(r.tokenIn).state()).nonce;
             const held = await tokenBalance(this.#p.client, r.tokenIn, r.escrow);
             if (held >= BigInt(r.amountIn)) {
-              await this.#p.sender.send([{ to: this.#p.swap.router, data: r.execute }]);
+              const tx = await this.#p.sender.send([{ to: this.#p.swap.router, data: r.execute }]);
+              await this.#doneFrom(r, tx);
               await this.#p.folder.remove(name);
               continue;
             }
-            if (nonce !== null && nonce > BigInt(r.vaultNonce)) await this.#p.folder.remove(name);
+            if (nonce !== null && nonce > BigInt(r.vaultNonce)) {
+              await this.#doneFrom(r, null);
+              await this.#p.folder.remove(name);
+            }
           } catch (err) {
             failures.push({ order: r.hash, error: err instanceof Error ? err.message : String(err) });
           }
@@ -33821,7 +34178,7 @@ var init_backup_cli = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/cli-prover.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/cli-prover.ts
 import { spawn } from "node:child_process";
 function cliProver(binary, timeoutMs = PROVER_TIMEOUT_MS) {
   return (command, request) => new Promise((resolve, reject) => {
@@ -33862,14 +34219,14 @@ function cliProver(binary, timeoutMs = PROVER_TIMEOUT_MS) {
 }
 var PROVER_TIMEOUT_MS;
 var init_cli_prover = __esm({
-  "../../ostra-swap/sdk/src/cli-prover.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/cli-prover.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     PROVER_TIMEOUT_MS = 12e4;
   }
 });
 
-// ../../ostra-swap/sdk/src/wasm-prover.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/wasm-prover.ts
 import { bytesToHex as bytesToHex17 } from "viem";
 async function sha256Hex(bytes) {
   return bytesToHex17(new Uint8Array(await crypto.subtle.digest("SHA-256", bytes)));
@@ -33905,7 +34262,7 @@ async function wasmProver(glue, bytes, sha2564) {
 }
 var WasmProverTrapped, initialized, trapped;
 var init_wasm_prover = __esm({
-  "../../ostra-swap/sdk/src/wasm-prover.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/wasm-prover.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     WasmProverTrapped = class extends Error {
@@ -34026,11 +34383,19 @@ var init_agent = __esm({
         this.creator = new VaultService(client, transport, config, p.creatorKeys, creatorSender, "creator");
         this.creatorRelayer?.attachBuyerVault(this.creator);
         this.creatorChannels = new ChannelService(client, config, p.creatorKeys, this.creator, creatorSender);
-        this.launchpad = config.deployment.launchpad === void 0 ? null : new LaunchpadService({ client, transport, config, keys, buyer: this.buyer, buyerSender: this.sender, creator: this.creator, creatorSender });
+        this.launchpad = config.deployment.launchpad === void 0 ? null : new LaunchpadService({ client, transport, config, keys, buyer: this.buyer, buyerSender: this.sender, creator: this.creator, creatorSender, logsClient: createPublicClient2({ chain: robinhoodChain, transport: http2(config.logsRpcUrl, { retryCount: 6, retryDelay: 2e3 }) }) });
         this.shield = new ShieldService(client, config, keys, this.buyer, this.sender);
         this.creatorShield = new ShieldService(client, config, keys, this.creator, creatorSender);
         this.unshield = new UnshieldService(client, config, keys, this.shield, (index) => this.privateVault(index));
-        this.borro = new BorroService({ client, config, buyer: this.buyer, tokenVault: (token) => this.vaultFor(token), sender: this.sender, ownVaults: () => this.ownVaults() });
+        this.borro = new BorroService({
+          client,
+          config,
+          buyer: this.buyer,
+          tokenVault: (token) => this.vaultFor(token),
+          sender: this.sender,
+          ownVaults: () => this.ownVaults(),
+          logsClient: createPublicClient2({ chain: robinhoodChain, transport: http2(config.logsRpcUrl, { retryCount: 6, retryDelay: 2e3 }) })
+        });
         this.breaker = new BreakerService({ client, config, buyer: this.buyer, borro: this.borro, sender: this.sender, folder: keys.folder.folder("breaker") });
         this.raeto = config.raetoUrl === null ? null : new RaetoService({ client, buyer: this.buyer, borro: this.borro, folder: keys.folder.folder("raeto"), apiUrl: config.raetoUrl });
         if (config.swap === null) {
@@ -34325,6 +34690,12 @@ async function proverConfig(env) {
   }
   return { kind: "wasm", dir, sha256: sha2564 };
 }
+function swapAnswerMs(env) {
+  const v = env.OSTRA_SWAP_ANSWER_MS;
+  if (v === void 0 || v === "") return DEFAULT_SWAP_ANSWER_MS;
+  if (!/^[1-9][0-9]{0,5}$/.test(v) || Number(v) > 6e5) throw new Error("OSTRA_SWAP_ANSWER_MS is a whole number of milliseconds from 1 to 600000");
+  return Number(v);
+}
 function serviceUrl(env, name, fallback) {
   const value = env[name];
   if (value === void 0 || value === "") return fallback;
@@ -34374,6 +34745,7 @@ async function loadConfig(env = process.env) {
     swap,
     logsRpcUrl,
     privateLocalSpends: env.OSTRA_PRIVATE_LOCAL_SPENDS === "yes",
+    swapAnswerMs: swapAnswerMs(env),
     prover,
     chainId: deployment.chainId,
     rpcUrl: rpcUrl ?? ROBINHOOD_PUBLIC_RPC,
@@ -34385,7 +34757,7 @@ async function loadConfig(env = process.env) {
     aiUrl: serviceUrl(env, "OSTRA_AI_URL", services?.aiUrl ?? null)
   };
 }
-var PROVER_WASM_FILES, PAD_INDEXER_URL, ETHEREUM_PUBLIC_RPC;
+var PROVER_WASM_FILES, PAD_INDEXER_URL, ETHEREUM_PUBLIC_RPC, DEFAULT_SWAP_ANSWER_MS;
 var init_config2 = __esm({
   "src/config.ts"() {
     "use strict";
@@ -34398,10 +34770,12 @@ var init_config2 = __esm({
     PROVER_WASM_FILES = ["ostra_prove.js", "ostra_prove_bg.wasm"];
     PAD_INDEXER_URL = "https://app.ostraagent.xyz";
     ETHEREUM_PUBLIC_RPC = "https://ethereum-rpc.publicnode.com";
+    DEFAULT_SWAP_ANSWER_MS = 4e4;
   }
 });
 
 // src/tools.ts
+import { randomBytes as randomBytes6 } from "node:crypto";
 import { readFile as readFile6, stat as stat4, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join7 } from "node:path";
 import { z } from "zod";
@@ -34445,7 +34819,79 @@ function registerTools(server, agent) {
     return agent.privateBalance;
   };
   const opt = (key, value) => value === void 0 ? {} : { [key]: value };
-  const tool = (name, description, shape, fn) => CLOSED_LAUNCHPAD_TOOLS.has(name) ? void 0 : server.registerTool(name, { description, inputSchema: shape }, ((args) => run2(() => fn(args), [agent.config.rpcUrl, agent.config.logsRpcUrl, ...agent.config.ethRpcUrl === null ? [] : [agent.config.ethRpcUrl]])));
+  const rpcUrls2 = [agent.config.rpcUrl, agent.config.logsRpcUrl, ...agent.config.ethRpcUrl === null ? [] : [agent.config.ethRpcUrl]];
+  const tool = (name, description, shape, fn) => CLOSED_LAUNCHPAD_TOOLS.has(name) ? void 0 : server.registerTool(name, { description, inputSchema: shape }, ((args) => run2(() => fn(args), rpcUrls2)));
+  const answerMs = agent.config.swapAnswerMs;
+  const swaps = /* @__PURE__ */ new Map();
+  const swapView = (r) => ({
+    swap: r.id,
+    what: r.what,
+    tokenIn: r.tokenIn,
+    tokenOut: r.tokenOut,
+    amount: r.amount,
+    startedAt: new Date(r.startedAt).toISOString(),
+    state: r.endedAt === void 0 ? "running" : r.error === void 0 ? "ended" : "failed",
+    // False while its call still waits for it (a client that gave up on that call learns the result here).
+    answeredPending: r.answered,
+    ...r.order === void 0 ? {} : { order: r.order },
+    ...r.split === void 0 ? {} : { split: r.split },
+    ...r.endedAt === void 0 ? {} : { endedAt: new Date(r.endedAt).toISOString() },
+    ...r.result === void 0 ? {} : { result: r.result },
+    ...r.error === void 0 ? {} : { error: r.error }
+  });
+  const boundedSwap = async (a, start) => {
+    const busy = [...swaps.values()].find((x) => x.endedAt === void 0 && x.tokenIn.toLowerCase() === a.tokenIn.toLowerCase());
+    if (busy !== void 0) {
+      throw new Error(`a swap from the agent's vault of ${a.tokenIn} is still running (${busy.what} of ${busy.amount}, begun ${new Date(busy.startedAt).toISOString()}): nothing was signed for this call; ostra_swap_orders shows how that one ends, call again once it has`);
+    }
+    const r = { id: randomBytes6(8).toString("hex"), ...a, startedAt: Date.now(), answered: false };
+    swaps.set(r.id, r);
+    const work = Promise.resolve().then(() => start({
+      onOrder: async (order) => {
+        r.order = order;
+      },
+      onSplit: async (id) => {
+        r.split = id;
+      }
+    }));
+    let timer;
+    const late = new Promise((resolve) => {
+      timer = setTimeout(() => resolve(null), answerMs);
+    });
+    let first;
+    try {
+      first = await Promise.race([work.then((value) => ({ value })), late]);
+    } catch (err) {
+      swaps.delete(r.id);
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+    if (first !== null) {
+      swaps.delete(r.id);
+      return first.value;
+    }
+    r.answered = true;
+    work.then(
+      (value) => {
+        r.result = value;
+        r.endedAt = Date.now();
+      },
+      (err) => {
+        r.error = rpcUrls2.reduce((text3, url) => redact(text3, url), err instanceof Error ? err.message : String(err));
+        r.endedAt = Date.now();
+      }
+    );
+    const ended = [...swaps.values()].filter((x) => x.endedAt !== void 0).sort((x, y) => x.endedAt - y.endedAt);
+    for (const x of ended.slice(0, Math.max(0, ended.length - ENDED_SWAPS_KEPT))) swaps.delete(x.id);
+    return {
+      status: "pending",
+      swap: r.id,
+      order: r.order ?? null,
+      split: r.split ?? null,
+      note: `${a.what} is still running after ${answerMs / 1e3} s and goes on in the MCP server: do not send it again. ostra_swap_orders shows how it ends (swap ${r.id}${r.order === void 0 ? "" : `, order ${r.order}`}${r.split === void 0 ? "" : `; split swap ${r.split}: ostra_swap_split list`}).`
+    };
+  };
   tool("open_vault", "Creates the agent's vault (USDG on Robinhood Chain, post-quantum WOTS keys) or finds it. With the Ostra relayer, its creation is paid later from the vault.", {}, () => agent.buyer.open());
   tool("balance", "The vault's balance, nonce, any operation signed and not landed, the relayer channels, and the creator vault.", {}, async () => ({
     vault: await agent.buyer.status(),
@@ -34539,9 +34985,27 @@ function registerTools(server, agent) {
   );
   tool(
     "ostra_swap",
-    "Swaps on Ostra Swap from the agent's vault of tokenIn to its vault of tokenOut, as an escrow order of OstraRouter: the vault signs one transfer into the order's escrow and the relayer executes it in the same transaction. The router pays at least minOut or sends the input back; where the tokens go is fixed by the escrow's address. A swap that moves the price more than maxImpactBps (default 1%) is split into up to 16 parts 60 seconds apart, each its own escrow order quoted again right before it is signed: a part waits while it would move the price more than the limit or pay less than the first part's quote less the slippage. The first part runs now and the next ones while the MCP server runs (ostra_swap_split); what is not swapped by the deadline stays in the vault.",
+    `Swaps on Ostra Swap from the agent's vault of tokenIn to its vault of tokenOut, as an escrow order of OstraRouter: the vault signs one transfer into the order's escrow and the relayer executes it in the same transaction. The router pays at least minOut or sends the input back; where the tokens go is fixed by the escrow's address. A swap that moves the price more than maxImpactBps (default 1%) is split into up to 16 parts 60 seconds apart, each its own escrow order quoted again right before it is signed: a part waits while it would move the price more than the limit or pay less than the first part's quote less the slippage. The first part runs now and the next ones while the MCP server runs (ostra_swap_split); what is not swapped by the deadline stays in the vault. A swap not done within ${answerMs / 1e3} s answers status "pending" and goes on: do not send it again; ostra_swap_orders tells how it ended.`,
     { tokenIn: swapToken, tokenOut: swapToken, amount: units.describe("in tokenIn"), slippageBps: slippage2, maxImpactBps: maxImpact },
-    (a) => ostraSwap().swap({ tokenIn: tokenAddress(a.tokenIn), tokenOut: tokenAddress(a.tokenOut), amount: a.amount, ...opt("slippageBps", a.slippageBps), ...opt("maxImpactBps", a.maxImpactBps) })
+    (a) => {
+      const tokenIn = tokenAddress(a.tokenIn);
+      const tokenOut = tokenAddress(a.tokenOut);
+      return boundedSwap(
+        { what: "the swap", tokenIn, tokenOut, amount: a.amount },
+        (hooks) => ostraSwap().swap({ tokenIn, tokenOut, amount: a.amount, ...opt("slippageBps", a.slippageBps), ...opt("maxImpactBps", a.maxImpactBps) }, hooks)
+      );
+    }
+  );
+  tool(
+    "ostra_swap_orders",
+    "The agent's Ostra Swap orders: swaps of this MCP server still running (their call waiting, or answered pending) and those that answered pending and then ended or failed, orders kept and not finished (signed or about to be, or landed and being finished by the MCP server's sweep each minute), and the last finished ones with what they spent and paid (refusal: why one did not swap, its input back in the vault). order: that order alone. Nothing is signed.",
+    { order: bytes323.optional() },
+    async (a) => {
+      const kept = await ostraSwap().orders(a.order === void 0 ? {} : { order: a.order });
+      const want = a.order?.toLowerCase();
+      const pending = [...swaps.values()].filter((x) => want === void 0 || x.order?.toLowerCase() === want).sort((x, y) => y.startedAt - x.startedAt);
+      return { pending: pending.map(swapView), open: kept.open, finished: kept.finished };
+    }
   );
   tool(
     "ostra_swap_split",
@@ -34642,10 +35106,11 @@ function registerTools(server, agent) {
   );
   tool(
     "vault_lock",
-    "The withdrawal lock of the vault (USDG) or of the agent's vault of a Borro stock. status: the lock, the daily limit left, the linked vault and the changes waiting. set: turns the lock on or changes it (withdrawal: a wallet whose key is not on this device, or another seed's Ostra vault in the same token that is locked already; never one of this agent's vaults; delaySeconds 129600 to 1209600; dailyLimit in the vault's token): turning it on and tightening are at once, loosening waits the delay. off: turns it off after the delay. cancel: drops the changes still waiting.",
+    "The withdrawal lock of the vault (USDG) or of the agent's vault of a Borro stock. status: the lock, the daily limit left, the linked vault, the changes waiting, and the hashes the vault approves for EIP-1271 (approvals: each hash, from when it counts and whether that time has come; a hash can be a permit or a transfer authorization of the vault's funds; under the lock no flow of this server approves anything, so every hash listed then came from elsewhere and should go; without the lock the list also holds this server's own approvals, such as Ostrapad's, which look alike: vault_revoke_hash withdraws one, a guardian of a locked vault revokes it with guard_vault); with vault, the same for any Ostra vault (a guardian watching the vault it guards). set: turns the lock on or changes it (withdrawal: a wallet whose key is not on this device, or another seed's Ostra vault in the same token that is locked already; never one of this agent's vaults; delaySeconds 129600 to 1209600; dailyLimit in the vault's token): turning it on and tightening are at once, loosening waits the delay. off: turns it off after the delay. cancel: drops the changes still waiting.",
     {
       action: z.enum(["status", "set", "off", "cancel"]),
       asset: borroAsset.optional().describe("USDG (default) or a Borro stock's ticker"),
+      vault: address5.optional().describe("status only: another Ostra vault to read"),
       withdrawal: address5.optional(),
       delaySeconds: z.number().int().min(129600).max(1209600).optional(),
       dailyLimit: units.optional(),
@@ -34653,7 +35118,8 @@ function registerTools(server, agent) {
     },
     async (a) => {
       const asset = a.asset ?? "USDG";
-      if (a.action === "status") return agent.borro.guard(asset);
+      if (a.vault !== void 0 && a.action !== "status") throw new RangeError("vault is for status only: set, off and cancel act on this agent's own vaults");
+      if (a.action === "status") return agent.borro.lockStatus(asset, a.vault);
       if (a.action === "cancel") return agent.borro.cancelPending(asset);
       if (a.action === "off") return agent.borro.setLock(asset, "off", 0, "0");
       if (a.withdrawal === void 0 || a.delaySeconds === void 0 || a.dailyLimit === void 0) throw new RangeError("set takes withdrawal, delaySeconds and dailyLimit");
@@ -34677,10 +35143,10 @@ function registerTools(server, agent) {
     (a) => agent.borro.setLink(a.asset ?? "USDG", a.vault)
   );
   tool(
-    "vault_approve_hash",
-    "Approves a 32-byte hash for EIP-1271 on the vault (isValidSignature answers for it), or withdraws an approval. Under the lock an approval waits the lock's delay; a new lock and every recovery end all approvals.",
-    { hash: bytes323, approved: z.boolean() },
-    (a) => agent.borro.approveHash(a.hash, a.approved)
+    "vault_revoke_hash",
+    "Withdraws the EIP-1271 approval of a 32-byte hash by the vault (USDG) or by the agent's vault of a Borro stock (vault_lock status lists them); at once, under the lock too; lands as done when there is none. No tool approves a hash it is given: USDG takes the vault's EIP-1271 answer as a permit or a transfer authorization of its funds, so the vault only approves digests this server builds and checks itself (Raeto's login message, OstraBreaker's limits, Ostrapad's actions).",
+    { hash: bytes323, asset: borroAsset.optional().describe("USDG (default) or a Borro stock's ticker") },
+    (a) => agent.borro.withdrawApproval(a.asset ?? "USDG", a.hash)
   );
   tool(
     "guard_vault",
@@ -34706,7 +35172,7 @@ function registerTools(server, agent) {
   const earnings = z.record(z.string().regex(/^[A-Z]{1,8}$/), z.number().int().min(0)).optional().describe("earnings dates the agent knows, unix seconds by stock ticker (without one NVDA stays at most 60% of its LLTV)");
   tool(
     "strategy_plan",
-    "Plans what the agent's vaults hold, computed from the chain now: a conservative plan (USDG into a cash vault that passes every check of Strategy 1) and, when a carry of the agent's SPY, QQQ or NVDA may open, a balanced one (Strategy 2: the stock lent to Borro as collateral, USDG borrowed into the cash vault), each with its steps, gas, what it earns in 30 days net of gas, risks, when it stops, and whether OstraBreaker watches (Strategy 3). Every step earns over 3x its gas in 30 days or is left out. The trading capital's cash (trading) stays in the vault. Nothing is signed. Only for an agent registered in ERC-8004 (register_agent).",
+    "Plans what the agent's vaults hold, computed from the chain now: a conservative plan (USDG into a cash vault that passes every check of Strategy 1) and, when a carry of the agent's SPY, QQQ or NVDA may open, a balanced one (Strategy 2: the stock lent to Borro as collateral, USDG borrowed into the cash vault), each with its steps, gas, what it earns in 30 days net of gas, risks, when it stops, and whether OstraBreaker watches (Strategy 3). Every step earns over 3x its gas in 30 days or is left out. The trading capital's cash (trading) stays in the vault. Nothing is signed. Only for an agent registered in ERC-8004 (publish_profile).",
     { buffer: usdg.optional().describe("USDG kept for payments (default: what the vault spent over 7 days)"), earnings },
     (a) => agent.strategy.plan({
       ...a.buffer === void 0 ? {} : { buffer: parseUsdg(a.buffer) },
@@ -34728,7 +35194,7 @@ function registerTools(server, agent) {
   const bpsLimit = z.number().int().min(1).max(1e4).optional();
   tool(
     "trading",
-    `The trading capital: USDG of the vault set aside for trades the agent decides, with Ostra's limits (an agent may only tighten them): a position at most 25% of the capital (positionMaxBps) and no larger than a buy whose quote moves the price 1% (maxImpactBps); buys stop for the day after a 5% loss of the capital that day (dailyLossBps) and for the week after 10% that week (weeklyLossBps). set: sets it (capital in USDG, the limits), only with no position open; the plans keep its cash out of the cash vaults. status: its value now (cash, positions at the quote of selling them), whether buys may happen and, with token, the most that position may be. buy: buys token with amount USDG of the capital, refused past those limits. sell: sells amount (or "all") of the capital's token, split like any large swap. end: ends it (positions stay in their vaults, untracked). Trades go through Ostra Swap; only for an agent registered in ERC-8004 (register_agent) to set it or buy.`,
+    `The trading capital: USDG of the vault set aside for trades the agent decides, with Ostra's limits (an agent may only tighten them): a position at most 25% of the capital (positionMaxBps) and no larger than a buy whose quote moves the price 1% (maxImpactBps); buys stop for the day after a 5% loss of the capital that day (dailyLossBps) and for the week after 10% that week (weeklyLossBps). set: sets it (capital in USDG, the limits), only with no position open; the plans keep its cash out of the cash vaults. status: its value now (cash, positions at the quote of selling them), whether buys may happen and, with token, the most that position may be. buy: buys token with amount USDG of the capital, refused past those limits. sell: sells amount (or "all") of the capital's token, split like any large swap. A buy or sell not done in time (${agent.config.swapAnswerMs / 1e3} s) answers status "pending" and goes on: do not send it again; ostra_swap_orders tells how it ended. end: ends it (positions stay in their vaults, untracked). Trades go through Ostra Swap; only for an agent registered in ERC-8004 (publish_profile) to set it or buy.`,
     {
       action: z.enum(["set", "status", "buy", "sell", "end"]),
       capital: usdg.optional(),
@@ -34758,9 +35224,11 @@ function registerTools(server, agent) {
       const token = tokenAddress(a.token);
       if (a.action === "buy") {
         if (a.amount === "all") throw new RangeError("buy takes an amount of USDG");
-        return t.buy({ token, amount: a.amount, ...opt("slippageBps", a.slippageBps) });
+        const amount2 = a.amount;
+        return boundedSwap({ what: "the trading buy", tokenIn: USDG, tokenOut: token, amount: amount2 }, () => t.buy({ token, amount: amount2, ...opt("slippageBps", a.slippageBps) }));
       }
-      return t.sell({ token, amount: a.amount, ...opt("slippageBps", a.slippageBps) });
+      const amount = a.amount;
+      return boundedSwap({ what: "the trading sell", tokenIn: token, tokenOut: USDG, amount }, () => t.sell({ token, amount, ...opt("slippageBps", a.slippageBps) }));
     }
   );
   tool("strategy_report", "What the strategies earn: yield per day by route at the rates now, the share growth since the first run that held each cash vault, and each carry's distance to liquidation.", {}, () => agent.strategy.report());
@@ -34829,7 +35297,7 @@ function registerTools(server, agent) {
   const files = z.array(z.string().max(200).regex(/^ipfs:\/\/[A-Za-z0-9]+(\/[A-Za-z0-9._-]+)*$/)).max(10).optional().describe("ipfs:// files (upload_image makes one)");
   tool(
     "pad_publish",
-    "Ostrapad as a provider. publish: lists offers in the agent's ERC-8004 registration file, paid into its USDG vault (the vault approves the listing once, so a listing is its own); needs publish_profile and register_agent first, and USDG in the creator vault for its relayed transactions (checked before the approval). unpublish: removes the listing. status: the agent's own listing as clients read it. bond / withdraw_bond: a voluntary provider bond (raises the limit per job to the bond, up to 500 USDG; a rejected job costs it 10% of the budget plus the evaluator fee). return_bond_box: returns USDG left in the provider bond box (a deposit whose second step failed) to the USDG vault.",
+    "Ostrapad as a provider. publish: lists offers in the agent's ERC-8004 registration file, paid into its USDG vault (the vault approves the listing once, so a listing is its own); needs publish_profile first (it registers the agent), and USDG in the creator vault for its relayed transactions (checked before the approval). unpublish: removes the listing. status: the agent's own listing as clients read it. bond / withdraw_bond: a voluntary provider bond (raises the limit per job to the bond, up to 500 USDG; a rejected job costs it 10% of the budget plus the evaluator fee). return_bond_box: returns USDG left in the provider bond box (a deposit whose second step failed) to the USDG vault.",
     { action: z.enum(["publish", "unpublish", "status", "bond", "withdraw_bond", "return_bond_box"]), offers: z.array(offer).min(1).max(20).optional(), amount: usdg.optional() },
     async (a) => {
       if (a.action === "publish") {
@@ -34979,17 +35447,9 @@ function registerTools(server, agent) {
     (a) => lp().tokenInfo(a.token)
   );
   tool("profile", "The agent's public identity, its creator vault: the profile URI it set, that profile read from IPFS, and its ERC-8004 agent id; or another account's profile.", { account: address5.optional() }, (a) => lp().profile(a.account));
-  tool(
-    "set_profile",
-    "Sets the agent's profile in OstraRegistry from its creator vault, with a WOTS-signed spend: uri is an ipfs:// (or https://) JSON file with name, description, image and links, ideally an ERC-8004 registration file.",
-    { uri },
-    (a) => lp().setProfile(a.uri)
-  );
-  tool("register_agent", "Registers the agent in the ERC-8004 Identity Registry, once: its creator vault owns the identity and is its agentWallet; uri is its ERC-8004 registration file.", { uri }, (a) => lp().registerAgent(a.uri));
-  tool("set_agent_uri", "Points the agent's ERC-8004 identity at a new registration file.", { uri }, (a) => lp().setAgentUri(a.uri));
   tool(
     "upload_image",
-    `Pins an image file on this machine (PNG, JPEG, WebP or GIF, at most ${MAX_UPLOAD_IMAGE_BYTES} bytes) to IPFS through the Ostra uploader and returns its ipfs:// URI, for a profile or a token's metadata.`,
+    `Pins an image file on this machine (PNG, JPEG, WebP or GIF, at most ${MAX_UPLOAD_IMAGE_BYTES} bytes) to IPFS through the Ostra uploader and returns its ipfs:// URI, for the files of an Ostrapad order or delivery.`,
     { path: z.string().min(1).max(4096) },
     async (a) => {
       const s = await stat4(a.path);
@@ -34999,9 +35459,9 @@ function registerTools(server, agent) {
   );
   tool(
     "publish_profile",
-    "Publishes the agent's profile: builds its ERC-8004 registration file (name, description, image, links, its creator vault as agentWallet), pins it to IPFS, sets it in OstraRegistry and, once the agent is registered, points its ERC-8004 identity at it.",
-    { name: z.string().min(1).max(64), ...publicFields },
-    (a) => lp().publishProfile(a)
+    `Publishes the agent's Ostra profile and registers it in the ERC-8004 Identity Registry, with nothing to fill in: the same for every Ostra agent ("Ostra Agent #<id>", Ostra's description, the Ostra agent card as its image, its creator vault as agentWallet). The first call publishes the profile, registers the agent (its creator vault owns the identity) and publishes the profile again with the agent's number; a later call publishes it again (an Ostrapad listing in it is kept). Needs USDG in the creator vault (fund_creator_vault).`,
+    {},
+    () => lp().publishProfile()
   );
   tool(
     "publish_token_metadata",
@@ -35064,7 +35524,7 @@ function launchOptions(raw) {
   }
   return out;
 }
-var toJson, address5, usdg, units, pair2, slippage2, bytes323, maxImpact, swapToken, tokenAddress, uri, publicFields, AI_DIR, MAX_VIDEO_BYTES, FINAL_JOB, CLOSED_LAUNCHPAD_TOOLS, BIGINT_FIELDS, ALLOWED_OPTIONS;
+var toJson, address5, usdg, units, pair2, slippage2, bytes323, maxImpact, swapToken, tokenAddress, uri, publicFields, AI_DIR, MAX_VIDEO_BYTES, FINAL_JOB, CLOSED_LAUNCHPAD_TOOLS, ENDED_SWAPS_KEPT, BIGINT_FIELDS, ALLOWED_OPTIONS;
 var init_tools = __esm({
   "src/tools.ts"() {
     "use strict";
@@ -35117,6 +35577,7 @@ var init_tools = __esm({
       "airdrop_fund",
       "airdrop_start"
     ]);
+    ENDED_SWAPS_KEPT = 20;
     BIGINT_FIELDS = /* @__PURE__ */ new Set(["minDividendBalance", "maxBuy", "maxWallet", "graduationThreshold"]);
     ALLOWED_OPTIONS = /* @__PURE__ */ new Set([
       "tiers",