@kaleidorg/mind 0.10.6 → 0.10.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaleidorg/mind",
-  "version": "0.10.6",
+  "version": "0.10.8",
   "description": "Local-first reasoning + function-calling engine for KaleidoSwap. QVAC-powered.",
   "license": "Apache-2.0",
   "type": "module",

package/skills/kaleido-trading/SKILL.md

@@ -17,10 +17,10 @@ ticker (`BTC`, `USDT`, `XAUT`) or an `rgb:…` id.
 A swap runs over Lightning: it needs a channel with enough outbound in the
 asset you send and enough inbound in the asset you receive. If
 `rln_list_channels` shows none, buy one first (see `channel-manager`).
-Sending BTC, the node sends the amount plus 3,000 sats (the RGB node's HTLC
-minimum) in one payment, so one usable channel needs outbound of at least
-amount + 3,000 sats. Less than that: offer a smaller swap (outbound − 3,000)
-or a bigger channel.
+Each leg is one payment plus the node's 3,000-sat HTLC minimum: sending BTC
+needs one channel with outbound ≥ amount + 3,000 sats, receiving BTC inbound ≥
+amount + 3,000; the asset side needs an asset channel holding the asset (or
+inbound for it). Short: offer a smaller swap or a bigger channel.
 
 ## Do
 - Quote with exactly one amount: `from_amount` to sell a fixed input,

package/src/engine.ts

