@ostraagent/mcp 0.1.10 → 0.1.12

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.10", 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.12", 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";
@@ -15521,6 +15529,7 @@ async function readBorroPosition(client, stockVault, stock2) {
     listed,
     supply: e.totalSupplyAssets,
     borrowed: e.totalBorrowAssets,
+    borrowedShares: e.totalBorrowShares,
     at: at.timestamp
   };
 }
@@ -15651,21 +15660,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));
         }
       }
     });
@@ -15682,7 +15724,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";
@@ -15699,6 +15741,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;
   }
 });
 
@@ -19872,6 +19918,7 @@ var init_browser = __esm({
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_abi();
+    init_agent_card();
     init_aggregator();
     init_airdrop();
     init_backup();
@@ -20248,6 +20295,10 @@ import { decodeFunctionData as decodeFunctionData4, getAddress as getAddress17,
 import { x402Client, x402HTTPClient } from "@x402/core/client";
 import { toClientEvmSigner } from "@x402/evm";
 import { BatchSettlementEvmScheme } from "@x402/evm/batch-settlement/client";
+function notLandedError(attempts, lastReason) {
+  const reason = lastReason.trim().slice(0, NOT_SENT_MESSAGE_MAX);
+  return new Error(`the relayer could not land the request in ${attempts} attempts${reason === "" ? "" : `; it answered last: ${reason}`}`);
+}
 function address(value, what) {
   if (typeof value !== "string" || !isAddress6(value, { strict: false })) throw new Error(`${what} is not an address`);
   return getAddress17(value);
@@ -20296,6 +20347,25 @@ function relayerChannelDeposit(needed, vaultBalance, keep = 0n) {
   const want = needed > RELAYER_CHANNEL_DEPOSIT ? needed : RELAYER_CHANNEL_DEPOSIT;
   return want < available ? want : available;
 }
+function relayerSpendPlan(p) {
+  const rooms = [...p.rooms];
+  let balance = p.balance;
+  let debt = p.debt;
+  for (const a of p.amounts) {
+    const i = debt > 0n ? -1 : rooms.findIndex((r) => r >= a);
+    if (i >= 0) {
+      rooms[i] = rooms[i] - a;
+      continue;
+    }
+    const needed = debt + p.openCost + a;
+    if (balance < needed) return false;
+    const deposit = relayerChannelDeposit(needed, balance);
+    balance -= deposit;
+    debt = 0n;
+    rooms.push(deposit - needed);
+  }
+  return true;
+}
 function relayerOfferProblem(r, want) {
   if (r.scheme !== "batch-settlement") return `the offer is ${r.scheme}, not batch-settlement`;
   if (r.network !== want.network) return `the offer is on ${r.network}, not ${want.network}`;
@@ -20330,7 +20400,7 @@ function openChannelCall(calls, vault, token) {
   }
   return null;
 }
-var RELAYER_DIR, VAULT_SPEND_GAS, REQUEST_TIMEOUT_MS2, MAX_STEPS, MAX_RESENDS, LANDED_TIMEOUT_MS, OPEN_READ_TRIES, OPEN_READ_INTERVAL_MS, BPS_DENOMINATOR, now, LocalSender, RelayerUnavailableError, PendingSpendUnpaidError, RelayerError, RelayerStore, RelayerClient;
+var RELAYER_DIR, VAULT_SPEND_GAS, REQUEST_TIMEOUT_MS2, MAX_STEPS, MAX_RESENDS, NOT_SENT_MESSAGE_MAX, LANDED_TIMEOUT_MS, OPEN_READ_TRIES, OPEN_READ_INTERVAL_MS, BPS_DENOMINATOR, now, LocalSender, RelayerUnavailableError, PendingSpendUnpaidError, RelayerError, RelayerStore, RelayerClient;
 var init_relay = __esm({
   "../core/src/relay.ts"() {
     "use strict";
@@ -20344,6 +20414,7 @@ var init_relay = __esm({
     REQUEST_TIMEOUT_MS2 = 24e4;
     MAX_STEPS = 8;
     MAX_RESENDS = 3;
+    NOT_SENT_MESSAGE_MAX = 500;
     LANDED_TIMEOUT_MS = 6e4;
     OPEN_READ_TRIES = 20;
     OPEN_READ_INTERVAL_MS = 500;
@@ -20381,9 +20452,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 {
@@ -20572,6 +20645,55 @@ var init_relay = __esm({
         }
         return null;
       }
+      /**
+       * Read only (nothing is retired, opened or signed): why this vault cannot pay, now, vault spends that reserve `gases`
+       * (each as VaultService.operate reserves it: reserve's amount for that gas), or null when it can. The spends are
+       * played in order as reserve and #ensureChannel would pay them: each from a usable relayer channel with room for it,
+       * or else from a new channel, whose open needs the vault's debt and the open's own spend (#spendBound) on top and
+       * takes RELAYER_CHANNEL_DEPOSIT or what it needs, at most what the vault holds. The vault's credit at the relayer is
+       * not counted: it lowers a price only after the reservation is made. An unpaid open the relayer holds for the vault
+       * is refused here (it is paid before anything else). An operation that sends something first (an approval before the
+       * call it allows) checks this before its first spend, so it does not leave the first done and the rest unpaid.
+       */
+      async shortfall(gases) {
+        const facts = await this.facts();
+        const vault = await this.#buyerVault().vaultAddress();
+        if (await readVault(this.#client, this.#config.deployment, vault) === null) return `the vault ${vault} does not exist yet`;
+        const state = await this.vaultState(vault);
+        if (state.unpaidOpen !== null) return `the relayer holds an unpaid open of the vault's relayer channel ${state.unpaidOpen.channel}: the vault's next relayed operation pays it first`;
+        const amounts = [];
+        for (const g of gases) amounts.push(await this.#reserveAmount(g));
+        const bound2 = await this.#spendBound();
+        const payer = await this.#payer();
+        const rooms = [];
+        for (const c of await this.#records()) {
+          if (c.retired || now() >= c.openedAt + SESSION_MAX_AGE_SECONDS) continue;
+          const free = this.#free(c, null);
+          if (free <= 0n) continue;
+          const ch = await readChannel(this.#client, this.#config.deployment.batchSettlement, c.channel);
+          const usable = payer !== null && getAddress17(c.config.payer) === payer && getAddress17(c.config.receiverAuthorizer) === facts.vault && getAddress17(c.config.receiver) === facts.split && ch.pendingWithdrawal === null;
+          const onChain = ch.balance - BigInt(c.cumulative);
+          if (usable) rooms.push(free < onChain ? free : onChain);
+        }
+        const balance = await tokenBalance(this.#client, this.#config.deployment.token, vault);
+        const plan = (held) => relayerSpendPlan({ amounts, rooms, balance: held, debt: state.debt, openCost: bound2 });
+        if (plan(balance)) return null;
+        let lo = balance;
+        let hi = balance > 0n ? balance * 2n : 1n;
+        while (!plan(hi)) hi *= 2n;
+        while (hi - lo > 1n) {
+          const mid = (lo + hi) / 2n;
+          if (plan(mid)) hi = mid;
+          else lo = mid;
+        }
+        const n = gases.length;
+        return `the vault ${vault} holds ${formatTokenAmount(balance)} USDG: ${n === 1 ? "its relayed transaction needs" : `its ${n} relayed transactions need`} it to hold ${formatTokenAmount(hi)} USDG now (with what its relayer channels have left, and a new channel's open where needed)`;
+      }
+      /** What reserve sets aside for a spend of `gas` (and `extraWei` of ETH it sends): the relayer's price for it, margin and tolerance included. */
+      async #reserveAmount(gas, extraWei = 0n) {
+        const wei = withMargin(gas * await this.#client.getGasPrice()) + extraWei;
+        return maxAcceptedQuote(weiToTokenUnits(wei, await this.#ethUsd(), TOKEN_DECIMALS));
+      }
       /** Base units a transaction of `wei` comes to at the Chainlink price, margin included (the relayer's rule). */
       async #amountFor(wei) {
         return weiToTokenUnits(withMargin(wei), await this.#ethUsd(), TOKEN_DECIMALS);
@@ -20610,8 +20732,7 @@ var init_relay = __esm({
         await (openChannel ?? ((t) => this.#buyerVault().openRelayerChannel(t)))(terms);
       }
       async reserve(gas, openChannel, keep = 0n, extraWei = 0n) {
-        const wei = withMargin(gas * await this.#client.getGasPrice()) + extraWei;
-        const amount = maxAcceptedQuote(weiToTokenUnits(wei, await this.#ethUsd(), TOKEN_DECIMALS));
+        const amount = await this.#reserveAmount(gas, extraWei);
         for (let attempt = 0; attempt < 2; attempt++) {
           const c = await this.#serial(async () => {
             const found = await this.#channelFor(amount, null);
@@ -20632,6 +20753,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);
@@ -20826,8 +20948,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;
@@ -20837,17 +20962,19 @@ 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") {
+              notSent = typeof b?.message === "string" ? b.message : "";
               again = true;
               continue;
             }
@@ -20866,7 +20993,7 @@ var init_relay = __esm({
           }
           if (!again) throw new Error(`the relayer did not relay the request after ${MAX_STEPS} answers`);
         }
-        throw new Error(`the relayer could not land the request in ${MAX_RESENDS} attempts`);
+        throw notLandedError(MAX_RESENDS, notSent);
       }
       /**
        * Relayer channels past SESSION_MAX_AGE_SECONDS stop paying; returns those
@@ -21388,10 +21515,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);
@@ -21403,10 +21534,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);
         }
@@ -21416,6 +21567,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
@@ -21645,7 +21815,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);
@@ -22035,6 +22209,21 @@ var init_borro2 = __esm({
         }
         return { buyerVault: buyer, usdgLent: { shares: usdg2.shares.toString(), value: formatUnitsAmount(usdg2.value, TOKEN_DECIMALS) }, stocks };
       }
+      /**
+       * Per Borro stock whose vault of this agent exists: its market, the stock vault's borrow shares, and the market's
+       * borrows and borrow shares accrued to this block, so that any number of borrow shares is valued now as
+       * toAssetsUp(shares, borrowed, borrowedShares) (what fundFromYield takes off as the debt's interest).
+       */
+      async debtBook() {
+        const out = [];
+        for (const s of borroStocks()) {
+          const v = await this.#p.tokenVault(s.token).vaultAddress();
+          if (await readVault(this.#p.client, this.#p.config.deployment, v) === null) continue;
+          const p = await readBorroPosition(this.#p.client, v, s);
+          out.push({ symbol: s.symbol, marketId: s.marketId, borrowShares: p.borrowShares, borrowed: p.borrowed, borrowedShares: p.borrowedShares });
+        }
+        return out;
+      }
       // -------------------------------------------------------------------------
       // Lend and redeem
       // -------------------------------------------------------------------------
@@ -23458,24 +23647,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) {
@@ -23514,6 +23696,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})`);
@@ -23521,13 +23706,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.";
   }
 });
 
@@ -23562,7 +23749,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, LaunchpadService;
+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 init_launchpad = __esm({
   "../core/src/launchpad.ts"() {
     "use strict";
@@ -23598,8 +23785,11 @@ var init_launchpad = __esm({
       volatility_fee: POOL_SETTING.VOLATILITY_FEE,
       max_tx_move: POOL_SETTING.MAX_TX_MOVE
     };
+    WOTS_GAS_SPREAD = 100000n;
+    STAND_IN_URI = `ipfs://bafkrei${"a".repeat(52)}`;
     LaunchpadService = class {
       #client;
+      #logsClient;
       #transport;
       #config;
       #keys;
@@ -23614,6 +23804,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;
@@ -24402,6 +24593,52 @@ 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.
+       */
+      async #recoverAgentRecord() {
+        const vault = getAddress24(await this.#creator.vaultAddress());
+        const owned = await this.#client.readContract({ address: ERC8004_IDENTITY_REGISTRY, abi: identityRegistryAbi, functionName: "balanceOf", args: [vault] });
+        if (owned === 0n) return null;
+        const to = await this.#logsClient.getBlockNumber({ cacheTime: 0 });
+        const logs = await getLogsChunked(this.#logsClient, { address: ERC8004_IDENTITY_REGISTRY, event: agentRegisteredEvent, args: { owner: vault }, fromBlock: BigInt(this.#config.deployment.fromBlock), toBlock: to });
+        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. `uri` is the file it registered with.
+       */
+      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;
+        const record = { agentId, uri: 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");
@@ -24418,32 +24655,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;
@@ -24469,15 +24695,38 @@ 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.status === "resent_pending" ? first.profile.resent : null;
+          const landed = resent !== null && resent.operation === "vault_spend" && resent.action === VAULT_ACTION.REGISTER_AGENT ? await this.#recordFromReceipt(resent.txHash, first.uri) : null;
+          if (landed === null) return { agentId: null, registration: null, unnumbered, ...first };
+          return { agentId: landed.agentId, registration: null, unnumbered, ...await this.#publishProfileFile(landed) };
+        }
+        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`);
@@ -24503,6 +24752,32 @@ var init_launchpad = __esm({
         if (profile.status !== "sent" || record === null) return { uri: uri2, profile, agentUri: null, pairCreators };
         return { uri: uri2, profile, agentUri: await this.setAgentUri(uri2), pairCreators };
       }
+      /**
+       * Read only: why the creator vault cannot pay for publishRegistrationFile now, or null when it can or does not pay
+       * through the relayer. Its spends (the profile and, once the agent is registered, its agent URI) are simulated as
+       * setProfile and setAgentUri send them, with the URI set now (or one of an ipfs:// URI's length) in place of the
+       * file's, and each is counted at the gas it will be reserved (simulatedGas) with WOTS_GAS_SPREAD added (a simulation
+       * signs with a throwaway key, and a WOTS signature's verification costs more or less with each message);
+       * RelayerClient.shortfall replays their payment. A
+       * spend the creator vault signed earlier and has not sent is refused here: its next operation would send that one
+       * instead of the profile.
+       */
+      async publishShortfall() {
+        if (!(this.#creatorSender instanceof RelayerClient)) return null;
+        const s = await this.#creator.state();
+        if (!s.exists) return `the creator vault ${s.vault} does not exist yet`;
+        if ((await this.#creator.spendSlot())?.pending != null) {
+          return `the creator vault ${s.vault} signed a spend earlier that has not landed: its next operation sends that one first (publish_profile with the same fields does), then publish again`;
+        }
+        const record = await this.#agentRecord();
+        const uri2 = record?.uri ?? await this.#profileUri(s.vault) ?? STAND_IN_URI;
+        const relayer = await this.#creatorSender.payer();
+        const gasOf = async (action, params) => simulatedGas((await simulateVaultSpend(this.#client, this.#config.deployment, { relayer, vault: s.vault, action, params })).gasUsed + WOTS_GAS_SPREAD);
+        const gases = [await gasOf(VAULT_ACTION.SET_PROFILE, setProfileParams(uri2))];
+        if (record !== null) gases.push(await gasOf(VAULT_ACTION.SET_AGENT_URI, setAgentUriParams({ agentId: BigInt(record.agentId), uri: uri2 })));
+        const short = await this.#creatorSender.shortfall(gases);
+        return short === null ? null : `${short}; fund_creator_vault moves USDG into it`;
+      }
       /**
        * Pins `file`, a registration file built from the current one (Ostrapad's listing, pad.ts), and makes it the
        * agent's profile in OstraRegistry and its ERC-8004 registration file when it is registered.
@@ -24809,7 +25084,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");
@@ -24818,7 +25093,11 @@ var init_pad2 = __esm({
           if (offers !== null) {
             const entry = padServiceEntry({ provider: vault, offers }, this.#pad, this.#p.config.chainId);
             const digest = padListingDigest(agentId, creatorVault, this.#pad, this.#p.config.chainId);
-            if (!await this.#approved(vault, digest)) approval = await this.#approveAlone(digest, "Ostrapad listing approval");
+            if (!await this.#approved(vault, digest)) {
+              const short = this.#p.publishShortfall === void 0 ? null : await this.#p.publishShortfall();
+              if (short !== null) throw new Error(`the creator vault could not publish the listing now, so its approval is not given: ${short}; nothing was signed`);
+              approval = await this.#approveAlone(digest, "Ostrapad listing approval");
+            }
             services.push(entry);
           }
           const out = await this.#p.publishFile({ ...current, services });
@@ -25542,6 +25821,19 @@ var init_pay = __esm({
 
 // ../core/src/raeto.ts
 import { getAddress as getAddress27, hashMessage, isAddress as isAddress13, parseAbi as parseAbi6 } from "viem";
+function netYieldSince(mark, now3, book) {
+  if (mark.debts === void 0) return null;
+  const high = BigInt(mark.price);
+  const earned = now3.price > high ? BigInt(mark.shares) * (now3.price - high) / now3.unit : 0n;
+  let interest = 0n;
+  for (const d of mark.debts) {
+    const m = book.find((b) => b.marketId.toLowerCase() === d.marketId.toLowerCase());
+    if (m === void 0) return null;
+    const owesNow = toAssetsUp(BigInt(d.borrowShares), m.borrowed, m.borrowedShares);
+    if (owesNow > BigInt(d.debt)) interest += owesNow - BigInt(d.debt);
+  }
+  return { earned, interest };
+}
 function raetoImages(answer) {
   const out = [];
   const choices = answer?.choices;
@@ -25788,15 +26080,20 @@ var init_raeto = __esm({
         return this.#scrub(await this.#call("POST", "/v1/chat/completions", request, await this.#key(), COMPLETION_TIMEOUT_MS));
       }
       /**
-       * What the vault's cash vault shares earn, as credits. Kept here: a mark (the shares, and the highest share price read:
-       * a high-water mark, so a price that falls and comes back earns nothing until it passes its high), what is owed (the
-       * shares of each mark times the rise of the price over its high, added on every call), and USDG redeemed for it and
-       * not sent yet (`ready`), with the vault's spend slot its transfer is signed at. A call adds what the shares earned
-       * since the mark, moves the mark to now, sends what was redeemed and not sent first, and else, when what is owed is at
-       * least `min` USDG, redeems that from the cash vault and sends what the redeem paid (at most what is owed) to Raeto's
-       * payTo. A transfer of `ready` that another operation of the vault sent first (it sends a signed spend before its
-       * own) is found at its slot and not paid again. Shares added or removed count from the read after; a full exit leaves
-       * what was owed until then. Raeto's terms are checked before anything is redeemed. Calls run one after the other.
+       * What the vault's cash vault shares earn, net of the agent's Borro debts' interest, as credits. Kept here: a mark
+       * (the shares, the highest share price read: a high-water mark, so a price that falls and comes back earns nothing
+       * until it passes its high; and each Borro debt's borrow shares with what they owed), what is owed (netYieldSince,
+       * added on every call: the shares' rise over the high less the interest the marked debts accrued; it can fall below
+       * zero, and nothing is sent until it is back above `min`), and USDG redeemed for it and not sent yet (`ready`), with
+       * the vault's spend slot its transfer is signed at. The interest comes off because the carry strategy borrows USDG
+       * from Borro into this same cash vault: the shares' rise is not earned while the loan behind them owes interest.
+       * A call adds what was earned since the mark, moves the mark to now, sends what was redeemed and not sent first, and
+       * else, when what is owed is at least `min` USDG, redeems that from the cash vault and sends what the redeem paid (at
+       * most what is owed) to Raeto's payTo. A transfer of `ready` that another operation of the vault sent first (it sends
+       * a signed spend before its own) is found at its slot and not paid again. Shares and debts added or removed count
+       * from the read after; a full exit leaves what was owed until then. A mark kept before debts were marked (MCP 0.1.10
+       * and earlier) earns nothing for the time since it, as that time's interest cannot be read back. Raeto's terms are
+       * checked before anything is redeemed. Calls run one after the other.
        */
       fundFromYield(min2 = "1") {
         return this.#serial(async () => {
@@ -25810,20 +26107,25 @@ var init_raeto = __esm({
             return { shares, unit, price };
           };
           const now3 = await read();
+          const book = await this.#p.borro.debtBook();
+          const debts = book.filter((b) => b.borrowShares > 0n).map((b) => ({ marketId: b.marketId, borrowShares: b.borrowShares.toString(), debt: toAssetsUp(b.borrowShares, b.borrowed, b.borrowedShares).toString() }));
           const text3 = await this.#p.folder.read(YIELD_FILE);
           const kept = text3 === void 0 ? null : JSON.parse(text3);
-          const usd4 = (x) => formatUnitsAmount(x, TOKEN_DECIMALS);
+          const usd4 = (x) => formatUnitsAmount(x > 0n ? x : 0n, TOKEN_DECIMALS);
           const write = (m) => this.#p.folder.write(YIELD_FILE, JSON.stringify(m));
           if (kept === null || getAddress27(kept.vault) !== target) {
-            await write({ vault: target, shares: now3.shares.toString(), price: now3.price.toString(), owed: "0", ready: "0" });
-            return { vault: target, owed: "0", sent: "0", note: "the mark is set now: what the shares earn from here is sent as credits by later calls" };
+            await write({ vault: target, shares: now3.shares.toString(), price: now3.price.toString(), owed: "0", ready: "0", debts });
+            return { vault: target, owed: "0", sent: "0", note: "the mark is set now: what the shares earn from here, less the Borro debts' interest, is sent as credits by later calls" };
           }
           const high = BigInt(kept.price);
-          let owed = BigInt(kept.owed) + (now3.price > high ? BigInt(kept.shares) * (now3.price - high) / now3.unit : 0n);
+          const net = netYieldSince(kept, now3, book);
+          let owed = BigInt(kept.owed) + (net === null ? 0n : net.earned - net.interest);
           let ready = BigInt(kept.ready);
-          const mark = { ...kept, vault: target, shares: now3.shares.toString(), price: (now3.price > high ? now3.price : high).toString(), owed: owed.toString(), ready: ready.toString() };
+          const mark = { ...kept, vault: target, shares: now3.shares.toString(), price: (now3.price > high ? now3.price : high).toString(), owed: owed.toString(), ready: ready.toString(), debts };
           await write(mark);
-          if (ready === 0n && (owed === 0n || owed < minimum)) return { vault: target, owed: usd4(owed), sent: "0", note: `under ${min2} USDG: kept for a later call` };
+          const unmarked = net === null ? "the mark did not follow the Borro debts yet (kept by an earlier version): nothing is counted for the time since it, and the mark now follows them; " : "";
+          if (ready === 0n && owed < 0n) return { vault: target, owed: "0", sent: "0", note: `${unmarked}the Borro debts' interest since the mark is more than the shares earned: ${formatUnitsAmount(-owed, TOKEN_DECIMALS)} USDG to make up before anything is sent` };
+          if (ready === 0n && (owed === 0n || owed < minimum)) return { vault: target, owed: usd4(owed), sent: "0", note: `${unmarked}under ${min2} USDG: kept for a later call` };
           const { payTo } = await this.terms();
           if (ready > 0n && mark.readySlot !== void 0) {
             const slot2 = { nonce: BigInt(mark.readySlot.nonce), keyIndex: BigInt(mark.readySlot.keyIndex) };
@@ -25859,7 +26161,7 @@ var init_raeto = __esm({
             ready = paid <= 0n ? 0n : paid < owed ? paid : owed;
             owed -= ready;
             const afterHigh = BigInt(mark.price) > after.price ? BigInt(mark.price) : after.price;
-            await write({ vault: target, shares: after.shares.toString(), price: afterHigh.toString(), owed: owed.toString(), ready: ready.toString() });
+            await write({ vault: target, shares: after.shares.toString(), price: afterHigh.toString(), owed: owed.toString(), ready: ready.toString(), debts });
             if (ready === 0n) return { vault: target, owed: usd4(owed), sent: "0", note: "the redeem paid nothing into the vault", redeem };
           }
           const slot = await this.#p.buyer.spendSlot();
@@ -25879,10 +26181,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 = [
@@ -28747,10 +29049,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;
@@ -28792,11 +29094,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)"]);
@@ -28888,7 +29190,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);
@@ -28925,7 +29227,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();
@@ -28935,7 +29237,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])));
@@ -28998,7 +29300,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();
@@ -29044,7 +29346,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);
@@ -29168,7 +29470,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();
@@ -29194,7 +29496,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;
@@ -29248,7 +29550,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();
@@ -29287,7 +29589,7 @@ var init_orders = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/private.ts
+// ../../../../../../srv/apps/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";
 function packDigest(elements) {
   if (elements.length !== 8) throw new Error("a digest has 8 field elements");
@@ -29487,7 +29789,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();
@@ -29603,19 +29905,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();
@@ -31292,7 +31594,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.`
         );
       }
       // -------------------------------------------------------------------------------------------------------------------
@@ -32191,7 +32493,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";
@@ -32215,6 +32517,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);
@@ -32427,7 +32731,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 }];
@@ -32456,6 +32776,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",
@@ -32792,6 +33127,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: getAbiItem2({ 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
@@ -32808,11 +33229,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) });
           }
@@ -33676,7 +34101,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) => {
@@ -33717,14 +34142,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)));
@@ -33760,7 +34185,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 {
@@ -33881,7 +34306,7 @@ 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));
@@ -33955,6 +34380,7 @@ var init_agent = __esm({
             return typeof p2.profile === "object" && p2.profile !== null && !Array.isArray(p2.profile) ? p2.profile : null;
           },
           publishFile: (file) => lp.publishRegistrationFile(file),
+          publishShortfall: () => lp.publishShortfall(),
           upload: (file) => uploadJson(config.relayerUrl, file),
           indexerUrl: config.padIndexerUrl
         });
@@ -34179,6 +34605,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;
@@ -34228,6 +34660,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,
@@ -34239,7 +34672,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";
@@ -34252,10 +34685,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";
@@ -34299,7 +34734,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(),
@@ -34393,9 +34900,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",
@@ -34560,7 +35085,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) },
@@ -34582,7 +35107,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(),
@@ -34612,9 +35137,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());
@@ -34624,7 +35151,7 @@ function registerTools(server, agent) {
   };
   tool(
     "raeto",
-    "Raeto (raeto.cc): 400+ AI models (text, and image models such as google/gemini-2.5-flash-image and openai/gpt-5-image-mini) through one OpenAI-compatible API, paid in Raeto credits of the vault's own Raeto account. login: signs the USDG vault in as an agent with EIP-1271 (the vault approves Raeto's login message, then withdraws the approval; refused under the withdrawal lock), its API key kept on this machine and never shown (name: the account's name; limitUsd: its spending limit). me: the account's credits. models: the models and prices per token (output: image for the image models). fund: sends `amount` USDG from the vault to Raeto, as credits. fund_yield: sends what the cash vault shares earned since the last call (at least `min`, default 1 USDG), redeemed then sent. complete: a model call, `request` in the OpenAI chat format with Raeto's model id (images it returns are saved as files in the agent's directory).",
+    "Raeto (raeto.cc): 400+ AI models (text, and image models such as google/gemini-2.5-flash-image and openai/gpt-5-image-mini) through one OpenAI-compatible API, paid in Raeto credits of the vault's own Raeto account. login: signs the USDG vault in as an agent with EIP-1271 (the vault approves Raeto's login message, then withdraws the approval; refused under the withdrawal lock), its API key kept on this machine and never shown (name: the account's name; limitUsd: its spending limit). me: the account's credits. models: the models and prices per token (output: image for the image models). fund: sends `amount` USDG from the vault to Raeto, as credits. fund_yield: sends what the cash vault shares earned since the last call, less the interest the agent's Borro loans accrued meanwhile (at least `min`, default 1 USDG), redeemed then sent. complete: a model call, `request` in the OpenAI chat format with Raeto's model id (images it returns are saved as files in the agent's directory).",
     {
       action: z.enum(["login", "me", "models", "fund", "fund_yield", "complete"]),
       name: z.string().min(1).max(64).optional(),
@@ -34683,7 +35210,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. 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") {
@@ -34833,17 +35360,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);
@@ -34853,9 +35372,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",
@@ -34918,7 +35437,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";
@@ -34971,6 +35490,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",