@kaleidorg/mind 0.4.0 → 0.5.0

package/src/lsps1/contract.ts

@@ -50,31 +50,49 @@ export const LSPS1_TOOLS: Lsps1ToolDef[] = [
     "Get the LSP's Lightning network info: pubkey, host, port, connect URI. Useful to display the counterparty or pre-connect a peer. No args."),
 
   t('lsp_estimate_fees',
-    "Estimate the fee for a channel order BEFORE committing. Returns the total cost in sats plus any LSP routing fee. Re-estimate rather than reusing a stale value.",
+    "Estimate the channel-order fee BEFORE committing. Returns setup_fee, capacity_fee, duration_fee, total_fee (all in sats). Re-estimate rather than reusing a stale value.",
     {
-      lsp_balance_sat:    { type: 'number', description: "Sats the LSP commits on their side (inbound capacity for the user)." },
-      client_balance_sat: { type: 'number', description: "Sats the user pre-funds into the channel (push amount). Often 0." },
-      channel_expiry_blocks: { type: 'number', description: 'Optional minimum lease in blocks. Defaults to the LSP minimum.' },
+      lsp_balance_sat:       { type: 'number', description: "Sats the LSP commits on their side (inbound capacity for the user)." },
+      client_balance_sat:    { type: 'number', description: "Sats the user pre-funds into the channel (push amount). Default 0." },
+      channel_expiry_blocks: { type: 'number', description: 'Lease duration in blocks. Default 4320 (~30 days). Maker maximum is typically 20160 (~140 days).' },
+      // RGB asset channels (optional):
+      asset_id:              { type: 'string', description: 'For RGB asset channels — the asset to provision liquidity for.' },
+      lsp_asset_amount:      { type: 'number', description: 'Asset units the LSP commits (RGB channels only).' },
+      client_asset_amount:   { type: 'number', description: 'Asset units the user pre-funds (RGB channels only). Requires rfq_id.' },
+      rfq_id:                { type: 'string', description: 'Quote id from kaleidoswap_get_quote — required when client_asset_amount > 0.' },
+      token:                 { type: 'string', description: 'Optional discount/affiliate token.' },
     },
-    ['lsp_balance_sat']),
+    ['lsp_balance_sat', 'client_balance_sat', 'channel_expiry_blocks']),
 
   t('lsp_create_order',
-    "Create a channel order. SPEND: confirmation-gated. Returns an order id + a Lightning invoice the user pays to lock the order. The channel opens only after payment.",
+    "Create a channel order. SPEND: confirmation-gated. Returns order_id + access_token + a payment.bolt11.invoice the user pays to lock the order. The channel opens only after payment.",
     {
-      lsp_balance_sat:    { type: 'number', description: "Sats the LSP commits on their side (inbound capacity for the user)." },
-      client_balance_sat: { type: 'number', description: 'Sats the user pre-funds. Often 0.' },
-      channel_expiry_blocks: { type: 'number', description: 'Minimum lease in blocks. Defaults to LSP minimum from lsp_get_info.' },
-      refund_onchain_address: { type: 'string', description: 'Optional on-chain refund address if the LSP cannot open the channel.' },
+      client_pubkey:                  { type: 'string', description: "User's Lightning node pubkey — the LSP opens the channel TO this node. Get it from rln_get_node_info." },
+      lsp_balance_sat:                { type: 'number', description: "Sats the LSP commits on their side (inbound capacity for the user)." },
+      client_balance_sat:             { type: 'number', description: "Sats the user pre-funds. Default 0." },
+      required_channel_confirmations: { type: 'number', description: 'Number of confs the user wants before considering the channel usable. Default 1.' },
+      funding_confirms_within_blocks: { type: 'number', description: 'Max blocks within which funding must confirm. Default 6.' },
+      channel_expiry_blocks:          { type: 'number', description: 'Lease duration in blocks. Default 4320 (~30 days).' },
+      announce_channel:               { type: 'boolean', description: 'Public (true) or unannounced (false). Default true.' },
+      refund_onchain_address:         { type: 'string', description: 'Optional on-chain refund address if the LSP cannot open the channel.' },
+      // RGB asset channels (optional):
+      asset_id:                       { type: 'string', description: 'For RGB asset channels.' },
+      lsp_asset_amount:               { type: 'number', description: 'Asset units the LSP commits.' },
+      client_asset_amount:            { type: 'number', description: 'Asset units the user pre-funds.' },
+      rfq_id:                         { type: 'string', description: 'Required when client_asset_amount > 0.' },
+      token:                          { type: 'string', description: 'Optional discount/affiliate token.' },
+      email:                          { type: 'string', description: 'Optional contact for order updates.' },
     },
-    ['lsp_balance_sat'],
+    ['client_pubkey', 'lsp_balance_sat'],
     /* spend */ true),
 
   t('lsp_get_order',
-    'Check the status of an LSPS1 order — pending / paid / opening / completed / failed. Poll after creating an order until the channel opens.',
+    'Check the status of an LSPS1 order. order_state progresses CREATED → CHANNEL_OPENING → COMPLETED (or FAILED). ALWAYS pass BOTH the order_id and the access_token from lsp_create_order (the access_token is required for order status).',
     {
-      order_id: { type: 'string', description: 'The order id from lsp_create_order.' },
+      order_id:     { type: 'string', description: 'The order id from lsp_create_order.' },
+      access_token: { type: 'string', description: 'The per-order access token returned by lsp_create_order. Required for non-admin reads.' },
     },
-    ['order_id']),
+    ['order_id', 'access_token']),
 ];
 
 /** All LSPS1 tool names that move funds (confirmation-gated). */

