@kaleidorg/mind 0.9.0 → 0.10.1

package/src/testing/mock-wallet.ts

@@ -149,6 +149,12 @@ export class MockWallet {
       }),
       spark_get_balance: async () => ({ btc_sats: this.balances.spark }),
       rln_get_balances: async () => ({ btc_sats: this.balances.rln, assets: this.assets }),
+      rln_get_node_info: async () => ({
+        pubkey: '02' + 'ab'.repeat(32),
+        num_channels: 0,
+        num_usable_channels: 0,
+        local_balance_sat: 0,
+      }),
       arkade_get_balance: async () => ({ btc_sats: this.balances.arkade }),
       spark_get_address: async () => ({ address: 'bc1qspark0mockreceiveaddr' }),
       arkade_get_address: async () => ({ address: 'ark1q0mockreceiveaddr' }),

package/src/wallet/contract.test.ts

@@ -11,6 +11,7 @@ import {
   toToolDefs,
   bindWalletTools,
   getWalletTool,
+  normalizeWalletArgs,
 } from './contract.js';
 
 describe('WALLET_TOOLS contract', () => {
@@ -64,7 +65,25 @@ describe('WALLET_TOOLS contract', () => {
   it('required args declared on the actionable tools', () => {
     expect((getWalletTool('send_payment')!.parameters as any).required).toContain('to');
     expect((getWalletTool('fiat_to_sats')!.parameters as any).required).toEqual(['amount', 'currency']);
-    expect((getWalletTool('rln_create_rgb_invoice')!.parameters as any).required).toEqual(['asset', 'amount']);
+    expect((getWalletTool('rln_send_asset')!.parameters as any).required).toEqual(['asset_id', 'recipient_id', 'amount']);
+  });
+});
+
+describe('normalizeWalletArgs', () => {
+  it('fills legacy names for older handlers and canonical names for legacy callers', () => {
+    expect(normalizeWalletArgs('rln_send_asset', { asset_id: 'rgb:x', recipient_id: 'utxob:y', amount: 1 }))
+      .toEqual({ asset_id: 'rgb:x', asset: 'rgb:x', recipient_id: 'utxob:y', to: 'utxob:y', amount: 1 });
+    expect(normalizeWalletArgs('rln_send_asset', { asset: 'USDT', to: 'bob', amount: 2 }))
+      .toMatchObject({ asset_id: 'USDT', recipient_id: 'bob' });
+    expect(normalizeWalletArgs('get_price', { asset: 'BTC', vs_currency: 'eur' })).toMatchObject({ fiat: 'eur' });
+    expect(normalizeWalletArgs('rln_get_balances', { skip_sync: true })).toEqual({ skip_sync: true });
+  });
+
+  it('bound handlers receive both shapes', async () => {
+    let got: Record<string, unknown> = {};
+    const src = bindWalletTools({ rln_create_rgb_invoice: async (a) => { got = a; return {}; } }, { layers: ['rln'], includeCore: false, allowMissing: true });
+    await src.execute('rln_create_rgb_invoice', { asset_id: 'USDT', amount: 5 });
+    expect(got).toMatchObject({ asset_id: 'USDT', asset: 'USDT', amount: 5 });
   });
 });
 

package/src/wallet/contract.ts

@@ -88,11 +88,20 @@ export const WALLET_TOOLS: WalletToolDef[] = [
   t('rln', 'rln_get_node_info', 'Get RLN node status and sync state.'),
   t('rln', 'rln_list_channels', 'List the RLN node Lightning channels.'),
   t('rln', 'rln_create_ln_invoice', 'Create a Lightning (BTC) invoice on the RLN node.', { amount_sats: sats }),
-  t('rln', 'rln_create_rgb_invoice', 'Create an RGB asset invoice to receive an asset (e.g. USDT).', { asset, amount: { type: 'number', description: 'Asset amount' } }, ['asset', 'amount']),
+  t('rln', 'rln_create_rgb_invoice', 'Create an RGB invoice to receive an asset on-chain. Returns the invoice string to share with the payer.', {
+    asset_id: { type: 'string', description: "RGB asset id ('rgb:…'); in-app wallets also accept a ticker. Omit for any asset." },
+    amount: { type: 'number', description: 'Expected amount in display units (e.g. 10 for 10 USDT)' },
+    duration_seconds: { type: 'number', description: 'Invoice expiry (default 86400)' },
+  }),
   t('rln', 'rln_pay_invoice', 'Pay a Lightning invoice from the RLN node.', { invoice: { type: 'string' } }, ['invoice'], true),
-  t('rln', 'rln_send_asset', 'Send an RGB asset (e.g. USDT) to a recipient.', { asset, amount: { type: 'number' }, to: { type: 'string' } }, ['asset', 'amount', 'to'], true),
-  t('rln', 'rln_list_assets', 'List RGB assets held by the RLN node (asset_id, ticker, name, precision, balances).'),
-  t('rln', 'rln_get_asset_balance', 'Get the balance of one RGB asset by asset_id (settled, future, spendable, off-chain).', { asset_id: { type: 'string', description: "RGB asset id, e.g. 'rgb:2JEUOrsc-…'" } }, ['asset_id']),
+  t('rln', 'rln_send_asset', 'Send an RGB asset to the recipient of an RGB invoice.', {
+    asset_id: { type: 'string', description: "RGB asset id ('rgb:…') from rln_list_assets; in-app wallets also accept a ticker." },
+    recipient_id: { type: 'string', description: 'Recipient from the RGB invoice: its utxob:/wvout: part, or the whole invoice.' },
+    amount: { type: 'number', description: 'Amount in display units (e.g. 10 for 10 USDT)' },
+    fee_rate: { type: 'number', description: 'sat/vbyte (default 3)' },
+  }, ['asset_id', 'recipient_id', 'amount'], true),
+  t('rln', 'rln_list_assets', 'List every RGB asset on the RLN node with its balance (asset_id, ticker, name, precision, balance {settled, future, spendable, offchain_outbound, offchain_inbound} in raw units = display × 10^precision). Answers "what do I hold" in one call.'),
+  t('rln', 'rln_get_asset_balance', 'Get the balance of ONE RGB asset by asset_id (settled, future, spendable, off-chain). rln_list_assets already includes every balance.', { asset_id: { type: 'string', description: "RGB asset id, e.g. 'rgb:2JEUOrsc-…'" } }, ['asset_id']),
   t('rln', 'rln_refresh_transfers', 'Refresh pending RGB transfers so balances and transfer status are up to date.'),
   t('rln', 'rln_get_address', 'Get an on-chain BTC address of the RLN node for deposits.'),
   t('rln', 'rln_send_btc', 'Send on-chain BTC from the RLN node.', { address: { type: 'string', description: 'Destination Bitcoin address' }, amount_sat: { type: 'number', description: 'Amount in satoshis' }, fee_rate: { type: 'number', description: 'sat/vbyte (default 3)' } }, ['address', 'amount_sat'], true),
@@ -141,7 +150,7 @@ export const WALLET_TOOLS: WalletToolDef[] = [
   // ── Core: router + helpers ─────────────────────────────────────────────
   t('core', 'get_balances', 'Get balances across all layers (or one layer).', { layer: { type: 'string', enum: ['spark', 'rln', 'arkade', 'liquid'], description: 'Optional: a single layer' } }),
   t('core', 'resolve_contact', 'Resolve a contact name to a Lightning address / Nostr / preferred rail.', { name: { type: 'string', description: 'Contact name, e.g. "bob"' } }, ['name']),
-  t('core', 'get_price', 'Get the current price of an asset, optionally in a fiat currency.', { asset, fiat: { type: 'string', description: "Fiat code, e.g. 'EUR', 'USD'" } }),
+  t('core', 'get_price', 'Get the current price of an asset, optionally in a fiat currency.', { asset, vs_currency: { type: 'string', description: "Quote currency, e.g. 'usd', 'eur' (default usd)" } }, ['asset']),
   t('core', 'fiat_to_sats', 'Convert a fiat amount to satoshis at the current rate.', { amount: { type: 'number' }, currency: { type: 'string', description: "Fiat code, e.g. 'EUR'" } }, ['amount', 'currency']),
   t('core', 'get_swap_quote', 'Quote a swap between two assets.', { from_asset: asset, to_asset: asset, amount: { type: 'number' } }, ['from_asset', 'to_asset', 'amount']),
   t('core', 'execute_swap', 'Execute a previously quoted swap.', { quote_id: { type: 'string' }, from_asset: asset, to_asset: asset, amount: { type: 'number' } }, [], true),
@@ -178,6 +187,27 @@ export function toToolDefs(tools: WalletToolDef[]): ToolDef[] {
   return tools.map(({ name, description, parameters, requiresConfirmation }) => ({ name, description, parameters, requiresConfirmation }));
 }
 
+/**
+ * Map kaleido-mcp argument names onto the pre-0.9 contract names (and back), so
+ * one call shape works on every surface and older host handlers keep working.
+ */
+export function normalizeWalletArgs(name: string, args: Record<string, unknown>): Record<string, unknown> {
+  const a: Record<string, unknown> = { ...args };
+  const alias = (canonical: string, legacy: string) => {
+    if (a[canonical] == null && a[legacy] != null) a[canonical] = a[legacy];
+    if (a[legacy] == null && a[canonical] != null) a[legacy] = a[canonical];
+  };
+  if (name === 'rln_send_asset') {
+    alias('asset_id', 'asset');
+    alias('recipient_id', 'to');
+  } else if (name === 'rln_create_rgb_invoice') {
+    alias('asset_id', 'asset');
+  } else if (name === 'get_price') {
+    alias('vs_currency', 'fiat');
+  }
+  return a;
+}
+
 /** A handler bound to one contract tool. */
 export type WalletHandler = (args: Record<string, unknown>) => Promise<unknown>;
 
@@ -208,7 +238,7 @@ export function bindWalletTools(handlers: Record<string, WalletHandler>, opts: B
       description: def.description,
       parameters: def.parameters,
       requiresConfirmation: def.requiresConfirmation,
-      handler,
+      handler: (args) => handler(normalizeWalletArgs(def.name, args)),
     });
   }
   return new InProcessToolSource(opts.id ?? 'wallet', bound);

package/skills/dca/SKILL.md

@@ -1,48 +0,0 @@
----
-name: dca
-description: "Dollar-cost-average a fixed budget into a target asset on a schedule. Reads the live quote and (when allowed) buys a small fixed slice via an atomic swap, respecting per-run allocation and risk limits. Triggers when the user mentions DCA, recurring buys, or averaging in — and is the skill a user-created DCA loop runs."
-tools: rln_get_balances, kaleidoswap_get_quote, kaleidoswap_atomic_init, kaleidoswap_atomic_execute, kaleidoswap_atomic_status, get_price
-triggers: dca, dollar cost average, recurring buy, average in, accumulate, stack
-metadata:
-  author: kaleidoswap
-  version: "0.1.0"
----
-
-# Dollar-cost averaging
-
-Buy a fixed, small slice of a target asset each run. Boring on purpose: same
-size, every interval, regardless of price.
-
-## Critical rules — these override everything else
-
-- **Fixed slice only.** The per-run budget is the task's `allocation` — never
-  exceed it, never "catch up" by buying extra after a missed run.
-- **Respect `dry_run`.** When true, quote and report what you *would* buy; do NOT
-  execute.
-- **Respect risk + reserve.** A DCA buy is a spend; it passes through the host's
-  risk gate. Never breach the BTC reserve or the max single-spend limit.
-
-## Each run
-
-1. **Check funds.** `rln_get_balances` — is there enough BTC for one slice plus
-   the reserve? If not, return `action: "skip"` with the reason.
-2. **Quote.** `kaleidoswap_get_quote(BTC, <asset>, <slice>)`. Read the
-   `to_amount_display` / `fee_display` strings verbatim — no arithmetic.
-3. **Execute** (only when `dry_run` is false and within limits): the atomic swap
-   recipe drives `kaleidoswap_atomic_init` → `_execute`; then poll
-   `kaleidoswap_atomic_status`.
-
-## Scheduled (background) runs
-
-Return STRICT JSON only:
-
-```
-{"task":"<task id>","timestamp":"<ISO8601>","action":"buy|skip","dry_run":<bool>,"reason":"<why>","details":{"asset":"<asset>","slice":"<n>","received":"<display>","fee":"<display>"}}
-```
-
-## Don'ts
-
-- Don't vary the slice size or try to time the market — that's not DCA.
-- Don't buy when funds are below the reserve — `skip` instead.
-- Don't execute when `dry_run` is true.
-- Don't invent a quote — only the current `kaleidoswap_get_quote` result is real.

package/skills/kaleido-lsps/SKILL.md

@@ -1,131 +0,0 @@
----
-name: kaleido-lsps
-description: "Buy inbound Lightning channel capacity from a Lightning Service Provider (LSPS1). Quote a channel, estimate fees, place a channel order, and check order status. Triggers when the user wants inbound liquidity, says they can't receive a payment, needs a channel, asks about LSP fees, or wants to check the status of a channel order / LSP order."
-tools: lsp_get_info, lsp_get_network_info, lsp_estimate_fees, lsp_create_order, lsp_get_order, kaleidoswap_lsp_get_info, kaleidoswap_lsp_estimate_fees, kaleidoswap_lsp_create_order, kaleidoswap_lsp_get_order, kaleidoswap_lsp_quote_asset_channel, kaleidoswap_lsp_create_asset_channel, rln_get_node_info, rln_list_channels, rln_pay_invoice
-triggers: inbound, liquidity, channel order, lsp, lsps1, receive limit, can't receive, open channel, channel from, check status, order status, check the order, channel status, lsp status, check my channel, check lsp order, did the channel open, lsp order status, list my channels, my channels, channel capacity
-metadata:
-  author: kaleidoswap
-  version: "0.2.0"
----
-
-# Lightning channel orders (LSPS1)
-
-Buy inbound Lightning channel capacity from a Lightning Service Provider when
-the user can't receive a payment, wants a bigger receive limit, or just wants
-to open a new channel from the LSP. The host binds these to whichever LSP it
-talks to — the KaleidoSwap maker by default. Tool names are LSP-agnostic
-(`lsp_*`), so the same skill works against any LSPS1-compliant LSP.
-
-## Critical rules — these override everything else
-
-You have **no knowledge** of LSP capabilities, fees, channel sizes, or order
-status. Every number, capacity, fee, order id, or invoice in your reply MUST
-come from a tool result returned in the CURRENT turn. Never quote a fee from
-memory. Never claim an order completed without calling `kaleidoswap_lsp_get_order`.
-Never reuse a number from a previous turn.
-
-**Calling the tool IS the answer.** Don't write "the LSP info is fetched with
-`kaleidoswap_lsp_get_info`" — call it. Don't reveal tool names in your reply; describe
-what you're doing in plain language.
-
-If a tool needs a required argument the user didn't give (e.g. `client_pubkey`
-when creating an order — get it from `rln_get_node_info`), resolve it via the
-appropriate read tool. Don't ask the user for a pubkey.
-
-## Asset codes
-
-The same conventions as trading apply:
-- `BTC` (sats) — the default for "inbound liquidity" / "channel capacity".
-- `USDT` / `XAUT` — for RGB asset channels (uses `asset_id` + `lsp_asset_amount`).
-
-## Tools and the flow
-
-### Step 1 — `kaleidoswap_lsp_get_info`
-No args. Returns the LSP's `OrderOptions` (min/max channel size, min/max
-expiry, etc.) and the `assets` list. **Call it once before estimating** so you
-can validate the user's request against the LSP's limits.
-
-If the user wants 1M sats inbound but `max_initial_lsp_balance_sat` is 500k,
-say so plainly and offer the maximum — don't push through and let the maker
-reject it.
-
-### Step 2 — `kaleidoswap_lsp_estimate_fees` (read-only)
-Required args: `lsp_balance_sat`, `client_balance_sat`, `channel_expiry_blocks`.
-
-Defaults you can use silently if the user didn't specify:
-- `client_balance_sat: 0` (pure inbound order — most common)
-- `channel_expiry_blocks: 4320` (~30 days)
-
-Returns `{setup_fee, capacity_fee, duration_fee, total_fee}` — surface
-`total_fee` to the user and the breakdown when relevant.
-
-### Step 3 — `rln_get_node_info`
-No args. Returns `{pubkey, ...}`. **Pubkey is required by `kaleidoswap_lsp_create_order` —
-fetch it deterministically. Never invent a pubkey.**
-
-### Step 4 — `kaleidoswap_lsp_create_order` 🔒 spend
-Required args: `client_pubkey` (from step 3), `lsp_balance_sat`. The maker
-also expects `client_balance_sat`, `required_channel_confirmations`,
-`funding_confirms_within_blocks`, `channel_expiry_blocks`, `announce_channel`
-— the host adapter fills sensible defaults (1, 6, 4320, true) when the user
-didn't specify, so just pass the values the user actually named.
-
-Returns:
-- `order_id`
-- `access_token` (save it — required for `kaleidoswap_lsp_get_order`)
-- `payment.bolt11.invoice` — Lightning invoice to pay
-- `payment.bolt11.order_total_sat` — the sats that need to flow
-- `payment.onchain.address` — optional on-chain fallback
-- `order_state: "CREATED"`
-
-### Step 5 — Pay the invoice with `rln_pay_invoice`
-Hand the `payment.bolt11.invoice` to `rln_pay_invoice`. This is a separate
-spend gate at the wallet contract; the user confirms paying the LSP.
-
-### Verify the opened channel — `rln_list_channels`
-After an order completes (or when the user asks "do I have a channel with X
-inbound?", "list my channels", "did my channel open?"), call
-`rln_list_channels`. It returns each channel's `capacity_sat`, `inbound_sat`,
-`outbound_sat`, `ready`/`status`, and RGB `asset_*` amounts. Match the
-requested capacity against an actual channel to confirm it opened correctly.
-A freshly-bought channel opens ASYNCHRONOUSLY — if it isn't listed yet, say
-it's still opening, don't claim failure. Do NOT use `rln_get_node_info` for
-this (it only has counts + aggregate balance, not per-channel capacity).
-
-### Step 6 — poll the order (`lsp_get_order` / `kaleidoswap_lsp_get_order`)
-Use `lsp_get_order` on CLI hosts, `kaleidoswap_lsp_get_order` on desktop —
-whichever your host exposes. **Args: `order_id`, `access_token` (BOTH
-required — never omit either).** `order_state` progresses
-`CREATED → CHANNEL_OPENING → COMPLETED` (or `FAILED`). Poll until terminal.
-Always pass the exact order_id and access_token from the previous
-create-order result **or from the most recent assistant message/summary**
-(the one that said something like "order_id=xxx access_token=yyy" or "To
-check status use: lsp_get_order(order_id=..., access_token=...)"). If
-memory/remember is available, first recall the last LSPS1 order details.
-Report the outcome plainly with the new channel id from `channel.channel_id` if present.
-
-## Don'ts
-
-- Don't invent capacity, fees, pubkeys, order_ids, or invoices.
-- Don't reuse a number from a previous turn — re-estimate when parameters
-  change (different size or expiry).
-- Don't describe how a tool works — call it.
-- Don't pay a Lightning invoice without confirming the amount + LSP — the
-  spend gate at `rln_pay_invoice` shows the user the destination.
-- Don't claim an order completed without polling `kaleidoswap_lsp_get_order` with BOTH
-  `order_id` and `access_token` and seeing `order_state: COMPLETED`.
-- Never call `kaleidoswap_lsp_get_order` with only the access_token or only the order_id.
-  Always extract the exact values from the previous turn's summary (the one that
-  said "order_id=... access_token=..." or the explicit "To check status use..." line)
-  and pass them as separate arguments. If using the `remember` tool, first recall
-  the last channel/LSPS1 order details.
-- Don't ask the user for their node pubkey — fetch it from `rln_get_node_info`.
-
-## When the deterministic recipe handles it
-
-For requests like "I need 500k inbound" or "buy a channel from the LSP", the
-`kaleidoswap-channel-order` recipe drives the whole chain (get_info →
-estimate_fees → get_node_info → create_order → pay_invoice) with a single
-confirmation gate showing the real fee. Use the agentic flow here only when
-the recipe didn't fire — typically for read-only questions ("what does the
-LSP offer?") or partial flows ("estimate fees for 200k inbound").

package/skills/liquidity-optimizer/SKILL.md

@@ -1,91 +0,0 @@
----
-name: liquidity-optimizer
-description: "Analyze and optimize the node's Lightning liquidity. Reads channels, balances and payment history, then explains the node's liquidity health and recommends concrete actions: buy inbound, open/close channels, rebalance BTC↔assets, or tune routing fees. Triggers when the user wants to rebalance, optimize liquidity, fix inbound/outbound balance, free up capital, lower fees, or asks 'how healthy is my node?' / 'where is my liquidity?'."
-tools: rln_list_channels, rln_get_balances, rln_get_node_info, rln_list_payments, kaleidoswap_lsp_get_info, kaleidoswap_lsp_estimate_fees, kaleidoswap_lsp_quote_asset_channel, rln_open_channel, rln_close_channel
-triggers: rebalance, rebalancing, optimize liquidity, liquidity, inbound, outbound, lopsided, depleted channel, free up capital, stuck funds, channel balance, routing fee, lower fees, fee optimization, node health, healthy node, where is my liquidity, capacity
-metadata:
-  author: kaleidoswap
-  version: "0.1.0"
----
-
-# Liquidity optimizer
-
-Help the user keep their RGB Lightning node's liquidity healthy: balanced
-inbound/outbound, capital not stuck in dead channels, and fees set so the node
-can actually route and receive. You **analyze real channel state and recommend
-actions** — you never move funds without an explicit, confirmed instruction.
-
-## Critical rules — these override everything else
-
-You have **no knowledge** of the node's channels, balances, or capacity. Every
-number, channel id, ratio, or fee in your reply MUST come from a tool result
-returned in the CURRENT turn. Never quote a balance from memory or reuse a
-number from a previous turn — re-read it.
-
-**Calling the tool IS the analysis.** Don't say "I'd check your channels with
-`rln_list_channels`" — call it, then report what it returned in plain language.
-Don't reveal raw tool names in your reply.
-
-**Read freely, spend never (without confirmation).** `rln_list_channels`,
-`rln_get_balances`, `rln_get_node_info`, `rln_list_payments`,
-`kaleidoswap_lsp_get_info`, and `kaleidoswap_lsp_estimate_fees` are read-only —
-use them as much as you need. `rln_open_channel`, `rln_close_channel`, and
-buying a channel are **spends**: only call them when the user explicitly asked
-for that action this turn, and each goes through the wallet's confirmation gate.
-When you merely *recommend* an action, describe it — do not execute it.
-
-## How to assess liquidity
-
-### 1 — Read the state (always start here)
-- `rln_list_channels` → `channel_count`, `total_outbound_msat`,
-  `total_inbound_msat`, and per-channel `outbound_balance_msat`,
-  `inbound_balance_msat`, `is_usable`, capacity, peer, and any RGB asset
-  allocation. **Balances are in millisats (msat); divide by 1000 for sats.**
-- `rln_get_balances` → on-chain (vanilla/colored) + Lightning balance, to see
-  uncommitted capital that could open a channel.
-- `rln_get_node_info` → pubkey, peer/channel counts, sync state.
-- `rln_list_payments` (optional) → recent flow direction, to infer whether the
-  node mostly sends or receives.
-
-### 2 — Compute the picture (per channel and overall)
-For each channel, the **outbound ratio** = `outbound / (outbound + inbound)`:
-- **~0% (all inbound):** can receive but can't send — depleted outbound.
-- **~100% (all outbound):** can send but can't receive — no inbound liquidity.
-- **40–60%:** balanced and healthy.
-Then look at the totals: is the node short on **inbound** (can't receive) or
-short on **outbound** (can't send)? Flag channels that are `is_usable: false`
-(offline/pending peer) or that hold meaningful capital but never route.
-
-### 3 — Recommend, prioritized
-Lead with a one-line health verdict, then a short ordered action list. Match the
-remedy to the problem:
-- **Low inbound / "can't receive":** buy inbound from the LSP. Use
-  `kaleidoswap_lsp_get_info` for limits and `kaleidoswap_lsp_estimate_fees`
-  (or `kaleidoswap_lsp_quote_asset_channel` for an asset channel) to give a real
-  fee, then hand off to the channel-order flow. Don't invent the fee.
-- **Low outbound / "can't send":** open a channel to a well-connected peer with
-  spare on-chain BTC (`rln_open_channel`), or fund the wallet first.
-- **Lopsided but funded both ways:** rebalance instead of opening new channels —
-  for BTC↔asset imbalance, suggest a swap (the trading flow), since circular
-  rebalancing may not be available on this node.
-- **Dead/offline channels with stuck capital:** consider closing
-  (`rln_close_channel`) to reclaim funds, but only if the user confirms — note
-  on-chain fees and the ~hours for funds to settle.
-- **Fees:** if the node should route more, suggest lower routing fees; if it's
-  draining outbound cheaply, suggest raising them. If no fee-setting tool is
-  available this turn, give the recommendation and tell the user where to set it
-  rather than pretending you changed it.
-
-## Output style
-Concise and scannable. A verdict line, then "Top actions" as a short numbered
-list with the concrete number behind each (e.g. "Channel abc12… is 97% outbound
-— buy ~200k inbound, est. fee from the LSP"). No walls of JSON.
-
-## Don'ts
-- Don't invent channels, balances, ratios, capacities, or fees — read them.
-- Don't forget msat→sat conversion when reporting channel balances.
-- Don't open or close a channel, or buy liquidity, unless the user asked for
-  that action this turn — recommendations are not actions.
-- Don't claim you changed fees or rebalanced if no tool did it — say what the
-  user should do.
-- Don't reuse last turn's numbers — re-read before advising again.