lyra-plugin-onchain 0.1.9 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lyra-plugin-onchain",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "type": "module",
   "description": "The Sui on-chain tools for Lyra: SUI transfers, DeepBook market data, Walrus receipts/memory — every write policy-checked, simulated, and recorded on-chain via lyra::policy",
   "license": "MIT",
@@ -37,7 +37,7 @@
     "@scallop-io/sui-scallop-sdk": "^2.4.5",
     "@suilend/sdk": "1.1.99",
     "@suilend/sui-fe": "0.3.49",
-    "lyra-core": "^0.1.2",
+    "lyra-core": "^0.1.10",
     "navi-sdk": "^1.7.3",
     "zod": "^3.23.8"
   }

package/src/index.ts

@@ -74,9 +74,21 @@ export {
 } from './policy'
 export { policyRequiresApprovalForCall } from './approval'
 export { deriveAgentKeypair, deriveAgentAddress } from './derive'
-export { resolveOwnerVault, type OwnerVault } from './vault'
+export {
+  resolveOwnerVault,
+  resolveVaultForAgent,
+  type OwnerVault,
+  type AgentVault,
+} from './vault'
 export { ONCHAIN_GUIDANCE } from './guidance'
 export type { OnchainRuntimeContext } from './types'
+export {
+  PROTOCOL_IDS,
+  PROTOCOL_LABELS,
+  ALLOWLISTABLE_PROTOCOLS,
+  NO_PROTOCOL,
+  type ProtocolKey,
+} from './protocol-ids'
 
 const plugin: NativePlugin = {
   name: 'onchain',

package/src/protocol-ids.ts

@@ -0,0 +1,48 @@
+/**
+ * Canonical on-chain protocol ids for the policy's protocol allowlist.
+ *
+ * When a tool draws from the vault via `vault_spend`, it tags the action with the
+ * protocol's package id. The owner's `allowed_protocols` allowlist (settable via
+ * `lyra::policy::set_allowed_protocols`) is checked against this tag on-chain — so
+ * an owner can restrict the agent to, say, only staking + NAVI. These ids are the
+ * SINGLE SOURCE OF TRUTH shared by the tools (which tag) and the console UI (which
+ * lets the owner toggle) so the two never drift.
+ *
+ * They are STABLE labels: a protocol upgrading its package doesn't change the tag
+ * (the tag is a self-reported label for the allowlist, not the call target), so an
+ * owner's allowlist keeps working across protocol upgrades. Sourced from each
+ * protocol's SDK on mainnet.
+ *
+ * `0x0` is the reserved "no specific protocol" tag used by transfers + swaps —
+ * always allowed by the policy (they're bounded by budget/cap/coin/recipient/
+ * slippage instead), so restricting protocols never blocks a plain transfer/swap.
+ */
+export const NO_PROTOCOL = '0x0'
+
+export const PROTOCOL_IDS = {
+  suiStaking: '0x3',
+  navi: '0x1e4a13a0494d5facdbe8473e74127b838c2d446ecec0ce262e2eddafa77259cb',
+  suilend: '0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf',
+  volo: '0x68d22cf8bdbcd11ecba1e094922873e4080d4d11133e2443fddda0bfd11dae20',
+  scallop: '0xde5c09ad171544aa3724dc67216668c80e754860f419136a68d78504eb2e2805',
+} as const
+
+export type ProtocolKey = keyof typeof PROTOCOL_IDS
+
+/** Human labels for each allowlistable protocol (for the owner UI + receipts). */
+export const PROTOCOL_LABELS: Record<string, string> = {
+  [PROTOCOL_IDS.suiStaking]: 'Sui staking',
+  [PROTOCOL_IDS.navi]: 'NAVI',
+  [PROTOCOL_IDS.suilend]: 'Suilend',
+  [PROTOCOL_IDS.volo]: 'Volo (vSUI)',
+  [PROTOCOL_IDS.scallop]: 'Scallop',
+}
+
+/** The allowlistable protocols in display order, for building the owner UI. */
+export const ALLOWLISTABLE_PROTOCOLS: { key: ProtocolKey; id: string; label: string }[] = [
+  { key: 'suiStaking', id: PROTOCOL_IDS.suiStaking, label: 'Sui staking' },
+  { key: 'navi', id: PROTOCOL_IDS.navi, label: 'NAVI' },
+  { key: 'suilend', id: PROTOCOL_IDS.suilend, label: 'Suilend' },
+  { key: 'volo', id: PROTOCOL_IDS.volo, label: 'Volo (vSUI)' },
+  { key: 'scallop', id: PROTOCOL_IDS.scallop, label: 'Scallop' },
+]

package/src/tools/liquid-stake.ts

@@ -16,8 +16,10 @@ import { stakeTovSuiPTB, unstakeTovSui } from 'navi-sdk'
 import { z } from 'zod'
 import { checkMinimum } from '../minimums'
 import { evaluatePolicy, suiToMist } from '../policy'
+import { PROTOCOL_IDS } from '../protocol-ids'
 import { simulate } from '../simulate'
 import type { OnchainRuntimeContext } from '../types'
+import { fundSui } from '../vault-fund'
 
 const SUI_TYPE = '0x2::sui::SUI'
 const VSUI_TYPE = '0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT'
@@ -61,7 +63,12 @@ export function makeVoloStake(ctx: OnchainRuntimeContext): ToolDef<StakeArgs> {
         }
 
         const tx = new Transaction()
-        const [suiCoin] = tx.splitCoins(tx.gas, [amountMist])
+        // Source the stake from the treasury vault (policy-enforced) when wired.
+        const suiCoin = fundSui(tx, ctx, amountMist, {
+          protocol: PROTOCOL_IDS.volo,
+          kind: 'stake',
+          memo: 'volo liquid stake',
+        })
         const vsui = await stakeTovSuiPTB(tx as never, suiCoin as never)
         tx.transferObjects([vsui as never], ctx.agentAddress)
 

package/src/tools/navi.ts

@@ -14,8 +14,10 @@ import { NAVISDKClient, borrowCoin, depositCoin, pool, repayDebt, withdrawCoin }
 import { z } from 'zod'
 import { checkMinimum } from '../minimums'
 import { evaluatePolicy, suiToMist } from '../policy'
+import { PROTOCOL_IDS } from '../protocol-ids'
 import { simulate } from '../simulate'
 import type { OnchainRuntimeContext } from '../types'
+import { fundSui, returnSuiToVault } from '../vault-fund'
 
 const SUI_TYPE = '0x2::sui::SUI'
 
@@ -142,20 +144,33 @@ async function runNaviWrite(
     const tx = new Transaction()
     const suiPool = (pool as Record<string, unknown>).Sui
     if (kind === 'supply') {
-      const [coin] = tx.splitCoins(tx.gas, [amountMist])
+      // Source the supply from the treasury vault (policy-enforced) when wired.
+      const coin = fundSui(tx, ctx, amountMist, {
+        protocol: PROTOCOL_IDS.navi,
+        kind: 'supply',
+        memo: 'navi supply',
+      })
       await depositCoin(tx as never, suiPool as never, coin as never, Number(amountMist))
     } else if (kind === 'withdraw') {
       // navi-sdk's withdrawCoin already wraps the withdrawn Balance into a Coin
-      // (via coin::from_balance) and returns [coin]; destructure and transfer it.
+      // (via coin::from_balance) and returns [coin]. Option 1: cycle it back into
+      // the vault (treasury stays intact); fall back to the agent when no vault.
       const [coin] = await withdrawCoin(tx as never, suiPool as never, Number(amountMist))
-      tx.transferObjects([coin as never], ctx.agentAddress)
+      if (!returnSuiToVault(tx, ctx, coin as never))
+        tx.transferObjects([coin as never], ctx.agentAddress)
     } else if (kind === 'borrow') {
-      // Borrow against supplied collateral; hand the borrowed coin to the agent.
+      // Borrow against supplied collateral; park the borrowed SUI in the vault
+      // (spendable under policy) when wired, else hand it to the agent.
       const [coin] = await borrowCoin(tx as never, suiPool as never, Number(amountMist))
-      tx.transferObjects([coin as never], ctx.agentAddress)
+      if (!returnSuiToVault(tx, ctx, coin as never))
+        tx.transferObjects([coin as never], ctx.agentAddress)
     } else {
-      // repay: split the repayment from gas and pay down the debt.
-      const [coin] = tx.splitCoins(tx.gas, [amountMist])
+      // repay: draw the repayment from the vault (policy-enforced) and pay the debt.
+      const coin = fundSui(tx, ctx, amountMist, {
+        protocol: PROTOCOL_IDS.navi,
+        kind: 'repay',
+        memo: 'navi repay',
+      })
       await repayDebt(tx as never, suiPool as never, coin as never, Number(amountMist))
     }
 

package/src/tools/scallop.ts

@@ -14,8 +14,10 @@ import type { ToolDef } from 'lyra-core'
 import { z } from 'zod'
 import { checkMinimum } from '../minimums'
 import { evaluatePolicy, suiToMist } from '../policy'
+import { PROTOCOL_IDS } from '../protocol-ids'
 import { simulate } from '../simulate'
 import type { OnchainRuntimeContext } from '../types'
+import { fundSui, returnSuiToVault } from '../vault-fund'
 
 const SUI_TYPE = '0x2::sui::SUI'
 
@@ -164,10 +166,18 @@ async function runScallopWrite(
     const builder = await sdk.createScallopBuilder()
     const tx = builder.createTxBlock()
     tx.setSender(ctx.agentAddress)
-    // depositQuick's 3rd arg returnSCoin=false keeps the old market-coin standard.
     let out: unknown
     if (kind === 'supply') {
-      out = await tx.depositQuick(Number(amountMist), 'sui', false)
+      // Source the deposit from the treasury vault (policy-enforced) when wired,
+      // then hand the vault-drawn Coin<SUI> to Scallop's non-quick `deposit` (the
+      // `*Quick` helpers auto-select the agent's own coins, so they can't be vault-
+      // funded). `deposit` returns the market coin, sent to the agent below.
+      const coin = fundSui(tx.txBlock as never, ctx, amountMist, {
+        protocol: PROTOCOL_IDS.scallop,
+        kind: 'supply',
+        memo: 'scallop supply',
+      })
+      out = await tx.deposit(coin as never, 'sui')
     } else {
       // withdrawQuick redeems a MARKET-COIN amount, not underlying SUI. Convert
       // the requested SUI to market coins at the position's rate and clamp to the
@@ -192,7 +202,12 @@ async function runScallopWrite(
       if (redeemMc > heldMc || redeemMc <= 0n) redeemMc = heldMc
       out = await tx.withdrawQuick(Number(redeemMc), 'sui')
     }
-    if (out) tx.transferObjects([out as never], ctx.agentAddress)
+    if (out) {
+      // Option 1: cycle withdrawn SUI back into the vault (treasury stays intact);
+      // supply's market coin and the no-vault case go to the agent.
+      const cycled = kind === 'withdraw' && returnSuiToVault(tx.txBlock as never, ctx, out as never)
+      if (!cycled) tx.transferObjects([out as never], ctx.agentAddress)
+    }
     const transaction = tx.txBlock
 
     const sim = await simulate(ctx.client, transaction, ctx.agentAddress)

package/src/tools/send.ts

@@ -15,6 +15,7 @@ import { checkMinimum } from '../minimums'
 import { evaluatePolicy, suiToMist } from '../policy'
 import { simulate } from '../simulate'
 import type { OnchainRuntimeContext } from '../types'
+import { canFundFromVault } from '../vault-fund'
 
 const SUI_TYPE = '0x2::sui::SUI'
 
@@ -55,26 +56,51 @@ export function makeSuiSend(ctx: OnchainRuntimeContext): ToolDef<Args> {
           }
         }
 
-        // 2. Build the PTB: split + transfer, plus on-chain receipt/enforcement.
+        // 2. Build the PTB.
         const tx = new Transaction()
-        const [coin] = tx.splitCoins(tx.gas, [amountMist])
-        tx.transferObjects([coin], to)
-        const recordsOnChain = Boolean(ctx.packageId && ctx.policyObjectId)
-        if (recordsOnChain) {
+        const vaultBacked = canFundFromVault(ctx, amountMist)
+        if (vaultBacked) {
+          // Vault-backed transfer: draw from the treasury via the full policy gate
+          // AND enforce the recipient allowlist ON-CHAIN (vault_transfer sends the
+          // funds to `to` and routes the ActionReceipt to the owner). A prompt-
+          // injected agent can't pay an un-allowlisted address even within budget.
           tx.moveCall({
-            target: `${ctx.packageId}::policy::record_action`,
+            target: `${ctx.packageId}::vault::vault_transfer`,
             typeArguments: [SUI_TYPE],
             arguments: [
+              tx.object(ctx.vaultId as string),
               tx.object(ctx.policyObjectId as string),
               tx.pure.u64(amountMist),
-              tx.pure.address('0x0'),
-              tx.pure.vector('u8', Array.from(new TextEncoder().encode('transfer'))),
-              tx.pure.vector('u8', Array.from(new TextEncoder().encode(`to ${to}`))),
+              tx.pure.address(to),
+              tx.pure.vector('u8', Array.from(new TextEncoder().encode('send transfer'))),
               tx.object.clock(),
             ],
           })
+        } else {
+          // Single-key mode (no vault wired): split from the agent's coin + transfer,
+          // plus an on-chain receipt when a policy object is configured.
+          const [coin] = tx.splitCoins(tx.gas, [amountMist])
+          tx.transferObjects([coin], to)
+          if (ctx.packageId && ctx.policyObjectId) {
+            tx.moveCall({
+              target: `${ctx.packageId}::policy::record_action`,
+              typeArguments: [SUI_TYPE],
+              arguments: [
+                tx.object(ctx.policyObjectId as string),
+                tx.pure.u64(amountMist),
+                tx.pure.address('0x0'),
+                tx.pure.vector('u8', Array.from(new TextEncoder().encode('transfer'))),
+                tx.pure.vector('u8', Array.from(new TextEncoder().encode(`to ${to}`))),
+                tx.object.clock(),
+              ],
+            })
+          }
         }
 
+        // Both paths enforce on-chain when configured: vault_transfer always mints
+        // a receipt; the gas path records only when a policy object is set.
+        const recordsOnChain = vaultBacked || Boolean(ctx.packageId && ctx.policyObjectId)
+
         // 3. Simulate-before-write.
         const sim = await simulate(ctx.client, tx, ctx.agentAddress)
         if (!sim.ok) {

package/src/tools/stake.ts

@@ -15,8 +15,10 @@ import type { ToolDef } from 'lyra-core'
 import { z } from 'zod'
 import { checkMinimum } from '../minimums'
 import { evaluatePolicy, suiToMist } from '../policy'
+import { PROTOCOL_IDS } from '../protocol-ids'
 import { simulate } from '../simulate'
 import type { OnchainRuntimeContext } from '../types'
+import { fundSui } from '../vault-fund'
 
 const SUI_TYPE = '0x2::sui::SUI'
 const SUI_SYSTEM_STATE = '0x5'
@@ -85,7 +87,13 @@ export function makeStake(ctx: OnchainRuntimeContext): ToolDef<StakeArgs> {
         if (!validator) return { ok: false, error: 'no active validator found to stake with' }
 
         const tx = new Transaction()
-        const [coin] = tx.splitCoins(tx.gas, [amountMist])
+        // Source the stake from the treasury vault (policy-enforced) when one is
+        // wired; otherwise from the agent's gas coin (single-key mode).
+        const coin = fundSui(tx, ctx, amountMist, {
+          protocol: PROTOCOL_IDS.suiStaking,
+          kind: 'stake',
+          memo: `stake ${args.amount} SUI`,
+        })
         tx.moveCall({
           target: '0x3::sui_system::request_add_stake',
           arguments: [tx.object(SUI_SYSTEM_STATE), coin, tx.pure.address(validator.address)],

package/src/tools/suilend.ts

@@ -20,18 +20,22 @@
  */
 
 import { Transaction } from '@mysten/sui/transactions'
-import {
-  LENDING_MARKET_ID,
-  LENDING_MARKET_TYPE,
-  SuilendClient,
-  initializeSuilend,
-} from '@suilend/sdk'
+// Import from @suilend/sdk SUBPATHS, not the package index. The index re-exports
+// strategies.js → @suilend/springsui-sdk, whose ESM does a directory import
+// (`import './lib'`) that Node's ESM resolver rejects — which would break
+// importing this plugin under Node (the Next.js web server; Bun tolerates it).
+// The lending client + initialize subpaths don't pull springsui and load cleanly
+// on both runtimes, so Suilend works on the web AND the CLI.
+import { LENDING_MARKET_ID, LENDING_MARKET_TYPE, SuilendClient } from '@suilend/sdk/client'
+import { initializeSuilend } from '@suilend/sdk/lib/initialize'
 import type { ToolDef } from 'lyra-core'
 import { z } from 'zod'
 import { checkMinimum } from '../minimums'
 import { evaluatePolicy, suiToMist } from '../policy'
+import { PROTOCOL_IDS } from '../protocol-ids'
 import { simulate } from '../simulate'
 import type { OnchainRuntimeContext } from '../types'
+import { fundSui } from '../vault-fund'
 
 const SUI_TYPE = '0x2::sui::SUI'
 // Canonical + long-form SUI coin types (reserve maps may use either).
@@ -156,7 +160,12 @@ export function makeSuilendSupply(ctx: OnchainRuntimeContext): ToolDef<AmountArg
         const existing = await findObligation(ctx)
         const tx = new Transaction()
         tx.setSender(ctx.agentAddress)
-        const [coin] = tx.splitCoins(tx.gas, [amountMist])
+        // Source the supply from the treasury vault (policy-enforced) when wired.
+        const coin = fundSui(tx, ctx, amountMist, {
+          protocol: PROTOCOL_IDS.suilend,
+          kind: 'supply',
+          memo: 'suilend supply',
+        })
         // The @suilend/sdk@1.1.x SDK carries its own nested @mysten/sui copy, so
         // TS sees a distinct Transaction class — cast at the boundary. The two
         // copies interop at runtime (verified with a live mainnet dry-run).

package/src/tools/swap.ts

@@ -17,6 +17,7 @@ import { checkMinimum } from '../minimums'
 import { evaluatePolicy } from '../policy'
 import { simulate } from '../simulate'
 import type { OnchainRuntimeContext } from '../types'
+import { fundSui } from '../vault-fund'
 
 const SUI_TYPE = '0x2::sui::SUI'
 
@@ -119,9 +120,16 @@ export function makeSwap(ctx: OnchainRuntimeContext): ToolDef<Args> {
           tx.setSender(me)
           tx.setGasBudget(150_000_000)
           try {
+            // SUI input is sourced from the treasury vault (policy-enforced) when
+            // wired; non-SUI input comes from the agent's own balance (the vault
+            // is SUI-typed). The swapped output goes to the agent.
             const coinIn =
               from.type === SUI_TYPE
-                ? tx.splitCoins(tx.gas, [amountIn])[0]
+                ? fundSui(tx, ctx, amountIn, {
+                    protocol: '0x0',
+                    kind: 'swap',
+                    memo: `swap to ${args.to}`,
+                  })
                 : coinWithBalance({ type: from.type, balance: amountIn })
             const coinOut = await ag.swap({ quote: q, signer: me, tx, coinIn: coinIn as never })
             tx.transferObjects([coinOut as never], me)

package/src/types.ts

@@ -23,6 +23,27 @@ export interface OnchainRuntimeContext {
   packageId?: string
   /** Shared `AgentPolicy` object id. When set, writes compose an on-chain receipt + enforcement. */
   policyObjectId?: string
+  /**
+   * Treasury `Vault<SUI>` object id bound to `policyObjectId`. When set (together
+   * with `policyObjectId` + `packageId`), write tools source their SUI from the
+   * vault via the policy-gated `vault_spend` instead of the agent's gas coin — so
+   * the vault is the single fund source and every deployment is enforced on-chain.
+   * When unset, tools fall back to the agent's own SUI (single-key mode).
+   */
+  vaultId?: string
+  /**
+   * The vault/policy owner address. Audit `ActionReceipt`s from `vault_spend` are
+   * sent here (falls back to the agent when unset). The owner also receives any
+   * funds swept back to the treasury.
+   */
+  ownerAddress?: string
+  /**
+   * Snapshot of the vault's SUI balance (MIST, as a string) at ctx-build time.
+   * A funding heuristic: when the vault can't cover an action, tools fall back to
+   * the agent's own SUI so the action still works (the on-chain `vault_spend` is
+   * the authoritative gate). Absent/`"0"` ⇒ always fall back.
+   */
+  vaultMist?: string
   /** Walrus network for receipt/memory storage (defaults to `network`). */
   walrusNetwork?: SuiNetwork
   agentDir: string

package/src/vault-fund.ts

@@ -0,0 +1,107 @@
+/**
+ * Vault-funded actions. Lyra's treasury `lyra::vault::Vault<SUI>` is the SINGLE
+ * fund source for agent actions: instead of splitting the agent's own gas coin,
+ * a write tool draws SUI from the owner's vault via the policy-gated `vault_spend`
+ * (the agent signs; `enforce_spend` re-checks budget, per-tx cap, coin/protocol
+ * allowlists, expiry, and revoke ON-CHAIN). Idle funds stay in the vault, and the
+ * treasury is topped back up on withdrawal (Option 1: funds cycle vault→protocol→
+ * vault, so the treasury doesn't drain as the agent works).
+ *
+ * All helpers degrade gracefully: with no vault configured in the runtime ctx,
+ * `fundSui` falls back to the agent's gas coin — so single-key mode (e.g. the CLI
+ * with no provisioned vault) keeps working unchanged.
+ */
+
+import type { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions'
+import type { OnchainRuntimeContext } from './types'
+
+const SUI_TYPE = '0x2::sui::SUI'
+const CLOCK = '0x6'
+
+/** True when the ctx carries a fully-wired treasury vault (vault + policy + package). */
+export function hasVault(ctx: OnchainRuntimeContext): boolean {
+  return Boolean(ctx.vaultId && ctx.policyObjectId && ctx.packageId)
+}
+
+/**
+ * True when the wired vault can cover `amountMist` (per its balance snapshot).
+ * When false, callers fund from the agent's own SUI so the action still works —
+ * e.g. the user provisioned a vault but funded the agent directly, or the vault
+ * is short for this action. The on-chain `vault_spend` remains the hard gate.
+ */
+export function canFundFromVault(ctx: OnchainRuntimeContext, amountMist: bigint): boolean {
+  if (!hasVault(ctx)) return false
+  return BigInt(ctx.vaultMist ?? '0') >= amountMist
+}
+
+function enc(tx: Transaction, s: string) {
+  return tx.pure.vector('u8', Array.from(new TextEncoder().encode(s)))
+}
+
+export interface FundOpts {
+  /**
+   * Protocol package/registry id checked against the policy's protocol allowlist.
+   * Pass the protocol's package id (e.g. NAVI, Scallop) so an owner-set allowlist
+   * gates it meaningfully; `0x0` when the action isn't protocol-scoped (a plain
+   * transfer). Defaults to `0x0`.
+   */
+  protocol?: string
+  /** Short action kind for the on-chain receipt (e.g. `stake`, `supply`, `swap`). */
+  kind: string
+  /** Human memo for the on-chain receipt. */
+  memo: string
+}
+
+/**
+ * Source `amountMist` of SUI for an in-PTB action. When a vault is wired, draws
+ * from it via `vault_spend` (policy-enforced) and routes the audit `ActionReceipt`
+ * to the owner; otherwise splits the agent's gas coin. Returns the `Coin<SUI>` to
+ * feed into the protocol call in the SAME transaction.
+ */
+export function fundSui(
+  tx: Transaction,
+  ctx: OnchainRuntimeContext,
+  amountMist: bigint,
+  opts: FundOpts,
+): TransactionObjectArgument {
+  if (canFundFromVault(ctx, amountMist)) {
+    const [coin, receipt] = tx.moveCall({
+      target: `${ctx.packageId}::vault::vault_spend`,
+      typeArguments: [SUI_TYPE],
+      arguments: [
+        tx.object(ctx.vaultId as string),
+        tx.object(ctx.policyObjectId as string),
+        tx.pure.u64(amountMist),
+        tx.pure.address(opts.protocol ?? '0x0'),
+        enc(tx, opts.kind),
+        enc(tx, opts.memo),
+        tx.object(CLOCK),
+      ],
+    })
+    // The receipt is an on-chain audit object (key+store); park it with the owner
+    // (or the agent when the owner is unknown) so the PTB has no dangling value.
+    tx.transferObjects([receipt as TransactionObjectArgument], ctx.ownerAddress ?? ctx.agentAddress)
+    return coin as TransactionObjectArgument
+  }
+  const [coin] = tx.splitCoins(tx.gas, [amountMist])
+  return coin as TransactionObjectArgument
+}
+
+/**
+ * Return a `Coin<SUI>` to the treasury vault (Option 1: withdrawals/unstakes cycle
+ * back into the vault instead of accumulating on the agent). No-op-returns `false`
+ * when no vault is wired, so the caller can transfer the coin to the agent instead.
+ */
+export function returnSuiToVault(
+  tx: Transaction,
+  ctx: OnchainRuntimeContext,
+  coin: TransactionObjectArgument,
+): boolean {
+  if (!ctx.vaultId || !ctx.packageId) return false
+  tx.moveCall({
+    target: `${ctx.packageId}::vault::deposit`,
+    typeArguments: [SUI_TYPE],
+    arguments: [tx.object(ctx.vaultId), coin],
+  })
+  return true
+}

package/src/vault.ts

@@ -22,6 +22,70 @@ export interface OwnerVault {
   vaultMist: string
 }
 
+export interface AgentVault {
+  policyId: string
+  vaultId: string
+  owner: string
+  vaultMist: string
+}
+
+/**
+ * Resolve the treasury vault for a delegated `agentAddress` WITHOUT knowing the
+ * owner — the CLI/gateway single-tenant path (the running agent knows only its own
+ * address). Finds the `AgentPolicy` delegating to this agent via `PolicyCreated`
+ * events, then its `Vault` via `VaultOpened`. Returns null when the agent has no
+ * (unrevoked) policy+vault, so the tools fall back to the agent's own SUI.
+ */
+export async function resolveVaultForAgent(
+  agentAddress: string,
+  network: SuiNetwork = 'mainnet',
+): Promise<AgentVault | null> {
+  const client = makeSuiClient(network)
+  const created = await client
+    .queryEvents({
+      query: { MoveEventType: `${ORIGINAL_PKG}::policy::PolicyCreated` },
+      limit: 200,
+      order: 'descending',
+    })
+    .catch(() => null)
+  if (!created) return null
+
+  for (const e of created.data) {
+    // biome-ignore lint/suspicious/noExplicitAny: parsed Move event
+    const f = e.parsedJson as any
+    if (f?.agent !== agentAddress) continue
+    const policyId = f.policy_id as string | undefined
+    const owner = f.owner as string | undefined
+    if (!policyId || !owner) continue
+    const pol = await client
+      .getObject({ id: policyId, options: { showContent: true } })
+      .catch(() => null)
+    // biome-ignore lint/suspicious/noExplicitAny: dynamic Move object fields
+    const pf = (pol?.data?.content as any)?.fields
+    if (!pf || pf.revoked) continue
+
+    const ev = await client
+      .queryEvents({
+        query: { MoveEventType: `${VAULT_PKG}::vault::VaultOpened` },
+        limit: 200,
+        order: 'descending',
+      })
+      .catch(() => null)
+    // biome-ignore lint/suspicious/noExplicitAny: parsed Move event
+    const match = ev?.data.find(x => (x.parsedJson as any)?.policy_id === policyId)
+    // biome-ignore lint/suspicious/noExplicitAny: parsed Move event
+    const vaultId = (match?.parsedJson as any)?.vault_id as string | undefined
+    if (!vaultId) continue
+    const v = await client
+      .getObject({ id: vaultId, options: { showContent: true } })
+      .catch(() => null)
+    // biome-ignore lint/suspicious/noExplicitAny: dynamic Move object fields
+    const vaultMist = String((v?.data?.content as any)?.fields?.balance ?? '0')
+    return { policyId, vaultId, owner, vaultMist }
+  }
+  return null
+}
+
 /** Find the owner's policy (delegating to their derived agent) + its SUI vault. */
 export async function resolveOwnerVault(
   owner: string,

package/src/derive.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { deriveAgentAddress, deriveAgentKeypair } from './derive'
-
-const MASTER = 'a'.repeat(64)
-const A = '0x46e37419c58981bb69100fa559baa52fd7e219486d75e9dc3f0896fab01d06f5'
-const B = '0x250880a4c1a268da8011b164f599d4e100cefce84f862d36396cd1a943ee8a35'
-
-describe('agent derivation', () => {
-  it('is deterministic for the same owner + master', () => {
-    expect(deriveAgentAddress(A, MASTER)).toBe(deriveAgentAddress(A, MASTER))
-  })
-
-  it('gives distinct agents for distinct owners', () => {
-    expect(deriveAgentAddress(A, MASTER)).not.toBe(deriveAgentAddress(B, MASTER))
-  })
-
-  it('is case-insensitive on the owner address', () => {
-    expect(deriveAgentAddress(A.toUpperCase().replace('0X', '0x'), MASTER)).toBe(
-      deriveAgentAddress(A, MASTER),
-    )
-  })
-
-  it('changes with the master secret (no master reuse leaks)', () => {
-    expect(deriveAgentAddress(A, MASTER)).not.toBe(deriveAgentAddress(A, `${'b'.repeat(64)}`))
-  })
-
-  it('returns a valid 32-byte Sui address', () => {
-    expect(deriveAgentAddress(A, MASTER)).toMatch(/^0x[0-9a-f]{64}$/)
-  })
-
-  it('the keypair signs (a real Ed25519 key)', async () => {
-    const kp = deriveAgentKeypair(A, MASTER)
-    const { signature } = await kp.signPersonalMessage(new TextEncoder().encode('hi'))
-    expect(typeof signature).toBe('string')
-    expect(signature.length).toBeGreaterThan(0)
-  })
-
-  it('rejects a too-short master secret', () => {
-    expect(() => deriveAgentAddress(A, 'short')).toThrow()
-  })
-
-  it('rejects a malformed owner address', () => {
-    expect(() => deriveAgentAddress('not-an-address', MASTER)).toThrow()
-  })
-})

package/src/minimums.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { MIN_MIST, checkMinimum } from './minimums'
-
-describe('checkMinimum', () => {
-  test('rejects a too-small stake (0.1 SUI < 1 SUI minimum)', () => {
-    const err = checkMinimum('stake', 100_000_000n) // 0.1 SUI
-    expect(err).not.toBeNull()
-    expect(err).toContain('amount too small')
-    expect(err).toContain('1 SUI minimum for stake')
-  })
-
-  test('accepts a stake at the 1 SUI minimum', () => {
-    expect(checkMinimum('stake', MIN_MIST.stake)).toBeNull()
-    expect(checkMinimum('stake', 2_000_000_000n)).toBeNull()
-  })
-
-  test('rejects dust transfers/swaps/supplies below their minimums', () => {
-    expect(checkMinimum('transfer', 1n)).not.toBeNull()
-    expect(checkMinimum('swap', 1_000_000n)).not.toBeNull() // 0.001 < 0.01
-    expect(checkMinimum('supply', 5_000_000n)).not.toBeNull() // 0.005 < 0.01
-    expect(checkMinimum('borrow', 9_999_999n)).not.toBeNull()
-  })
-
-  test('accepts amounts at/above the minimum', () => {
-    expect(checkMinimum('transfer', MIN_MIST.transfer)).toBeNull()
-    expect(checkMinimum('swap', MIN_MIST.swap)).toBeNull()
-    expect(checkMinimum('supply', MIN_MIST.supply)).toBeNull()
-    expect(checkMinimum('borrow', MIN_MIST.borrow)).toBeNull()
-  })
-
-  test('the message names the amount, the minimum, and the action', () => {
-    const err = checkMinimum('swap', 5_000_000n) // 0.005 SUI
-    expect(err).toContain('0.005 SUI')
-    expect(err).toContain('0.01 SUI minimum for swap')
-  })
-})

package/src/policy.test.ts

@@ -1,187 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import {
-  type SuiPolicy,
-  type SuiPolicyAction,
-  evaluatePolicy,
-  normalizeCoinType,
-  policyFromEnv,
-  suiToMist,
-} from './policy'
-
-const ONE_SUI = 1_000_000_000n // 1 SUI in MIST
-const SUI = '0x2::sui::SUI'
-
-const send = (over: Partial<SuiPolicyAction> = {}): SuiPolicyAction => ({
-  kind: 'transfer',
-  coinType: SUI,
-  amountMist: ONE_SUI,
-  to: '0x1111111111111111111111111111111111111111111111111111111111111111',
-  protocol: 'transfer',
-  ...over,
-})
-
-describe('evaluatePolicy', () => {
-  it('allows a compliant native transfer', () => {
-    const v = evaluatePolicy(send(), { maxMistPerTx: 2n * ONE_SUI })
-    expect(v.allowed).toBe(true)
-    expect(v.violations).toHaveLength(0)
-    expect(v.requiresApproval).toBe(false)
-  })
-
-  it('blocks a transfer over the per-tx cap', () => {
-    const v = evaluatePolicy(send({ amountMist: 5n * ONE_SUI }), { maxMistPerTx: 2n * ONE_SUI })
-    expect(v.allowed).toBe(false)
-    expect(v.violations[0]).toContain('exceeds per-tx cap')
-  })
-
-  it('blocks a recipient not in the allowlist', () => {
-    const v = evaluatePolicy(send({ to: '0x2222' }), { recipientAllowlist: ['0x1111'] })
-    expect(v.allowed).toBe(false)
-    expect(v.violations[0]).toContain('not in the recipient allowlist')
-  })
-
-  it('allows an allowlisted recipient case-insensitively', () => {
-    const v = evaluatePolicy(send({ to: '0xABCD' }), { recipientAllowlist: ['0xabcd'] })
-    expect(v.allowed).toBe(true)
-  })
-
-  it('blocks a coin not in the coin allowlist', () => {
-    const v = evaluatePolicy(send({ coinType: '0xdead::x::X' }), { coinAllowlist: [SUI] })
-    expect(v.allowed).toBe(false)
-    expect(v.violations[0]).toContain('not in the coin allowlist')
-  })
-
-  it('allows SUI by short or padded form against an allowlist', () => {
-    const padded = `0x${'0'.repeat(63)}2::sui::SUI`
-    expect(evaluatePolicy(send({ coinType: padded }), { coinAllowlist: [SUI] }).allowed).toBe(true)
-    expect(evaluatePolicy(send({ coinType: 'native' }), { coinAllowlist: [SUI] }).allowed).toBe(
-      true,
-    )
-  })
-
-  it('blocks a swap whose slippage exceeds the cap', () => {
-    const v = evaluatePolicy(
-      { kind: 'swap', coinType: SUI, amountMist: ONE_SUI, slippageBps: 300 },
-      { maxSlippageBps: 100 },
-    )
-    expect(v.allowed).toBe(false)
-    expect(v.violations[0]).toContain('slippage')
-  })
-
-  it('blocks a protocol not in the protocol allowlist', () => {
-    const v = evaluatePolicy(send({ protocol: 'cetus' }), {
-      protocolAllowlist: ['transfer', 'deepbook'],
-    })
-    expect(v.allowed).toBe(false)
-    expect(v.violations[0]).toContain('not in the protocol allowlist')
-  })
-
-  it('blocks everything under a read-only policy', () => {
-    expect(evaluatePolicy(send(), { readOnly: true }).allowed).toBe(false)
-    expect(evaluatePolicy(send(), { autonomy: 'readonly' }).allowed).toBe(false)
-  })
-
-  it('blocks when the policy has expired', () => {
-    const v = evaluatePolicy(send(), { expiryMs: 1_000 }, 2_000)
-    expect(v.allowed).toBe(false)
-    expect(v.violations[0]).toContain('expired')
-  })
-
-  it('allows before the policy expires', () => {
-    expect(evaluatePolicy(send(), { expiryMs: 5_000 }, 2_000).allowed).toBe(true)
-  })
-
-  it('requires approval in the confirm tier', () => {
-    const v = evaluatePolicy(send(), { autonomy: 'confirm' })
-    expect(v.allowed).toBe(true)
-    expect(v.requiresApproval).toBe(true)
-  })
-
-  it('escalates to approval when a spend exceeds the auto ceiling', () => {
-    const policy: SuiPolicy = { autonomy: 'auto', autoMaxMistPerTx: ONE_SUI / 10n }
-    expect(evaluatePolicy(send({ amountMist: ONE_SUI / 100n }), policy).requiresApproval).toBe(
-      false,
-    )
-    expect(evaluatePolicy(send({ amountMist: ONE_SUI }), policy).requiresApproval).toBe(true)
-  })
-})
-
-describe('coin allowlist — adversarial', () => {
-  const A = '0xaaa::coin::A'
-  const B = '0xbbb::coin::B'
-  const policy: SuiPolicy = { coinAllowlist: [A] }
-
-  it('blocks a swap whose OUTPUT coin is not allowlisted', () => {
-    const v = evaluatePolicy({ kind: 'swap', coinType: A, toCoinType: B, amountMist: 1n }, policy)
-    expect(v.allowed).toBe(false)
-    expect(v.violations.some(s => /output coin/.test(s))).toBe(true)
-  })
-
-  it('allows a swap when both legs are allowlisted', () => {
-    const v = evaluatePolicy({ kind: 'swap', coinType: A, toCoinType: A, amountMist: 1n }, policy)
-    expect(v.allowed).toBe(true)
-  })
-
-  it('still blocks a swap whose INPUT coin is not allowlisted', () => {
-    const v = evaluatePolicy({ kind: 'swap', coinType: B, toCoinType: A, amountMist: 1n }, policy)
-    expect(v.allowed).toBe(false)
-  })
-})
-
-describe('amount-cap boundaries', () => {
-  it('allows exactly at the cap, blocks one MIST over', () => {
-    const policy: SuiPolicy = { maxMistPerTx: ONE_SUI }
-    expect(evaluatePolicy(send({ amountMist: ONE_SUI }), policy).allowed).toBe(true)
-    expect(evaluatePolicy(send({ amountMist: ONE_SUI + 1n }), policy).allowed).toBe(false)
-  })
-
-  it('auto tier: no approval exactly at the auto ceiling, approval one MIST over', () => {
-    const policy: SuiPolicy = { autoMaxMistPerTx: ONE_SUI }
-    expect(evaluatePolicy(send({ amountMist: ONE_SUI }), policy).requiresApproval).toBe(false)
-    expect(evaluatePolicy(send({ amountMist: ONE_SUI + 1n }), policy).requiresApproval).toBe(true)
-  })
-})
-
-describe('suiToMist + normalizeCoinType', () => {
-  it('converts decimal SUI to MIST', () => {
-    expect(suiToMist('1')).toBe(ONE_SUI)
-    expect(suiToMist('0.1')).toBe(ONE_SUI / 10n)
-    expect(suiToMist('1.5')).toBe(1_500_000_000n)
-    expect(suiToMist('')).toBeUndefined()
-    expect(suiToMist('-1')).toBeUndefined()
-  })
-
-  it('canonicalizes SUI forms and aliases', () => {
-    expect(normalizeCoinType('SUI')).toBe('0x2::sui::sui')
-    expect(normalizeCoinType('native')).toBe('0x2::sui::sui')
-    expect(normalizeCoinType(`0x${'0'.repeat(63)}2::sui::SUI`)).toBe('0x2::sui::sui')
-  })
-})
-
-describe('policyFromEnv', () => {
-  it('returns undefined when no policy env is set', () => {
-    expect(policyFromEnv({})).toBeUndefined()
-  })
-
-  it('parses caps, slippage, tier, allowlists and expiry', () => {
-    const p = policyFromEnv(
-      {
-        LYRA_POLICY_MAX_PER_TX_SUI: '1.0',
-        LYRA_POLICY_AUTO_MAX_SUI: '0.1',
-        LYRA_POLICY_MAX_SLIPPAGE_BPS: '100',
-        LYRA_POLICY_AUTONOMY: 'auto',
-        LYRA_POLICY_ALLOWED_PROTOCOLS: 'transfer, deepbook, walrus',
-        LYRA_POLICY_ALLOWED_COINS: '0x2::sui::SUI',
-        LYRA_POLICY_EXPIRY_MINUTES: '60',
-      },
-      1_000_000,
-    )
-    expect(p?.maxMistPerTx).toBe(ONE_SUI)
-    expect(p?.autoMaxMistPerTx).toBe(ONE_SUI / 10n)
-    expect(p?.maxSlippageBps).toBe(100)
-    expect(p?.autonomy).toBe('auto')
-    expect(p?.protocolAllowlist).toEqual(['transfer', 'deepbook', 'walrus'])
-    expect(p?.coinAllowlist).toEqual(['0x2::sui::SUI'])
-    expect(p?.expiryMs).toBe(1_000_000 + 60 * 60_000)
-  })
-})

package/src/tools/onchain.integration.test.ts

@@ -1,111 +0,0 @@
-/**
- * Integration coverage — LIVE mainnet dry-runs (devInspect, never broadcast).
- *
- * Gated: runs only when `LYRA_RUN_INTEGRATION=1` and a real `LYRA_AGENT_KEY` is
- * present. In CI (no secret) the whole suite is skipped, so it never flakes the
- * default `bun test`. Run locally with:
- *
- *   LYRA_RUN_INTEGRATION=1 bun test src/tools/onchain.integration.test.ts
- *
- * Each write case builds the exact PTB its tool builds and simulates it against
- * mainnet, proving the SDK integration + PTB are valid on-chain without moving
- * funds. Read-only tools are invoked directly (safe).
- */
-
-import { describe, expect, test } from 'bun:test'
-import { Transaction } from '@mysten/sui/transactions'
-import { LENDING_MARKET_ID, LENDING_MARKET_TYPE, SuilendClient } from '@suilend/sdk'
-import { stakeTovSuiPTB } from 'navi-sdk'
-import { keypairFromSecret, makeSuiClient } from '../client'
-import type { OnchainRuntimeContext } from '../types'
-import { makeScallopMarkets } from './scallop'
-import { makeSuilendPosition } from './suilend'
-
-const SUI = '0x2::sui::SUI'
-const RUN = process.env.LYRA_RUN_INTEGRATION === '1' && !!process.env.LYRA_AGENT_KEY
-const ONE_SUI = 1_000_000_000n
-
-function realCtx(): OnchainRuntimeContext {
-  const client = makeSuiClient('mainnet')
-  const keypair = keypairFromSecret(process.env.LYRA_AGENT_KEY as string)
-  return {
-    client,
-    keypair,
-    agentAddress: keypair.getPublicKey().toSuiAddress(),
-    network: 'mainnet',
-    agentDir: '/tmp/lyra-integration',
-  }
-}
-
-async function simStatus(ctx: OnchainRuntimeContext, tx: Transaction): Promise<string | undefined> {
-  const r = await ctx.client.devInspectTransactionBlock({
-    sender: ctx.agentAddress,
-    transactionBlock: tx as never,
-  })
-  return r.effects?.status?.status
-}
-
-describe.skipIf(!RUN)('mainnet dry-run integration', () => {
-  test('native stake (1 SUI → validator) simulates success', async () => {
-    const ctx = realCtx()
-    const state = await ctx.client.getLatestSuiSystemState()
-    const validator = state.activeValidators
-      .slice()
-      .sort((a, b) => Number(b.votingPower) - Number(a.votingPower))[0]
-    if (!validator) throw new Error('no active validators')
-    const tx = new Transaction()
-    tx.setSender(ctx.agentAddress)
-    const [coin] = tx.splitCoins(tx.gas, [ONE_SUI])
-    tx.moveCall({
-      target: '0x3::sui_system::request_add_stake',
-      arguments: [tx.object('0x5'), coin, tx.pure.address(validator.suiAddress)],
-    })
-    expect(await simStatus(ctx, tx)).toBe('success')
-  }, 45_000)
-
-  test('Volo liquid stake (1 SUI → vSUI) simulates success', async () => {
-    const ctx = realCtx()
-    const tx = new Transaction()
-    tx.setSender(ctx.agentAddress)
-    const [coin] = tx.splitCoins(tx.gas, [ONE_SUI])
-    const vsui = await stakeTovSuiPTB(tx as never, coin as never)
-    tx.transferObjects([vsui as never], ctx.agentAddress)
-    expect(await simStatus(ctx, tx)).toBe('success')
-  }, 45_000)
-
-  test('Suilend supply (1 SUI) simulates success', async () => {
-    const ctx = realCtx()
-    const suilend = await SuilendClient.initialize(
-      LENDING_MARKET_ID,
-      LENDING_MARKET_TYPE,
-      ctx.client as never,
-    )
-    const caps = await SuilendClient.getObligationOwnerCaps(
-      ctx.agentAddress,
-      [LENDING_MARKET_TYPE],
-      ctx.client as never,
-    )
-    const tx = new Transaction()
-    tx.setSender(ctx.agentAddress)
-    const [coin] = tx.splitCoins(tx.gas, [ONE_SUI])
-    if (caps.length === 0) {
-      const cap = suilend.createObligation(tx as never)
-      suilend.deposit(coin as never, SUI, cap, tx as never)
-      tx.transferObjects([cap as never], ctx.agentAddress)
-    } else {
-      const c = caps[0] as { id: string | { id: string } }
-      const capId = typeof c.id === 'string' ? c.id : c.id.id
-      suilend.deposit(coin as never, SUI, capId, tx as never)
-    }
-    expect(await simStatus(ctx, tx)).toBe('success')
-  }, 45_000)
-
-  test('read-only tools return live data', async () => {
-    const ctx = realCtx()
-    const position = await makeSuilendPosition(ctx).handler({})
-    expect(position.ok).toBe(true)
-
-    const markets = await makeScallopMarkets(ctx).handler({ coins: 'sui' })
-    expect(markets.ok).toBe(true)
-  }, 45_000)
-})

package/src/tools/tools.test.ts

@@ -1,140 +0,0 @@
-/**
- * Unit coverage for the DeFi tool surface: (1) the plugin registers every
- * value-moving adapter, and (2) each new write tool runs its guard checks
- * (mainnet-only, valid amount, minimum size) BEFORE it ever touches the
- * network — so a dust/invalid/testnet request fails fast and deterministically,
- * never a false success.
- *
- * These tests deliberately use a bare stub context: the guard branches return
- * before any `client`/`keypair` access, so no RPC is needed. Live end-to-end
- * PTB simulation lives in `onchain.integration.test.ts` (gated on a real key).
- */
-
-import { describe, expect, test } from 'bun:test'
-import type { PluginContext, ToolDef } from 'lyra-core'
-import plugin from '../index'
-import type { OnchainRuntimeContext } from '../types'
-import { makeVoloStake } from './liquid-stake'
-import { makeNaviBorrow, makeNaviRepay } from './navi'
-import { makeSuilendBorrow, makeSuilendSupply } from './suilend'
-
-// A context whose network/amount guards resolve before any client access.
-function stubCtx(network: 'mainnet' | 'testnet' = 'mainnet'): OnchainRuntimeContext {
-  return {
-    network,
-    agentAddress: '0x0000000000000000000000000000000000000000000000000000000000000abc',
-    agentDir: '/tmp/lyra-test',
-    // Accessing either of these would throw — guards must return first.
-    client: new Proxy(
-      {},
-      {
-        get() {
-          throw new Error('network access before guard')
-        },
-      },
-    ) as never,
-    keypair: {} as never,
-  }
-}
-
-describe('onchain plugin registration', () => {
-  test('registers the full DeFi write surface (lending + staking + swap)', () => {
-    const names: string[] = []
-    const ctx = {
-      registerTool: (def: ToolDef) => names.push(def.name),
-      registerListener: () => {},
-      addHook: () => {},
-      network: 'mainnet',
-      agentDir: '/tmp',
-      agentId: 'test',
-      // side-banded onchain runtime the plugin reads off PluginContext
-      onchain: stubCtx(),
-    } as unknown as PluginContext
-    plugin.register(ctx)
-
-    for (const expected of [
-      // lending: the three biggest Sui money markets, full CRUD
-      'scallop.supply',
-      'scallop.withdraw',
-      'navi.supply',
-      'navi.borrow',
-      'navi.repay',
-      'suilend.supply',
-      'suilend.withdraw',
-      'suilend.borrow',
-      'suilend.repay',
-      'suilend.position',
-      // staking: native + Volo liquid staking
-      'sui.stake',
-      'sui.unstake',
-      'volo.stake',
-      'volo.unstake',
-      // swap aggregator
-      'swap',
-    ]) {
-      expect(names).toContain(expected)
-    }
-  })
-
-  test('registers nothing without an onchain runtime (safe no-op for loaders)', () => {
-    const names: string[] = []
-    const ctx = {
-      registerTool: (def: ToolDef) => names.push(def.name),
-      registerListener: () => {},
-      addHook: () => {},
-      network: 'mainnet',
-      agentDir: '/tmp',
-      agentId: 'test',
-    } as unknown as PluginContext
-    plugin.register(ctx)
-    expect(names).toHaveLength(0)
-  })
-})
-
-describe('write-tool guards (fail before network)', () => {
-  test('suilend.supply rejects a dust amount below the supply minimum', async () => {
-    const res = await makeSuilendSupply(stubCtx()).handler({ amount: '0.001' })
-    expect(res.ok).toBe(false)
-    if (!res.ok) expect(res.error).toContain('amount too small')
-  })
-
-  test('suilend.borrow rejects a dust amount below the borrow minimum', async () => {
-    const res = await makeSuilendBorrow(stubCtx()).handler({ amount: '0.0001' })
-    expect(res.ok).toBe(false)
-    if (!res.ok) expect(res.error).toContain('amount too small')
-  })
-
-  test('volo.stake rejects below the 1 SUI staking minimum', async () => {
-    const res = await makeVoloStake(stubCtx()).handler({ amount: '0.1' })
-    expect(res.ok).toBe(false)
-    if (!res.ok) expect(res.error).toContain('amount too small')
-  })
-
-  test('navi.borrow rejects a dust amount', async () => {
-    const res = await makeNaviBorrow(stubCtx()).handler({ amount: '0.001' })
-    expect(res.ok).toBe(false)
-    if (!res.ok) expect(res.error).toContain('amount too small')
-  })
-
-  test('invalid amount strings are rejected before any network call', async () => {
-    const res = await makeVoloStake(stubCtx()).handler({ amount: 'not-a-number' })
-    expect(res.ok).toBe(false)
-    if (!res.ok) expect(res.error).toContain('invalid amount')
-  })
-
-  test('mainnet-only tools refuse to run on testnet', async () => {
-    const supply = await makeSuilendSupply(stubCtx('testnet')).handler({ amount: '5' })
-    expect(supply.ok).toBe(false)
-    if (!supply.ok) expect(supply.error).toContain('mainnet only')
-
-    const stake = await makeVoloStake(stubCtx('testnet')).handler({ amount: '5' })
-    expect(stake.ok).toBe(false)
-    if (!stake.ok) expect(stake.error).toContain('mainnet only')
-  })
-
-  test('navi.repay is a registered, well-formed tool', () => {
-    const tool = makeNaviRepay(stubCtx())
-    expect(tool.name).toBe('navi.repay')
-    expect(typeof tool.handler).toBe('function')
-  })
-})