package/src/recipe/buy-asset-channel.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ToolRegistry } from '../tools/registry.js';
+import { InProcessToolSource } from '../tools/in-process.js';
+import type { LLMProvider } from '../providers/types.js';
+import { runRecipe, RecipeRegistry } from './runner.js';
+import { buyAssetChannelRecipe, extractBuyAsset } from './buy-asset-channel.js';
+import { swapRecipe } from './swap.js';
+import { assetSendRecipe } from './asset-send.js';
+
+const approve: LLMProvider = { name: 'x', runTurn: async () => ({ text: '', rawContent: '', toolCalls: [] }) };
+
+/** Stub the two asset-channel tools the recipe drives. */
+function stubTools(spy?: { create?: (a: any) => void }) {
+  return new ToolRegistry([
+    new InProcessToolSource('ks', [
+      {
+        name: 'kaleidoswap_lsp_quote_asset_channel',
+        description: '',
+        parameters: { type: 'object', properties: {} },
+        handler: async (a) => ({
+          rfq_id: 'rfq1',
+          asset_amount: a.asset_amount,
+          btc_amount_sat: 13807,
+          channel_fee_sat: 16139,
+          total_sat: 29946,
+          expires_at: 1234567890,
+        }),
+      },
+      {
+        name: 'kaleidoswap_lsp_create_asset_channel',
+        description: '',
+        parameters: { type: 'object', properties: {} },
+        requiresConfirmation: true,
+        handler: async (a) => {
+          spy?.create?.(a);
+          return { order_id: 'ord1', total_sat: 29946, payment: { onchain_address: 'bcrt1qexample' } };
+        },
+      },
+    ]),
+  ]);
+}
+
+describe('extractBuyAsset (deterministic Tier-0)', () => {
+  it('parses "buy 100 usdt"', () => {
+    expect(extractBuyAsset('buy 100 usdt')).toEqual({ asset: 'USDT', asset_amount: 100 });
+  });
+  it('parses "get me 50 xaut"', () => {
+    expect(extractBuyAsset('get me 50 xaut')).toEqual({ asset: 'XAUT', asset_amount: 50 });
+  });
+  it('parses "i want 200 usdt" and "purchase 10 xaut"', () => {
+    expect(extractBuyAsset('i want 200 usdt')).toEqual({ asset: 'USDT', asset_amount: 200 });
+    expect(extractBuyAsset('purchase 10 xaut')).toEqual({ asset: 'XAUT', asset_amount: 10 });
+  });
+  it('handles comma grouping in the amount', () => {
+    expect(extractBuyAsset('buy 1,000 usdt')).toEqual({ asset: 'USDT', asset_amount: 1000 });
+  });
+  it('null for a swap (a named source asset ⇒ swap owns it)', () => {
+    expect(extractBuyAsset('buy 0.001 btc with usdt')).toBeNull();
+    expect(extractBuyAsset('swap 10 usdt for btc')).toBeNull();
+    expect(extractBuyAsset('buy 100 usdt with my bitcoin')).toBeNull();
+  });
+  it('null for a send (asset-send owns it)', () => {
+    expect(extractBuyAsset('send 10 usdt to bob')).toBeNull();
+  });
+  it('null for BTC (BTC is not bought via an asset channel)', () => {
+    expect(extractBuyAsset('buy 100000 sats')).toBeNull();
+    expect(extractBuyAsset('get 0.01 btc')).toBeNull();
+  });
+});
+
+describe('runRecipe — buy asset channel', () => {
+  it('quote → confirm → create order, deterministic (0 inferences)', async () => {
+    const created: any[] = [];
+    const tools = stubTools({ create: (a) => created.push(a) });
+    const onConfirm = vi.fn(async () => ({ approved: true }));
+    const res = await runRecipe(buyAssetChannelRecipe, 'buy 100 usdt', { provider: approve, tools, onConfirm });
+
+    expect(res.status).toBe('done');
+    expect(res.inferences).toBe(0);
+    expect(onConfirm).toHaveBeenCalledOnce();
+    expect(res.results.quote).toMatchObject({ rfq_id: 'rfq1' });
+    expect(created[0]).toMatchObject({ asset: 'USDT', asset_amount: 100, rfq_id: 'rfq1' });
+    // The quote's cost rides along for the confirm card.
+    expect(created[0]).toMatchObject({ total_sat: 29946, btc_amount_sat: 13807, channel_fee_sat: 16139 });
+    expect(res.text).toContain('100 USDT');
+    expect(res.text).toContain('29,946');
+  });
+
+  it('denied confirmation → cancelled, no order placed', async () => {
+    const created: any[] = [];
+    const tools = stubTools({ create: (a) => created.push(a) });
+    const res = await runRecipe(buyAssetChannelRecipe, 'buy 100 usdt', {
+      provider: approve,
+      tools,
+      onConfirm: async () => ({ approved: false }),
+    });
+    expect(res.status).toBe('cancelled');
+    expect(created).toHaveLength(0);
+  });
+
+  it('fails closed when no confirm handler is wired (spend never runs)', async () => {
+    const created: any[] = [];
+    const tools = stubTools({ create: (a) => created.push(a) });
+    const res = await runRecipe(buyAssetChannelRecipe, 'buy 100 usdt', { provider: approve, tools });
+    expect(res.status).toBe('cancelled');
+    expect(created).toHaveLength(0);
+  });
+
+  it('falls back to ONE LLM extraction when the regex misses', async () => {
+    const created: any[] = [];
+    const tools = stubTools({ create: (a) => created.push(a) });
+    const llmOnly = { ...buyAssetChannelRecipe, extract: undefined };
+    const provider: LLMProvider = {
+      name: 'mock',
+      runTurn: vi.fn(async () => ({
+        text: '',
+        rawContent: '',
+        toolCalls: [{ id: '1', name: 'extract_request', arguments: { asset: 'USDT', asset_amount: 100 } }],
+      })),
+    };
+    const res = await runRecipe(llmOnly, 'could you set me up with a hundred tether', {
+      provider,
+      tools,
+      onConfirm: async () => ({ approved: true }),
+    });
+    expect(res.inferences).toBe(1);
+    expect(provider.runTurn).toHaveBeenCalledOnce();
+    expect(created[0]).toMatchObject({ asset: 'USDT', asset_amount: 100, rfq_id: 'rfq1' });
+  });
+});
+
+describe('recipe selection / precedence', () => {
+  it('selects buy-asset-channel before swap for "buy 100 usdt"', () => {
+    const reg = new RecipeRegistry([buyAssetChannelRecipe, swapRecipe]);
+    expect(reg.select('buy 100 usdt')?.name).toBe('buy-asset-channel');
+    expect(reg.select('get me 50 xaut')?.name).toBe('buy-asset-channel');
+  });
+  it('does not hijack a swap or an asset send', () => {
+    const reg = new RecipeRegistry([buyAssetChannelRecipe, swapRecipe, assetSendRecipe]);
+    expect(reg.select('swap 10 usdt for btc')?.name).not.toBe('buy-asset-channel');
+    expect(reg.select('send 10 usdt to bob')?.name).not.toBe('buy-asset-channel');
+  });
+  it('confident only with both asset and a positive amount', () => {
+    expect(buyAssetChannelRecipe.confident!({ asset: 'USDT', asset_amount: 100 })).toBe(true);
+    expect(buyAssetChannelRecipe.confident!({ asset: 'USDT' })).toBe(false);
+    expect(buyAssetChannelRecipe.confident!({ asset: 'USDT', asset_amount: 0 })).toBe(false);
+  });
+});