@@ -367,7 +367,7 @@ export class Engine {
         };
       } else if (def.requiresConfirmation) {
         args = check.args;
-        const summary = confirmReadback({ name: call.name, arguments: args }) ?? undefined;
+        const summary = confirmReadback({ name: call.name, arguments: args }, { results: state.executed }) ?? undefined;
         const decision = opts.onConfirm
           ? await opts.onConfirm({ name: call.name, arguments: args, ...(summary ? { summary } : {}) })
           : { approved: false, reason: 'no confirmation handler available' };

package/src/funnel.mind.test.ts

@@ -212,9 +212,9 @@ describe('desktop mind — buy assets via atomic swap', () => {
     // The full deterministic chain, in order.
     expect(calls.map((c) => c.name)).toEqual([
       'kaleidoswap_get_quote',
+      'rln_get_node_info',
       'rln_list_channels',
       'kaleidoswap_atomic_init',
-      'rln_get_node_info',
       'rln_atomic_taker',
       'kaleidoswap_atomic_execute',
     ]);
@@ -257,9 +257,9 @@ describe('desktop mind — buy assets via atomic swap', () => {
     expect(res.route).toBe('kaleidoswap-atomic');
     expect(calls.map((c) => c.name)).toEqual([
       'kaleidoswap_get_quote',
+      'rln_get_node_info',
       'rln_list_channels',
       'kaleidoswap_atomic_init',
-      'rln_get_node_info',
       'rln_atomic_taker',
       'kaleidoswap_atomic_execute',
     ]);

package/src/recipe/kaleidoswap-atomic.test.ts

@@ -204,8 +204,8 @@ describe('kaleidoswapAtomicRecipe — full chain', () => {
     expect(res.inferences).toBe(0);
     expect(captured.map((c) => c.name)).toEqual([
       'kaleidoswap_get_quote',
-      'kaleidoswap_atomic_init',
       'rln_get_node_info',
+      'kaleidoswap_atomic_init',
       'rln_atomic_taker',
       'kaleidoswap_atomic_execute',
     ]);
@@ -307,7 +307,71 @@ describe('kaleidoswapAtomicRecipe — single confirmation', () => {
 
     expect(res.status).toBe('cancelled');
     // Quote ran (read-only), but NOTHING after the declined gate.
-    expect(captured.map((c) => c.name)).toEqual(['kaleidoswap_get_quote']);
+    expect(captured.map((c) => c.name)).toEqual(['kaleidoswap_get_quote', 'rln_get_node_info']);
+  });
+});
+
+describe('kaleidoswapAtomicRecipe — channel liquidity preflight', () => {
+  const btcToUsdt = {
+    rfq_id: 'rfq-2',
+    from_asset: { asset_id: 'BTC', ticker: 'BTC', layer: 'BTC_LN', amount_raw: 50_000_000, amount_display: '50,000 sats' },
+    to_asset: { asset_id: 'rgb:usdt', ticker: 'USDT', layer: 'RGB_LN', amount_raw: 30_000_000, amount_display: '30' },
+  };
+  const usdtToBtc = {
+    rfq_id: 'rfq-3',
+    from_asset: { asset_id: 'rgb:usdt', ticker: 'USDT', layer: 'RGB_LN', amount_raw: 10_000_000, amount_display: '10' },
+    to_asset: { asset_id: 'BTC', ticker: 'BTC', layer: 'BTC_LN', amount_raw: 15_000_000, amount_display: '15,000 sats' },
+  };
+  const usdtChannel = (over: Record<string, unknown> = {}) => ({
+    ready: true,
+    is_usable: true,
+    asset_id: 'rgb:usdt',
+    asset_local_amount: 20_000_000,
+    asset_remote_amount: 40_000_000,
+    next_outbound_htlc_limit_msat: 60_000_000,
+    inbound_balance_msat: 50_000_000,
+    ...over,
+  });
+
+  it('BTC -> asset: BTC outbound must cover the amount plus the HTLC minimum', async () => {
+    const { swapLiquidityShortfall } = await import('./kaleidoswap-atomic.js');
+    expect(swapLiquidityShortfall(btcToUsdt as never, { channels: [usdtChannel({ next_outbound_htlc_limit_msat: 51_000_000 })] })).toBe(
+      'your channels can send at most 51,000 sats, and this swap needs 53,000 sats (the amount plus the 3,000 sats HTLC minimum). Swap at most 48,000 sats, or buy a bigger channel.',
+    );
+    expect(swapLiquidityShortfall(btcToUsdt as never, { channels: [usdtChannel()] })).toBeNull();
+    expect(swapLiquidityShortfall(btcToUsdt as never, { channels: [usdtChannel({ next_outbound_htlc_limit_msat: 3_000_000 })] })).toBe(
+      'your channels can send at most 3,000 sats, which only covers the 3,000 sats HTLC minimum, so no BTC swap fits. This one needs 53,000 sats: buy a channel with more outbound.',
+    );
+    expect(swapLiquidityShortfall(btcToUsdt as never, { channels: [] })).toMatch(/no channels/);
+    expect(swapLiquidityShortfall(btcToUsdt as never, { channels: [usdtChannel({ ready: false })] })).toMatch(/none can send right now/);
+  });
+
+  it('BTC -> asset: an asset channel must be able to receive the asset', async () => {
+    const { swapLiquidityShortfall } = await import('./kaleidoswap-atomic.js');
+    expect(swapLiquidityShortfall(btcToUsdt as never, { channels: [usdtChannel({ asset_remote_amount: 5_000_000 })] })).toMatch(
+      /^no channel can receive 30 USDT/,
+    );
+    expect(swapLiquidityShortfall(btcToUsdt as never, { channels: [usdtChannel({ inbound_balance_msat: 1_000_000 })] })).toMatch(
+      /^no channel can receive 30 USDT/,
+    );
+  });
+
+  it('asset -> BTC: the asset must be on our side and BTC inbound must cover amount + minimum', async () => {
+    const { swapLiquidityShortfall } = await import('./kaleidoswap-atomic.js');
+    expect(swapLiquidityShortfall(usdtToBtc as never, { channels: [usdtChannel()] })).toBeNull();
+    expect(swapLiquidityShortfall(usdtToBtc as never, { channels: [usdtChannel({ asset_local_amount: 1_000_000 })] })).toMatch(
+      /^no channel can send 10 USDT/,
+    );
+    expect(swapLiquidityShortfall(usdtToBtc as never, { channels: [usdtChannel({ inbound_balance_msat: 10_000_000 })] })).toBe(
+      'your channels can receive at most 10,000 sats, and this swap pays you 18,000 sats (the amount plus the 3,000 sats HTLC minimum). Swap for less BTC, or get more inbound.',
+    );
+  });
+
+  it("uses the node's HTLC minimum and doesn't block on unreadable data", async () => {
+    const { swapLiquidityShortfall } = await import('./kaleidoswap-atomic.js');
+    expect(swapLiquidityShortfall(btcToUsdt as never, { channels: [usdtChannel({ next_outbound_htlc_limit_msat: 51_000_000 })] }, 1_000_000)).toBeNull();
+    expect(swapLiquidityShortfall(btcToUsdt as never, { channels: [{ channel_id: 'x' }] })).toBeNull();
+    expect(swapLiquidityShortfall(btcToUsdt as never, 'not json')).toBeNull();
   });
 });
 
@@ -321,10 +385,10 @@ describe('kaleidoswapAtomicRecipe — outbound preflight (BTC leg + RLN HTLC min
   it('reports the shortfall in plain numbers', async () => {
     const { outboundShortfall } = await import('./kaleidoswap-atomic.js');
     expect(outboundShortfall(btcQuote as never, { channels: [{ ready: true, is_usable: true, outbound_balance_msat: 51_000_000 }] })).toBe(
-      'your channels can send at most 51,000 sats, and this swap needs 53,000 sats (the amount plus RLN\'s 3,000-sat HTLC minimum). Swap at most 48,000 sats, or buy a bigger channel.',
+      'your channels can send at most 51,000 sats, and this swap needs 53,000 sats (the amount plus the 3,000 sats HTLC minimum). Swap at most 48,000 sats, or buy a bigger channel.',
     );
     expect(outboundShortfall(btcQuote as never, { channels: [{ ready: true, next_outbound_htlc_limit_msat: 60_000_000 }] })).toBeNull();
-    expect(outboundShortfall(btcQuote as never, { channels: [] })).toMatch(/none can send right now/);
+    expect(outboundShortfall(btcQuote as never, { channels: [] })).toMatch(/no channels/);
     expect(outboundShortfall(btcQuote as never, { something: 'else' })).toBeNull();
     expect(outboundShortfall(btcQuote as never, { channels: [{ ready: false, outbound_balance_msat: 900_000_000 }] })).toMatch(/none can send right now/);
     expect(outboundShortfall(btcQuote as never, { channels: [{ channel_id: 'x' }] })).toBeNull();
@@ -367,7 +431,40 @@ describe('kaleidoswapAtomicRecipe — outbound preflight (BTC leg + RLN HTLC min
     });
     expect(res.status).toBe('error');
     expect(res.text).toMatch(/can send at most 3,000 sats.*needs 53,000 sats/);
-    expect(calls).toEqual(['kaleidoswap_get_quote', 'rln_list_channels']);
+    expect(calls).toEqual(['kaleidoswap_get_quote', 'rln_get_node_info', 'rln_list_channels']);
     expect(confirms).toEqual([]);
   });
 });
+
+describe('kaleidoswapAtomicRecipe — amounts and the deterministic path', () => {
+  it('converts a BTC amount said in sats to display units for the quote', async () => {
+    const { quoteAmount } = await import('./kaleidoswap-atomic.js');
+    expect(quoteAmount('BTC', 2500, 'Swap 2500 sats into USDT')).toBe(0.000025);
+    expect(quoteAmount('BTC', 0.001, 'swap 0.001 btc to usdt')).toBe(0.001);
+    expect(quoteAmount('BTC', 100000, 'swap 100000 into usdt')).toBe(0.001);
+    expect(quoteAmount('USDT', 10, 'swap 10 usdt for btc')).toBe(10);
+  });
+
+  it('runs "Swap 2500 sats into USDT" without a model, quoting 0.000025 BTC', async () => {
+    const quoteArgs: unknown[] = [];
+    const tools = new ToolRegistry([
+      new InProcessToolSource('k', [
+        {
+          name: 'kaleidoswap_get_quote',
+          description: 'q',
+          parameters: { type: 'object', properties: {} },
+          handler: async (a: Record<string, unknown>) => {
+            quoteArgs.push(a);
+            return { error: 'stop here' };
+          },
+        },
+      ]),
+    ]);
+    const res = await runRecipe(kaleidoswapAtomicRecipe, 'Swap 2500 sats into USDT on KaleidoSwap', {
+      provider: { name: 'none', async runTurn() { throw new Error('the model must not be called'); } } as LLMProvider,
+      tools,
+    });
+    expect(res.inferences).toBe(0);
+    expect(quoteArgs[0]).toMatchObject({ from_asset_id: 'BTC', to_asset_id: 'USDT', from_amount: 0.000025 });
+  });
+});

package/src/recipe/kaleidoswap-atomic.ts

@@ -85,16 +85,36 @@ interface QuoteResult {
 const layerFor = (asset: unknown): string =>
   /^btc$/i.test(String(asset)) ? 'BTC_LN' : 'RGB_LN';
 
-/** RLN adds this to the taker's BTC HTLC in a BTC→RGB swap (rgb_htlc_min_msat). */
+/**
+ * `kaleidoswap_get_quote` takes display units (0.0005 BTC). The slots carry
+ * what the user said: a BTC amount said in sats ("2500 sats") is converted;
+ * one said in BTC ("0.001 btc") is kept. Without a unit word, below 1 reads as
+ * BTC and 1 or more as sats.
+ */
+export function quoteAmount(asset: unknown, amount: unknown, text = ''): unknown {
+  const n = Number(amount);
+  if (!/^(btc|sats?|bitcoin)$/i.test(String(asset ?? '').trim()) || !Number.isFinite(n)) return amount;
+  const saidSats = /\b(sats?|satoshis?)\b/i.test(text);
+  const saidBtc = /\b(btc|bitcoins?)\b/i.test(text.replace(/\b(sats?|satoshis?)\b/gi, ''));
+  const inSats = saidSats || (!saidBtc && n >= 1);
+  return inSats ? n / 1e8 : n;
+}
+
+/** "swap|convert|exchange|trade|sell <N> <asset> for|to|into <asset>": nothing for a model to resolve. */
+const EXPLICIT_SWAP = /\b(?:swap|convert|exchange|trade|sell)\s+\d[\d,]*(?:\.\d+)?\s*(?:sats?|satoshis?|btc|bitcoin|usdt|xaut)\s+(?:for|to|into)\s+(?:sats?|btc|bitcoin|usdt|xaut)\b/i;
+
+/** RLN's minimum HTLC for RGB payments when the node doesn't report one (rgb_htlc_min_msat). */
 export const RLN_HTLC_MIN_MSAT = 3_000_000;
 
-function paysBtcOverLightning(q?: QuoteResult): boolean {
-  const leg = q?.from_asset as { layer?: string; ticker?: string } | undefined;
-  return leg?.layer === 'BTC_LN' || (!leg?.layer && String(leg?.ticker ?? '').toUpperCase() === 'BTC');
-}
+type Leg = { asset_id?: string; ticker?: string; layer?: string; amount_raw?: number; amount_display?: string };
+type Channel = Record<string, unknown>;
+
+const isBtc = (leg?: Leg) => leg?.layer === 'BTC_LN' || (!leg?.layer && String(leg?.ticker ?? '').toUpperCase() === 'BTC');
+const num = (v: unknown): number | undefined => (v == null || v === '' || !Number.isFinite(Number(v)) ? undefined : Number(v));
+const fmtSats = (msat: number) => `${Math.floor(msat / 1000).toLocaleString('en-US')} sats`;
+const legText = (leg?: Leg) => (leg?.amount_display ? `${leg.amount_display}${leg.ticker && !/sats?$/i.test(leg.amount_display) ? ` ${leg.ticker}` : ''}` : (leg?.ticker ?? 'the asset'));
 
-/** The most one usable channel can send now, in msat; undefined when the shape is unknown. */
-function maxOutboundMsat(channels: unknown): number | undefined {
+function channelRows(channels: unknown): Channel[] | undefined {
   let list: unknown = channels;
   if (typeof list === 'string') {
     try {
@@ -104,37 +124,98 @@ function maxOutboundMsat(channels: unknown): number | undefined {
     }
   }
   const rows = Array.isArray(list) ? list : (list as { channels?: unknown })?.channels;
-  if (!Array.isArray(rows)) return undefined;
-  // No channels at all: nothing can send. Channels without readable amounts:
-  // unknown, so don't block.
-  if (!rows.length) return 0;
+  return Array.isArray(rows) ? (rows as Channel[]) : undefined;
+}
+
+/** Largest value of `pick` over usable channels; undefined when no channel reports it. */
+function maxOver(rows: Channel[], pick: (c: Channel) => number | undefined): number | undefined {
   let best: number | undefined;
   let readable = false;
-  for (const c of rows as Array<Record<string, unknown>>) {
-    const msat = Number(c.next_outbound_htlc_limit_msat ?? c.outbound_balance_msat);
-    if (!Number.isFinite(msat)) continue;
+  for (const c of rows) {
+    const v = pick(c);
+    if (v === undefined) continue;
     readable = true;
     if (c.is_usable === false || c.ready === false) continue;
-    best = Math.max(best ?? 0, msat);
+    best = Math.max(best ?? 0, v);
   }
-  // Readable channels, none usable: nothing can send.
   return best ?? (readable ? 0 : undefined);
 }
 
-const fmtSats = (msat: number) => `${Math.floor(msat / 1000).toLocaleString('en-US')} sats`;
+const outbound = (c: Channel) => num(c.next_outbound_htlc_limit_msat ?? c.outbound_balance_msat);
+const inbound = (c: Channel) => num(c.inbound_balance_msat);
+
+/**
+ * Why the node can't carry this swap over its Lightning channels, or null when
+ * it can (or the channel data doesn't say). RLN sends each leg as one HTLC and
+ * adds its RGB HTLC minimum to the BTC side and to the asset payment:
+ * - BTC → asset: BTC outbound ≥ amount + minimum; an asset channel with inbound
+ *   ≥ the asset received and BTC inbound ≥ minimum.
+ * - asset → BTC: an asset channel holding the asset with BTC outbound ≥
+ *   minimum; BTC inbound ≥ amount + minimum.
+ */
+export function swapLiquidityShortfall(
+  q: QuoteResult | undefined,
+  channels: unknown,
+  htlcMinMsat: number = RLN_HTLC_MIN_MSAT,
+): string | null {
+  const from = q?.from_asset as Leg | undefined;
+  const to = q?.to_asset as Leg | undefined;
+  const fromBtc = isBtc(from);
+  const toBtc = isBtc(to);
+  if (fromBtc === toBtc) return null;
+  const rows = channelRows(channels);
+  if (!rows) return null;
+  const min = fmtSats(htlcMinMsat);
+  if (!rows.length) return `this swap runs over Lightning and you have no channels. Buy a channel first.`;
+  const usable = rows.filter((c) => c.is_usable !== false && c.ready !== false);
+  const hasAssetData = rows.some((c) => 'asset_id' in c);
+
+  if (fromBtc) {
+    const amount = num(from?.amount_raw);
+    const maxOut = maxOver(rows, outbound);
+    if (amount !== undefined && maxOut !== undefined && maxOut < amount + htlcMinMsat) {
+      const need = amount + htlcMinMsat;
+      if (maxOut === 0) {
+        return `this swap needs a Lightning channel that can send ${fmtSats(need)} (the amount plus the ${min} HTLC minimum), and none can send right now. Buy a channel with at least that much outbound first.`;
+      }
+      if (maxOut <= htlcMinMsat) {
+        return `your channels can send at most ${fmtSats(maxOut)}, which only covers the ${min} HTLC minimum, so no BTC swap fits. This one needs ${fmtSats(need)}: buy a channel with more outbound.`;
+      }
+      return `your channels can send at most ${fmtSats(maxOut)}, and this swap needs ${fmtSats(need)} (the amount plus the ${min} HTLC minimum). Swap at most ${fmtSats(Math.max(0, maxOut - htlcMinMsat))}, or buy a bigger channel.`;
+    }
+    const want = num(to?.amount_raw);
+    if (hasAssetData && want !== undefined) {
+      const ok = usable.some(
+        (c) => c.asset_id === to?.asset_id && (num(c.asset_remote_amount) ?? 0) >= want && (inbound(c) ?? Infinity) >= htlcMinMsat,
+      );
+      if (!ok) {
+        return `no channel can receive ${legText(to)}: you need a ${to?.ticker ?? 'asset'} channel with at least that much inbound and ${min} of BTC inbound. Buy an asset channel from the LSP first.`;
+      }
+    }
+    return null;
+  }
 
-/** Why the node can't send this swap's BTC leg, or null when it can (or can't tell). */
-export function outboundShortfall(q: QuoteResult | undefined, channels: unknown): string | null {
-  const amount = Number(q?.from_asset?.amount_raw);
-  const max = maxOutboundMsat(channels);
-  if (!Number.isFinite(amount) || max === undefined) return null;
-  const need = amount + RLN_HTLC_MIN_MSAT;
-  if (max >= need) return null;
-  return max === 0
-    ? `this swap needs a Lightning channel that can send ${fmtSats(need)} (the amount plus RLN's 3,000-sat HTLC minimum), and none can send right now. Buy a channel with at least that much outbound first.`
-    : `your channels can send at most ${fmtSats(max)}, and this swap needs ${fmtSats(need)} (the amount plus RLN's 3,000-sat HTLC minimum). Swap at most ${fmtSats(Math.max(0, max - RLN_HTLC_MIN_MSAT))}, or buy a bigger channel.`;
+  // asset → BTC
+  const have = num(from?.amount_raw);
+  if (hasAssetData && have !== undefined) {
+    const ok = usable.some(
+      (c) => c.asset_id === from?.asset_id && (num(c.asset_local_amount) ?? 0) >= have && (outbound(c) ?? Infinity) >= htlcMinMsat,
+    );
+    if (!ok) {
+      return `no channel can send ${legText(from)}: you need a ${from?.ticker ?? 'asset'} channel holding at least that much, with ${min} of BTC outbound.`;
+    }
+  }
+  const amount = num(to?.amount_raw);
+  const maxIn = maxOver(rows, inbound);
+  if (amount !== undefined && maxIn !== undefined && maxIn < amount + htlcMinMsat) {
+    return `your channels can receive at most ${fmtSats(maxIn)}, and this swap pays you ${fmtSats(amount + htlcMinMsat)} (the amount plus the ${min} HTLC minimum). Swap for less BTC, or get more inbound.`;
+  }
+  return null;
 }
 
+/** @deprecated Use `swapLiquidityShortfall`. */
+export const outboundShortfall = swapLiquidityShortfall;
+
 // Render a quote leg as "<amount> <TICKER>" from the MCP quote echo, or undefined
 // if the leg is missing (callers fall back to the user's slot values).
 const quoteLeg = (leg?: { ticker?: string; amount_display?: string }): string | undefined =>
@@ -160,6 +241,9 @@ export const kaleidoswapAtomicRecipe: Recipe = {
   // always ask the model to produce the actual slots used for execution.
   extract: extractSwap,
   forceModelExtract: true,
+  // An explicit amount + both assets needs no model, which small models
+  // otherwise misread ("2500 sats into USDT" as 2,500 USDT).
+  trustExtract: (text) => EXPLICIT_SWAP.test(text),
   confident: (s) => !!s.from_asset && !!s.to_asset && !!s.amount,
   steps: [
     // 1. MAKER quotes the swap (read-only). Returns rfq_id + full asset specs
@@ -178,22 +262,31 @@ export const kaleidoswapAtomicRecipe: Recipe = {
           from_layer: layerFor(ctx.slots.from_asset),
           to_layer: layerFor(ctx.slots.to_asset),
         };
-        return side === 'to'
-          ? { ...base, to_amount: ctx.slots.amount }
-          : { ...base, from_amount: ctx.slots.amount };
+        const asset = side === 'to' ? ctx.slots.to_asset : ctx.slots.from_asset;
+        const amount = quoteAmount(asset, ctx.slots.amount, ctx.text);
+        return side === 'to' ? { ...base, to_amount: amount } : { ...base, from_amount: amount };
       },
     },
-    // 1b. NODE: the BTC leg goes out as one Lightning HTLC of the amount plus
-    //     RLN's 3,000-sat HTLC minimum, so a channel must be able to send that
-    //     much. Stop here, before the confirmation, instead of failing with
-    //     NoRoute after the maker has locked the swap.
+    // 1b. NODE: pubkey for execute, and the node's RGB HTLC minimum.
+    {
+      tool: 'rln_get_node_info',
+      as: 'node',
+      args: () => ({}),
+    },
+    // 1c. NODE: can the channels carry both legs? RLN sends each leg as one
+    //     HTLC and adds its HTLC minimum. Stop here, before the confirmation,
+    //     instead of failing with NoRoute after the maker has locked the swap.
     {
       tool: 'rln_list_channels',
       as: 'channels',
       optional: true,
       args: () => ({}),
-      skipIf: (ctx) => !paysBtcOverLightning(ctx.results.quote as QuoteResult | undefined),
-      check: (ctx) => outboundShortfall(ctx.results.quote as QuoteResult | undefined, ctx.results.channels),
+      check: (ctx) =>
+        swapLiquidityShortfall(
+          ctx.results.quote as QuoteResult | undefined,
+          ctx.results.channels,
+          num((ctx.results.node as { rgb_htlc_min_msat?: unknown } | undefined)?.rgb_htlc_min_msat) ?? RLN_HTLC_MIN_MSAT,
+        ),
     },
     // 2. MAKER locks the swap. SwapRequest is flat (asset ids + maker-unit
     //    amounts) — sourced straight from the quote result, no re-scaling.
@@ -212,12 +305,6 @@ export const kaleidoswapAtomicRecipe: Recipe = {
         };
       },
     },
-    // 3. NODE: read our pubkey — the maker needs it as taker_pubkey for execute.
-    {
-      tool: 'rln_get_node_info',
-      as: 'node',
-      args: () => ({}),
-    },
     // 4. NODE: the taker whitelists the maker's swapstring (accept the swap).
     //    Exposed by kaleido-mcp as `rln_atomic_taker` (calls rln.whitelistSwap).
     //    Ungated — covered by the single confirm above.

package/src/recipe/runner.ts

@@ -76,7 +76,7 @@ export async function extractSlots(
   const det = recipe.extract?.(text);
   const detValid = det && Object.values(det).some((v) => v !== undefined && v !== null && v !== '');
 
-  if (detValid && !recipe.forceModelExtract) {
+  if (detValid && (!recipe.forceModelExtract || recipe.trustExtract?.(text))) {
     return { slots: det, inferences: 0 };
   }
 

package/src/recipe/types.ts

@@ -62,6 +62,11 @@ export interface Recipe {
    * reliable multi-step execution plan and single-confirmation safety.
    */
   forceModelExtract?: boolean;
+  /**
+   * With `forceModelExtract`, use the deterministic extraction anyway when this
+   * returns true for the request (an unambiguous phrasing).
+   */
+  trustExtract?: (text: string) => boolean;
   /**
    * Whether the recipe is confident enough to RUN deterministically given the
    * extracted slots (vs falling back to the agentic loop). e.g. payments needs a

package/src/wallet/confirm.test.ts

@@ -60,8 +60,8 @@ describe('confirmReadback', () => {
       .toBe('Open a 100,000 sats channel to 03abcd…6789. Confirm?');
     expect(confirmReadback({ name: 'rln_close_channel', arguments: { channel_id: 'chan0123456789abcdef0123', peer_pubkey: 'x', force: true } }))
       .toBe('Force-close channel chan01…0123. Confirm?');
-    expect(confirmReadback({ name: 'rln_atomic_taker', arguments: { swapstring: '30/rgb:asset/10/btc/3600/abcdef0123456789' } }))
-      .toBe('Accept atomic swap 30/rgb…6789 on your node. Confirm?');
+    expect(confirmReadback({ name: 'rln_atomic_taker', arguments: { swapstring: '30/rgb:asset/10000/btc/3600/abcdef0123456789' } }))
+      .toBe('Accept atomic swap 30 units of rgb:asset ⇄ 10 sats (30/rgb…6789). Confirm?');
   });
 
   it('execute_swap: from → to with amount', () => {
@@ -90,3 +90,62 @@ describe('confirmReadback: LSP orders', () => {
     ).toBe('Order a channel from the LSP with 10 USDT inbound. The order total is paid in a separate step. Confirm?');
   });
 });
+
+describe('confirmReadback: accepting an atomic swap', () => {
+  const swapstring = '2500000/btc/1500000/rgb:usdt-abcdefgh/1791400000/ph1';
+  const quote = {
+    name: 'kaleidoswap_get_quote',
+    result: { from_asset: { ticker: 'BTC', amount_display: '2,500 sats' }, to_asset: { ticker: 'USDT', amount_display: '1.5' } },
+  };
+
+  it("shows the run's quote amounts", () => {
+    const init = { name: 'kaleidoswap_atomic_init', result: { swapstring, payment_hash: 'ph1' } };
+    expect(confirmReadback({ name: 'rln_atomic_taker', arguments: { swapstring } }, { results: [quote, init] })).toBe(
+      'Accept the atomic swap: you send 2,500 sats, you receive 1.5 USDT. Confirm?',
+    );
+  });
+
+  it('flags a swapstring that is not the one just created', () => {
+    const init = { name: 'kaleidoswap_atomic_init', result: { swapstring: 'other/btc/1/btc/1/x' } };
+    expect(confirmReadback({ name: 'rln_atomic_taker', arguments: { swapstring } }, { results: [quote, init] })).toMatch(
+      /\(this is not the swap just created\)\. Confirm\?$/,
+    );
+  });
+
+  it('decodes the swapstring when there is no quote', () => {
+    expect(confirmReadback({ name: 'wdk_atomic_taker', arguments: { swapstring } })).toMatch(
+      /^Accept atomic swap 2,500 sats ⇄ 1,500,000 units of rgb:/,
+    );
+  });
+});
+
+describe('confirmReadback: starting a KaleidoSwap swap', () => {
+  const quote = {
+    name: 'kaleidoswap_get_quote',
+    result: {
+      rfq_id: 'rfq-9',
+      from_asset: { ticker: 'BTC', amount_display: '2,500 sats', amount_raw: 2_500_000 },
+      to_asset: { ticker: 'USDT', amount_display: '2.020975', amount_raw: 2_020_975 },
+      expires_at: Math.floor(Date.now() / 1000) + 45,
+    },
+  };
+  const args = { rfq_id: 'rfq-9', from_asset_id: 'BTC', from_amount_raw: 2_500_000, to_asset_id: 'rgb:usdt', to_amount_raw: 2_020_975 };
+
+  it('reads the quote amounts and expiry', () => {
+    expect(confirmReadback({ name: 'kaleidoswap_atomic_init', arguments: args }, { results: [quote] })).toMatch(
+      /^Swap 2,500 sats for 2\.020975 USDT on KaleidoSwap \(quote expires in 4[0-9]s\)\. Confirm\?$/,
+    );
+    expect(confirmReadback({ name: 'kaleidoswap_atomic_execute', arguments: {} }, { results: [quote] })).toBe(
+      'Settle the KaleidoSwap swap: you send 2,500 sats, you receive 2.020975 USDT. Confirm?',
+    );
+  });
+
+  it('flags amounts that differ from the quote, and reads raw amounts without one', () => {
+    expect(confirmReadback({ name: 'kaleidoswap_atomic_init', arguments: { ...args, to_amount_raw: 1 } }, { results: [quote] })).toMatch(
+      /\(the amounts sent differ from the quote\)\. Confirm\?$/,
+    );
+    expect(confirmReadback({ name: 'kaleidoswap_atomic_init', arguments: args })).toBe(
+      'Swap 2,500 sats for 2,020,975 raw units of rgb:usdt on KaleidoSwap (no quote in this conversation). Confirm?',
+    );
+  });
+});

package/src/wallet/confirm.ts

@@ -63,7 +63,86 @@ const asset = (amount: unknown, ticker: unknown) => {
 };
 
 /** A spoken confirmation ending in "Confirm?", or null for non-spend tools. */
-export function confirmReadback(call: { name: string; arguments: Record<string, unknown> }): string | null {
+/** What earlier calls in the same run returned, for readbacks that depend on them. */
+export interface ReadbackContext {
+  results?: Array<{ name: string; result: unknown }>;
+}
+
+type QuoteLeg = { ticker?: string; amount_display?: string };
+
+const legText = (leg?: QuoteLeg) =>
+  leg?.amount_display ? `${leg.amount_display}${leg.ticker && !/sats?$/i.test(leg.amount_display) ? ` ${leg.ticker}` : ''}` : undefined;
+
+const lastResult = (ctx: ReadbackContext | undefined, re: RegExp): Record<string, any> | undefined => {
+  const hit = [...(ctx?.results ?? [])].reverse().find((r) => re.test(r.name));
+  let r = hit?.result;
+  if (typeof r === 'string') {
+    try {
+      r = JSON.parse(r);
+    } catch {
+      return undefined;
+    }
+  }
+  return r && typeof r === 'object' ? (r as Record<string, any>) : undefined;
+};
+
+/** RLN swapstring: qty_from/from_asset/qty_to/to_asset/expiry/payment_hash (BTC in msat). */
+function swapstringLegs(swapstring: string): string | undefined {
+  const [qtyFrom, from, qtyTo, to] = swapstring.split('/');
+  if (!qtyFrom || !from || !qtyTo || !to || !/^\d+$/.test(qtyFrom) || !/^\d+$/.test(qtyTo)) return undefined;
+  const leg = (qty: string, asset: string) =>
+    asset === 'btc' ? sats(Math.floor(Number(qty) / 1000)) : `${Number(qty).toLocaleString('en-US')} units of ${shortRef(asset)}`;
+  return `${leg(qtyFrom, from)} ⇄ ${leg(qtyTo, to)}`;
+}
+
+function expiresIn(expiresAt: unknown): string {
+  const t = Number(expiresAt);
+  if (!Number.isFinite(t) || t <= 0) return '';
+  const secs = Math.round((t > 1e12 ? t : t * 1000) / 1000 - Date.now() / 1000);
+  return secs > 0 ? ` (quote expires in ${secs}s)` : ' (the quote has expired)';
+}
+
+/** One leg from init args alone: BTC raw is msat; an asset's raw units without its precision. */
+function rawLeg(assetId: unknown, raw: unknown): string {
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return String(assetId ?? '?');
+  return /^(btc|sats?)$/i.test(String(assetId ?? '')) ? sats(Math.floor(n / 1000)) : `${n.toLocaleString('en-US')} raw units of ${shortRef(String(assetId ?? '?'))}`;
+}
+
+function atomicInitReadback(a: Record<string, unknown>, ctx?: ReadbackContext): string {
+  const quote = lastResult(ctx, /(^|_)get_quote$/);
+  const from = legText(quote?.from_asset);
+  const to = legText(quote?.to_asset);
+  if (quote && from && to && (!a.rfq_id || !quote.rfq_id || a.rfq_id === quote.rfq_id)) {
+    const differs =
+      (a.from_amount_raw != null && quote.from_asset?.amount_raw != null && Number(a.from_amount_raw) !== Number(quote.from_asset.amount_raw)) ||
+      (a.to_amount_raw != null && quote.to_asset?.amount_raw != null && Number(a.to_amount_raw) !== Number(quote.to_asset.amount_raw));
+    return `Swap ${from} for ${to} on KaleidoSwap${expiresIn(quote.expires_at)}${differs ? ' (the amounts sent differ from the quote)' : ''}`;
+  }
+  return `Swap ${rawLeg(a.from_asset_id, a.from_amount_raw)} for ${rawLeg(a.to_asset_id, a.to_amount_raw)} on KaleidoSwap (no quote in this conversation)`;
+}
+
+function atomicExecuteReadback(ctx?: ReadbackContext): string {
+  const quote = lastResult(ctx, /(^|_)get_quote$/);
+  const from = legText(quote?.from_asset);
+  const to = legText(quote?.to_asset);
+  return from && to ? `Settle the KaleidoSwap swap: you send ${from}, you receive ${to}` : 'Settle the KaleidoSwap atomic swap';
+}
+
+function atomicTakerReadback(swapstring: string, ctx?: ReadbackContext): string {
+  const quote = lastResult(ctx, /(^|_)get_quote$/);
+  const init = lastResult(ctx, /(^|_)atomic_init$/);
+  const from = legText(quote?.from_asset);
+  const to = legText(quote?.to_asset);
+  if (from && to) {
+    const other = init?.swapstring && init.swapstring !== swapstring ? ' (this is not the swap just created)' : '';
+    return `Accept the atomic swap: you send ${from}, you receive ${to}${other}`;
+  }
+  const legs = swapstringLegs(swapstring);
+  return legs ? `Accept atomic swap ${legs} (${shortRef(swapstring)})` : `Accept atomic swap ${shortRef(swapstring)}`;
+}
+
+export function confirmReadback(call: { name: string; arguments: Record<string, unknown> }, context?: ReadbackContext): string | null {
   const { name, arguments: a } = call;
   const to = (k = 'to') => shortRef(String(a[k] ?? ''));
   const ask = (s: string) => `${s}. Confirm?`;
@@ -102,8 +181,13 @@ export function confirmReadback(call: { name: string; arguments: Record<string,
     }
     case 'rln_close_channel':
       return ask(`${a.force ? 'Force-close' : 'Close'} channel ${shortRef(String(a.channel_id ?? ''))}`);
+    case 'kaleidoswap_atomic_init':
+      return ask(atomicInitReadback(a, context));
+    case 'kaleidoswap_atomic_execute':
+      return ask(atomicExecuteReadback(context));
     case 'rln_atomic_taker':
-      return ask(`Accept atomic swap ${shortRef(String(a.swapstring ?? ''))} on your node`);
+    case 'wdk_atomic_taker':
+      return ask(atomicTakerReadback(String(a.swapstring ?? ''), context));
     case 'execute_swap':
       return ask(`Swap ${asset(a.amount, a.from_asset)} for ${label(a.to_asset)}`);
     // The order total is only known once the LSP creates the order; the