package/src/recipe/buy-asset-channel.ts

@@ -0,0 +1,118 @@
+/**
+ * Built-in "buy an asset channel" recipe — the onboarding buy.
+ *
+ * The user has on-chain BTC but no Lightning channel yet, and wants to HOLD an
+ * RGB asset (USDT, XAUT). They can't swap (no channel to swap inside), so they
+ * buy a NEW channel from the maker LSP pre-loaded with the asset. One quote,
+ * one spend:
+ *
+ *   "buy 100 usdt"  /  "get me 50 xaut"  /  "i want 200 usdt"
+ *     ↓ 1 model inference (slot extraction; 0 when the regex hits)
+ *   kaleidoswap_lsp_quote_asset_channel    ← maker prices the asset + channel
+ *   kaleidoswap_lsp_create_asset_channel 🔒 ← (final) order it; pay to open
+ *
+ * Distinct from `swapRecipe`: a swap names a source asset ("swap 10 usdt FOR
+ * btc", "buy btc WITH usdt") and needs an existing channel. This is the
+ * no-source, no-channel onboarding path — "buy <amount> <asset>" with nothing
+ * to spend it from — so it must be SELECTED BEFORE swap for that phrasing.
+ *
+ * Opt-in: register via `Funnel.recipes` (like `kaleidoswapAtomicRecipe`). The
+ * host binds `kaleidoswap_lsp_*` to its transport (maker REST / MCP / WDK).
+ */
+
+import type { Recipe } from './types.js';
+
+/** RGB assets the maker sells as an asset channel. BTC is never "bought" this way. */
+const RGB_ASSET = /\b(usdt|tether|xaut|gold)\b/i;
+/** A named funding source ⇒ this is a swap, not an onboarding buy. */
+const HAS_SOURCE = /\b(?:with|using|from)\b|\bfor\s+(?:btc|bitcoin|sats?|usdt|xaut|tether|gold)\b/i;
+/** Verbs other intents own (swap / sell / send) — never an onboarding buy. */
+const NOT_BUY = /\b(swap|exchange|convert|trade|sell|send)\b/i;
+/** Acquire verbs that DO mean an onboarding buy. */
+const BUY_VERB = /\b(buy|get|acquire|want|purchase|onboard|need)\b/i;
+
+function normAsset(a?: string): string | undefined {
+  if (!a) return undefined;
+  const x = a.toLowerCase();
+  if (/usdt|tether/.test(x)) return 'USDT';
+  if (/xaut|gold/.test(x)) return 'XAUT';
+  return undefined;
+}
+
+const num = (s?: string): number | undefined => {
+  if (!s) return undefined;
+  const n = Number(s.replace(/,/g, ''));
+  return Number.isFinite(n) ? n : undefined;
+};
+
+/** Thousands separators, locale-independent (deterministic for tests). */
+const commas = (n: number): string => String(n).replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+
+/** "buy 100 usdt" / "get me 50 xaut" / "i want 200 usdt" / "purchase 10 xaut". */
+export function extractBuyAsset(text: string): Record<string, unknown> | null {
+  const t = text.trim();
+  if (NOT_BUY.test(t) || HAS_SOURCE.test(t)) return null;
+  if (!RGB_ASSET.test(t)) return null;
+  // buy/get/want/acquire/purchase [me] <amount> <asset>
+  const m = t.match(/\b(?:buy|get|acquire|want|purchase|onboard|need)\b(?:\s+me)?\s+([\d.,]+)\s*([a-z]+)/i);
+  if (!m) return null;
+  const asset = normAsset(m[2]);
+  const amount = num(m[1]);
+  if (!asset || amount === undefined) return null;
+  return { asset, asset_amount: amount };
+}
+
+export const buyAssetChannelRecipe: Recipe = {
+  name: 'buy-asset-channel',
+  description:
+    'Onboarding buy: purchase a new Lightning channel pre-loaded with an RGB asset (USDT, XAUT) from the maker LSP — for a user with on-chain BTC but no channel yet. Quote, then order (with confirmation).',
+  // "buy/get/want N <rgb-asset>" with NO named source asset and NO swap/send verb.
+  match: (t) => !NOT_BUY.test(t) && !HAS_SOURCE.test(t) && RGB_ASSET.test(t) && BUY_VERB.test(t),
+  triggers: ['buy', 'get', 'purchase', 'acquire'],
+  slots: [
+    { name: 'asset', type: 'string', description: 'RGB asset to acquire (USDT or XAUT)', required: true },
+    { name: 'asset_amount', type: 'number', description: 'Amount of the asset to load into the channel (display units, e.g. 100)', required: true },
+  ],
+  extract: extractBuyAsset,
+  confident: (s) => !!s.asset && s.asset_amount !== undefined && Number(s.asset_amount) > 0,
+  steps: [
+    // 1. Maker prices the asset + the channel.
+    //    Returns { rfq_id, btc_amount_sat, channel_fee_sat, total_sat, expires_at }.
+    {
+      tool: 'kaleidoswap_lsp_quote_asset_channel',
+      as: 'quote',
+      args: (ctx) => ({ asset: ctx.slots.asset, asset_amount: ctx.slots.asset_amount }),
+    },
+  ],
+  // 2. Order the channel with the fresh rfq_id. Spend → confirmation-gated.
+  //    The quote's cost fields ride along so the host's confirm card can show
+  //    the price before approval; the create tool treats them as display-only.
+  final: {
+    tool: 'kaleidoswap_lsp_create_asset_channel',
+    args: (ctx) => {
+      const q = (ctx.results.quote ?? {}) as {
+        rfq_id?: string;
+        total_sat?: number;
+        btc_amount_sat?: number;
+        channel_fee_sat?: number;
+        expires_at?: number;
+      };
+      return {
+        asset: ctx.slots.asset,
+        asset_amount: ctx.slots.asset_amount,
+        rfq_id: q.rfq_id,
+        total_sat: q.total_sat,
+        btc_amount_sat: q.btc_amount_sat,
+        channel_fee_sat: q.channel_fee_sat,
+        expires_at: q.expires_at,
+      };
+    },
+  },
+  summary: (ctx, finalResult) => {
+    const q = ctx.results.quote as { total_sat?: number } | undefined;
+    const o = finalResult as { order_id?: string } | undefined;
+    const cost = typeof q?.total_sat === 'number' ? ` for ${commas(q.total_sat)} sats` : '';
+    const id = o?.order_id ? ` (order ${o.order_id})` : '';
+    return `Ordered a Lightning channel with ${ctx.slots.asset_amount} ${ctx.slots.asset}${cost}${id}. Pay the returned invoice/address to open it.`;
+  },
+};

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

@@ -5,15 +5,19 @@ import type { LLMProvider } from '../providers/types.js';
 import { runRecipe } from './runner.js';
 import { kaleidoswapAtomicRecipe } from './kaleidoswap-atomic.js';
 
-// LLM provider that should never be called when slots are extracted deterministically.
+// LLM provider that should never be called when slots are pre-supplied to runRecipe
+// (or when a recipe is not using forceModelExtract).
 const refusingProvider: LLMProvider = {
   name: 'refusing',
   runTurn: async () => {
-    throw new Error('provider should NOT be called when extractSwap succeeds');
+    throw new Error('provider should NOT be called (slots pre-supplied or det path)');
   },
 };
 
-// Stub tools that record every call so we can assert the chain ran end-to-end.
+/**
+ * Stub the maker + node tools. The quote echoes full asset specs (asset_id +
+ * maker-unit amount) the way the real maker does, so init can source them.
+ */
 function buildStubs(captured: { name: string; args: any }[]) {
   const tool = (name: string, response: any, spend = false) => ({
     name,
@@ -27,112 +31,181 @@ function buildStubs(captured: { name: string; args: any }[]) {
   });
   return new ToolRegistry([
     new InProcessToolSource('kaleidoswap', [
-      tool('kaleidoswap_get_quote', { quote_id: 'q-1', receive_amount: 100, fees: 250 }),
-      tool('kaleidoswap_atomic_init', { atomic_id: 'a-1', maker_invoice: 'lnbc1maker' }, /* spend */ true),
-      tool('kaleidoswap_atomic_execute', { status: 'completed' }, /* spend */ true),
+      tool('kaleidoswap_get_quote', {
+        rfq_id: 'rfq-1',
+        from_asset: { asset_id: 'USDT', ticker: 'USDT', amount: 10_000_000 },
+        to_asset: { asset_id: 'BTC', ticker: 'BTC', amount: 15_250_000 },
+        from_amount_display: '10 USDT',
+        to_amount_display: '15,250 sats',
+        fee_display: '154 sats',
+      }),
+      tool('kaleidoswap_atomic_init', { swapstring: 'SWAP/abc/def', payment_hash: 'ph-1' }, /* spend */ true),
+      tool('kaleidoswap_atomic_execute', { status: 200, message: 'Swap executed successfully.' }, /* spend */ true),
     ]),
     new InProcessToolSource('rln', [
-      tool('rln_create_rgb_invoice', { invoice: 'rgb:invoice:USDT:100' }),
-      tool('rln_create_ln_invoice', { invoice: 'lnbc1user' }),
-      tool('rln_pay_invoice', { status: 'SUCCESS', payment_hash: 'h' }, /* spend */ true),
+      tool('rln_get_node_info', { pubkey: '03c31dae' }),
+      tool('rln_whitelist_swap', { ok: true }, /* spend */ true),
     ]),
   ]);
 }
 
-describe('kaleidoswapAtomicRecipe — selection (match + triggers)', () => {
-  it('triggers on explicit atomic-swap phrasings', () => {
-    expect(kaleidoswapAtomicRecipe.match!('atomic swap 100000 sats for usdt')).toBe(true);
-    expect(kaleidoswapAtomicRecipe.match!('trustless swap btc to usdt')).toBe(true);
-    expect(kaleidoswapAtomicRecipe.match!('htlc swap 1000 sats to USDT')).toBe(true);
+describe('kaleidoswapAtomicRecipe — selection', () => {
+  it('triggers on swap phrasings', () => {
+    expect(kaleidoswapAtomicRecipe.match!('swap 10 usdt to btc')).toBe(true);
+    expect(kaleidoswapAtomicRecipe.match!('exchange 100000 sats for usdt')).toBe(true);
+    expect(kaleidoswapAtomicRecipe.match!('convert btc to usdt')).toBe(true);
   });
+  it('triggers on buy/sell of a crypto asset (the reported bug)', () => {
+    expect(kaleidoswapAtomicRecipe.match!('buy one usdt from kaleido')).toBe(true);
+    expect(kaleidoswapAtomicRecipe.match!('sell 100 usdt')).toBe(true);
+  });
+  it('does NOT trigger on buying a gift card (that is commerce, not a swap)', () => {
+    expect(kaleidoswapAtomicRecipe.match!('buy a gift card')).toBe(false);
+    expect(kaleidoswapAtomicRecipe.match!('buy an amazon voucher')).toBe(false);
+  });
+  it('does not trigger on a balance question', () => {
+    expect(kaleidoswapAtomicRecipe.match!('what is my balance')).toBe(false);
+  });
+});
+
+describe('kaleidoswapAtomicRecipe — forceModelExtract (less deterministic slot parsing)', () => {
+  it('always uses 1 LLM inference for slots even when a det extract would succeed (model does the NL understanding)', async () => {
+    const captured: { name: string; args: any }[] = [];
+    const tools = buildStubs(captured);
+
+    // Provider that handles the synthetic extract_request tool the runner builds.
+    const modelExtractProvider: LLMProvider = {
+      name: 'model-extract',
+      runTurn: async (input) => {
+        // The runner sends a single-turn request with the extract tool.
+        const call = input.tools?.find((t) => t.name === 'extract_request');
+        if (call && input.messages.some((m) => m.role === 'user' && /usdt/i.test(m.content || ''))) {
+          // Simulate the model correctly parsing a natural "buy" phrasing.
+          return {
+            text: '',
+            rawContent: '',
+            toolCalls: [{
+              id: 'ex1',
+              name: 'extract_request',
+              arguments: { from_asset: 'BTC', to_asset: 'USDT', amount: 1, amount_side: 'to' },
+            }],
+          };
+        }
+        return { text: '', rawContent: '', toolCalls: [] };
+      },
+    };
 
-  it('does NOT fire on a plain swap (those go to swapRecipe)', () => {
-    expect(kaleidoswapAtomicRecipe.match!('swap 10 usdt for btc')).toBe(false);
-    expect(kaleidoswapAtomicRecipe.match!('exchange 1000 sats for usdt')).toBe(false);
+    const res = await runRecipe(kaleidoswapAtomicRecipe, 'buy 1 usdt', {
+      provider: modelExtractProvider,
+      tools,
+      onConfirm: async () => ({ approved: true }),
+    });
+
+    expect(res.status).toBe('done');
+    expect(res.inferences).toBe(1); // forced through the model
+    // The execution still used the model-provided slots (from_asset came from the "model" not regex default).
+    // (The stub quote in the test is for USDT→BTC, but the point is the inference count + that it ran.)
+    expect(captured[0].name).toBe('kaleidoswap_get_quote');
   });
 });
 
-describe('kaleidoswapAtomicRecipe — RGB receive leg', () => {
-  it('runs quote → rgb_invoice → atomic_init → pay → atomic_execute (one inference)', async () => {
+describe('kaleidoswapAtomicRecipe — full chain', () => {
+  it('runs quote → init → nodeinfo → whitelist → execute in order (one inference)', async () => {
     const captured: { name: string; args: any }[] = [];
     const tools = buildStubs(captured);
 
-    const res = await runRecipe(kaleidoswapAtomicRecipe, 'atomic swap 100000 sats for usdt', {
+    const res = await runRecipe(kaleidoswapAtomicRecipe, 'swap 10 usdt to btc', {
       provider: refusingProvider,
       tools,
       onConfirm: async () => ({ approved: true }),
+      // Pre-supply slots so refusingProvider is not hit. This simulates a
+      // successful prior extraction (the normal fast path for most recipes,
+      // or the early Funnel heuristic for forceModelExtract recipes).
+      slots: { from_asset: 'USDT', to_asset: 'BTC', amount: 10, amount_side: 'from' },
     });
 
     expect(res.status).toBe('done');
-    expect(res.inferences).toBe(0); // extractSwap handled it deterministically
-
-    // The chain: quote → rgb_invoice → atomic_init → pay → atomic_execute (5 calls).
+    expect(res.inferences).toBe(0);
     expect(captured.map((c) => c.name)).toEqual([
       'kaleidoswap_get_quote',
-      'rln_create_rgb_invoice',
       'kaleidoswap_atomic_init',
-      'rln_pay_invoice',
+      'rln_get_node_info',
+      'rln_whitelist_swap',
       'kaleidoswap_atomic_execute',
     ]);
+  });
 
-    // RGB invoice fed into atomic_init.
+  it('threads quote → init args (flat asset ids + maker-unit amounts)', async () => {
+    const captured: { name: string; args: any }[] = [];
+    const tools = buildStubs(captured);
+    await runRecipe(kaleidoswapAtomicRecipe, 'swap 10 usdt to btc', {
+      provider: refusingProvider, tools, onConfirm: async () => ({ approved: true }),
+      slots: { from_asset: 'USDT', to_asset: 'BTC', amount: 10, amount_side: 'from' },
+    });
     const init = captured.find((c) => c.name === 'kaleidoswap_atomic_init')!;
-    expect(init.args).toEqual({ quote_id: 'q-1', receive_invoice: 'rgb:invoice:USDT:100' });
-
-    // Maker invoice fed into pay step.
-    const pay = captured.find((c) => c.name === 'rln_pay_invoice')!;
-    expect(pay.args).toEqual({ invoice: 'lnbc1maker' });
+    expect(init.args).toEqual({
+      rfq_id: 'rfq-1',
+      from_asset: 'USDT', from_amount: 10_000_000,
+      to_asset: 'BTC', to_amount: 15_250_000,
+    });
+  });
 
-    // Final execute carried the atomic id.
+  it('threads init.swapstring + node.pubkey + init.payment_hash → execute', async () => {
+    const captured: { name: string; args: any }[] = [];
+    const tools = buildStubs(captured);
+    await runRecipe(kaleidoswapAtomicRecipe, 'swap 10 usdt to btc', {
+      provider: refusingProvider, tools, onConfirm: async () => ({ approved: true }),
+      slots: { from_asset: 'USDT', to_asset: 'BTC', amount: 10, amount_side: 'from' },
+    });
+    const whitelist = captured.find((c) => c.name === 'rln_whitelist_swap')!;
+    expect(whitelist.args).toEqual({ swapstring: 'SWAP/abc/def' });
     const exe = captured.find((c) => c.name === 'kaleidoswap_atomic_execute')!;
-    expect(exe.args).toEqual({ atomic_id: 'a-1' });
+    expect(exe.args).toEqual({
+      swapstring: 'SWAP/abc/def',
+      taker_pubkey: '03c31dae',
+      payment_hash: 'ph-1',
+    });
   });
 });
 
-describe('kaleidoswapAtomicRecipe — BTC receive leg', () => {
-  it('uses rln_create_ln_invoice (not rgb) when to_asset is BTC', async () => {
+describe('kaleidoswapAtomicRecipe — single confirmation', () => {
+  it('fires ONE gate (before init), showing the quote summary, then runs ungated', async () => {
     const captured: { name: string; args: any }[] = [];
     const tools = buildStubs(captured);
+    const confirms: { name: string; summary?: string }[] = [];
 
-    const res = await runRecipe(kaleidoswapAtomicRecipe, 'atomic swap 100 usdt for btc', {
+    const res = await runRecipe(kaleidoswapAtomicRecipe, 'swap 10 usdt to btc', {
       provider: refusingProvider,
       tools,
-      onConfirm: async () => ({ approved: true }),
+      onConfirm: async (call) => {
+        confirms.push({ name: call.name, summary: (call as any).summary });
+        return { approved: true };
+      },
+      slots: { from_asset: 'USDT', to_asset: 'BTC', amount: 10, amount_side: 'from' },
     });
 
     expect(res.status).toBe('done');
-    expect(captured.map((c) => c.name)).toEqual([
-      'kaleidoswap_get_quote',
-      'rln_create_ln_invoice',
-      'kaleidoswap_atomic_init',
-      'rln_pay_invoice',
-      'kaleidoswap_atomic_execute',
-    ]);
-    const init = captured.find((c) => c.name === 'kaleidoswap_atomic_init')!;
-    expect(init.args.receive_invoice).toBe('lnbc1user');
+    // Exactly one confirm, on the first spend step (init), with the rich summary.
+    expect(confirms).toHaveLength(1);
+    expect(confirms[0]!.name).toBe('kaleidoswap_atomic_init');
+    expect(confirms[0]!.summary).toContain('10 USDT');
+    expect(confirms[0]!.summary).toContain('15,250 sats');
+    expect(confirms[0]!.summary).toContain('154 sats');
   });
-});
 
-describe('kaleidoswapAtomicRecipe — confirmation gate', () => {
-  it('cancels the chain when the user declines a spend gate', async () => {
+  it('declining the single gate cancels the whole chain before any spend', async () => {
     const captured: { name: string; args: any }[] = [];
     const tools = buildStubs(captured);
-    let firstSpendSeen = false;
 
-    const res = await runRecipe(kaleidoswapAtomicRecipe, 'atomic swap 100000 sats for usdt', {
+    const res = await runRecipe(kaleidoswapAtomicRecipe, 'swap 10 usdt to btc', {
       provider: refusingProvider,
       tools,
-      onConfirm: async () => {
-        if (firstSpendSeen) return { approved: true };
-        firstSpendSeen = true;
-        return { approved: false, reason: 'user said no' };
-      },
+      onConfirm: async () => ({ approved: false, reason: 'user said no' }),
+      slots: { from_asset: 'USDT', to_asset: 'BTC', amount: 10, amount_side: 'from' },
     });
 
-    expect(res.status).not.toBe('done');
-    // The first spend tool (atomic_init) should NOT have completed successfully —
-    // the chain stops before pay/execute.
-    expect(captured.some((c) => c.name === 'rln_pay_invoice')).toBe(false);
-    expect(captured.some((c) => c.name === 'kaleidoswap_atomic_execute')).toBe(false);
+    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']);
   });
 });