@kaleidorg/mind 0.4.0 → 0.5.0

package/src/recipe/kaleidoswap-atomic.ts

@@ -1,53 +1,92 @@
 /**
- * Built-in "atomic swap on KaleidoSwap" recipe — trust-minimised chain.
+ * Built-in "swap on KaleidoSwap" recipe — the real atomic-swap chain.
  *
- * Most users want the simple market-order swap (`swapRecipe` over generic
- * `get_swap_quote` / `execute_swap`). This recipe is the EXPLICIT atomic path:
- * the user creates an RGB/LN receive invoice, the maker locks the swap, the
- * user pays the maker's Lightning invoice, and the maker releases.
+ * A swap (especially the full maker + RLN atomic) is a 6-step, two-service flow
+ * no small model can plan reliably, so the recipe carries the plan. The model
+ * is used for natural-language understanding of the request (slot extraction).
  *
- * Triggered only by explicit atomic-swap intent ("atomic swap", "trustless
- * swap", "htlc swap") so it never preempts the simpler swap path for vague
- * phrasings.
+ *   "buy 1 usdt"  (or "swap 10 usdt to btc")
+ *     ↓ heuristic pre-filter (0 inf) decides to enter the reliable recipe branch
+ *     ↓ 1 model inference (forced LLM slot extraction — the model parses intent)
+ *   kaleidoswap_get_quote        ← MAKER  prices the swap (read-only)
+ *     ↓ [ONE confirmation gate — shows the real quote numbers]
+ *   kaleidoswap_atomic_init      ← MAKER  locks the swap → swapstring, payment_hash
+ *   rln_get_node_info            ← NODE   read pubkey (= taker_pubkey)
+ *   rln_whitelist_swap           ← NODE   accept the swapstring
+ *   kaleidoswap_atomic_execute   ← MAKER  settle (final)
  *
- *   "atomic swap 100000 sats for usdt"
- *     ↓ 1 model inference (slot extraction)
- *   kaleidoswap_get_quote        ← maker prices the swap
- *   rln_create_rgb_invoice       ← user's node prepares receive (if to_asset is RGB)
- *   rln_create_ln_invoice        ← (alt) if to_asset is BTC
- *   kaleidoswap_atomic_init  🔒 ← maker locks the swap, returns its invoice
- *   rln_pay_invoice          🔒 ← user pays the maker
- *   kaleidoswap_atomic_execute 🔒 ← (final) maker releases the asset
+ * `forceModelExtract` ensures the model is always consulted for slot parsing
+ * (1 inference) so natural language like "buy 1 usdt" is interpreted by the LLM.
+ * A safety fallback in the runner uses the deterministic extractor if the model
+ * returns incomplete slots. The execution sequence + single-confirm gate remain
+ * fully deterministic and reliable.
  *
- * Two-or-three confirmation gates are intentional: each represents a distinct
- * decision point. The host's confirm UI describes what's about to happen.
+ * Status is NOT polled here — settlement takes seconds-to-minutes and blocking
+ * the chat is bad UX. The recipe reports "submitted, settling"; the user (or a
+ * follow-up turn) calls `kaleidoswap_atomic_status` on demand.
+ *
+ * Confirmation: the single decision a user makes is "given this quote, proceed?"
+ * — so the recipe declares ONE `confirm(ctx)` summary, fired after the quote and
+ * before init. init/whitelist/execute then run as one approved unit. (The
+ * runner's recipe-level confirm path handles this; see recipe/runner.ts.)
  */
 
-import type { Recipe } from './types.js';
+import type { Recipe, RecipeContext } from './types.js';
 import { extractSwap } from './swap.js';
 
-const ATOMIC_INTENT =
-  /\b(atomic|trustless|htlc)\b.*\b(swap|exchange|convert|trade)\b|\b(swap|exchange|convert|trade)\b.*\b(atomic|trustless|htlc)\b/i;
+// Fire on swap intent — "swap/exchange/convert/trade", or "buy/sell/get" when a
+// crypto asset is named (so "buy one usdt" routes here, but "buy a gift card"
+// does not). PRICE / rate / "how much" questions are read-only and go to
+// `kaleidoswapPriceRecipe` instead — keep them out of this match.
+const ASSET = /\b(btc|bitcoin|sats?|usdt|tether|xaut|gold)\b/i;
+const SWAP_INTENT = (t: string) => {
+  // Explanatory / educational questions → route to RAG-backed agentic answer,
+  // not the deterministic spend chain.
+  if (/\b(why|how|what|when|explain|tell\s+me|do\s+I\s+need|should\s+I|can\s+I)\b/i.test(t)) return false;
+  if (/\b(swap|exchange|convert|trade)\b/i.test(t)) return true;
+  if (
+    /\b(buy|sell|get|purchase|acquire)\b/i.test(t) &&
+    ASSET.test(t) &&
+    // Exclude commerce / receive / LSPS1 channel-order phrasings that share
+    // the buy/get verb. "Buy a USDT channel" is a channel order, not a swap.
+    !/\b(gift\s?card|top-?up|esim|voucher|invoice|address|channel|inbound|liquidity|lsps?\b)\b/i.test(t)
+  ) return true;
+  return false;
+};
 
-function isBtc(asset: unknown): boolean {
-  return String(asset ?? '').toUpperCase() === 'BTC';
+interface QuoteResult {
+  rfq_id?: string;
+  from_asset?: { asset_id?: string; ticker?: string; amount?: number };
+  to_asset?: { asset_id?: string; ticker?: string; amount?: number };
+  from_amount_display?: string;
+  to_amount_display?: string;
+  fee_display?: string;
 }
+interface InitResult { swapstring?: string; payment_hash?: string }
+interface NodeInfo { pubkey?: string }
 
 export const kaleidoswapAtomicRecipe: Recipe = {
   name: 'kaleidoswap-atomic',
   description:
-    'Trust-minimised atomic swap on KaleidoSwap: quote, prepare a receive invoice on the user\'s node, lock the swap with the maker, pay, and execute.',
-  match: (t) => ATOMIC_INTENT.test(t),
-  triggers: ['atomic swap', 'trustless swap', 'htlc swap'],
+    'Swap between BTC and an RGB asset on KaleidoSwap: quote, confirm once, then init (maker) → whitelist (node) → execute (maker).',
+  match: (t) => SWAP_INTENT(t),
+  triggers: ['swap', 'exchange', 'convert', 'trade', 'buy', 'sell'],
   slots: [
     { name: 'from_asset', type: 'string', description: 'Asset to spend (BTC / USDT / XAUT)', required: true },
     { name: 'to_asset', type: 'string', description: 'Asset to receive (BTC / USDT / XAUT)', required: true },
-    { name: 'amount', type: 'number', description: 'Amount of from_asset to swap' },
+    { name: 'amount', type: 'number', description: 'The amount the user named' },
+    { name: 'amount_side', type: 'string', description: "Which leg the amount is on: 'from' (sell/swap) or 'to' (buy)" },
   ],
+  // Keep the fast `extract` for the Funnel's cheap pre-filter (so "buy 1 usdt"
+  // reliably enters the recipe branch instead of falling to free agentic).
+  // `forceModelExtract` makes runRecipe ignore the deterministic result and
+  // always ask the model to produce the actual slots used for execution.
   extract: extractSwap,
+  forceModelExtract: true,
   confident: (s) => !!s.from_asset && !!s.to_asset && !!s.amount,
   steps: [
-    // 1. Maker quotes the swap. Returns { quote_id, receive_amount, fees, ttl_ms, ... }.
+    // 1. MAKER quotes the swap (read-only). Returns rfq_id + full asset specs
+    //    (echoes the rgb: asset ids and maker-unit amounts) + *_display strings.
     {
       tool: 'kaleidoswap_get_quote',
       as: 'quote',
@@ -55,63 +94,70 @@ export const kaleidoswapAtomicRecipe: Recipe = {
         from_asset: ctx.slots.from_asset,
         to_asset: ctx.slots.to_asset,
         amount: ctx.slots.amount,
+        // 'to' for buy ("buy 1 USDT" → amount is what you RECEIVE); default
+        // 'from' for sell/swap. The host puts the amount on the right leg.
+        amount_side: ctx.slots.amount_side ?? 'from',
       }),
     },
-    // 2a. User's node creates an RGB receive invoice (when to_asset is an RGB asset).
-    {
-      tool: 'rln_create_rgb_invoice',
-      as: 'receive_rgb',
-      args: (ctx) => {
-        const q = ctx.results.quote as { receive_amount?: number } | undefined;
-        return { asset: ctx.slots.to_asset, amount: q?.receive_amount };
-      },
-      skipIf: (ctx) => isBtc(ctx.slots.to_asset),
-    },
-    // 2b. User's node creates an LN receive invoice (when to_asset is BTC).
-    {
-      tool: 'rln_create_ln_invoice',
-      as: 'receive_ln',
-      args: (ctx) => {
-        const q = ctx.results.quote as { receive_amount?: number } | undefined;
-        return { amount_sats: q?.receive_amount };
-      },
-      skipIf: (ctx) => !isBtc(ctx.slots.to_asset),
-    },
-    // 3. Maker locks the swap. Returns { atomic_id, maker_invoice }. Spend-gated.
+    // 2. MAKER locks the swap. SwapRequest is flat (asset ids + maker-unit
+    //    amounts) — sourced straight from the quote result, no re-scaling.
+    //    First spend step → the recipe-level confirm gate fires just before it.
     {
       tool: 'kaleidoswap_atomic_init',
-      as: 'atomic',
+      as: 'init',
       args: (ctx) => {
-        const rgb = ctx.results.receive_rgb as { invoice?: string } | undefined;
-        const ln = ctx.results.receive_ln as { invoice?: string } | undefined;
-        const q = ctx.results.quote as { quote_id?: string } | undefined;
+        const q = ctx.results.quote as QuoteResult | undefined;
         return {
-          quote_id: q?.quote_id,
-          receive_invoice: rgb?.invoice ?? ln?.invoice,
+          rfq_id: q?.rfq_id,
+          from_asset: q?.from_asset?.asset_id,
+          from_amount: q?.from_asset?.amount,
+          to_asset: q?.to_asset?.asset_id,
+          to_amount: q?.to_asset?.amount,
         };
       },
     },
-    // 4. User pays the maker's Lightning invoice. Spend-gated by the wallet contract.
+    // 3. NODE: read our pubkey — the maker needs it as taker_pubkey for execute.
     {
-      tool: 'rln_pay_invoice',
-      as: 'paid',
+      tool: 'rln_get_node_info',
+      as: 'node',
+      args: () => ({}),
+    },
+    // 4. NODE: whitelist the maker's swapstring (accept the swap). Ungated —
+    //    covered by the single confirm above.
+    {
+      tool: 'rln_whitelist_swap',
+      as: 'whitelist',
       args: (ctx) => {
-        const a = ctx.results.atomic as { maker_invoice?: string } | undefined;
-        return { invoice: a?.maker_invoice };
+        const init = ctx.results.init as InitResult | undefined;
+        return { swapstring: init?.swapstring };
       },
     },
   ],
-  // 5. Maker releases the receive asset → swap completes. Spend-gated.
+  // 5. MAKER settles the swap. Needs swapstring + taker_pubkey + payment_hash.
   final: {
     tool: 'kaleidoswap_atomic_execute',
     args: (ctx) => {
-      const a = ctx.results.atomic as { atomic_id?: string } | undefined;
-      return { atomic_id: a?.atomic_id };
+      const init = ctx.results.init as InitResult | undefined;
+      const node = ctx.results.node as NodeInfo | undefined;
+      return {
+        swapstring: init?.swapstring,
+        taker_pubkey: node?.pubkey,
+        payment_hash: init?.payment_hash,
+      };
     },
   },
+  // ONE confirmation, fired after the quote / before init, with the real numbers.
+  confirm: (ctx: RecipeContext) => {
+    const q = ctx.results.quote as QuoteResult | undefined;
+    const from = q?.from_amount_display ?? `${ctx.slots.amount} ${ctx.slots.from_asset}`;
+    const to = q?.to_amount_display ?? String(ctx.slots.to_asset);
+    const fee = q?.fee_display ? ` · fee ${q.fee_display}` : '';
+    return `Swap ${from} → ${to}${fee} on KaleidoSwap. Proceed?`;
+  },
   summary: (ctx) => {
-    const q = ctx.results.quote as { receive_amount?: number } | undefined;
-    const tail = q?.receive_amount ? ` ≈ ${q.receive_amount} ${ctx.slots.to_asset}` : '';
-    return `Atomic swap: ${ctx.slots.amount} ${ctx.slots.from_asset} → ${ctx.slots.to_asset}${tail}.`;
+    const q = ctx.results.quote as QuoteResult | undefined;
+    const from = q?.from_amount_display ?? `${ctx.slots.amount} ${ctx.slots.from_asset}`;
+    const to = q?.to_amount_display ?? String(ctx.slots.to_asset);
+    return `Swap submitted: ${from} → ${to}. Settling now — ask me to check the status.`;
   },
 };

package/src/recipe/kaleidoswap-channel-order.test.ts

@@ -0,0 +1,333 @@
+import { describe, expect, it } from 'vitest';
+import { ToolRegistry } from '../tools/registry.js';
+import { InProcessToolSource } from '../tools/in-process.js';
+import type { LLMProvider } from '../providers/types.js';
+import { runRecipe } from './runner.js';
+import {
+  kaleidoswapChannelOrderRecipe,
+  extractChannelOrder,
+} from './kaleidoswap-channel-order.js';
+
+const refusingProvider: LLMProvider = {
+  name: 'refusing',
+  runTurn: async () => {
+    throw new Error('provider should NOT be called when slots are pre-supplied');
+  },
+};
+
+/** Stubs that match the real LSPS1 + RLN response shapes. */
+function buildStubs(captured: { name: string; args: any }[]) {
+  const tool = (name: string, response: any, spend = false) => ({
+    name,
+    description: '',
+    parameters: { type: 'object', properties: {} },
+    requiresConfirmation: spend,
+    handler: async (a: any) => {
+      captured.push({ name, args: a });
+      return typeof response === 'function' ? response(a) : response;
+    },
+  });
+  return new ToolRegistry([
+    new InProcessToolSource('lsps1', [
+      tool('lsp_get_info', {
+        lsp_connection_url: '03abc@1.2.3.4:9735',
+        options: {
+          min_initial_lsp_balance_sat: 50_000,
+          max_initial_lsp_balance_sat: 10_000_000,
+          max_channel_expiry_blocks: 20160,
+        },
+        assets: [],
+      }),
+      tool('lsp_estimate_fees', {
+        setup_fee: 100,
+        capacity_fee: 250,
+        duration_fee: 50,
+        total_fee: 400,
+      }),
+      tool('lsp_create_order', {
+        order_id: 'ord-xyz',
+        access_token: 'tok-1',
+        order_state: 'CREATED',
+        payment: {
+          bolt11: {
+            invoice: 'lnbc500400n1lspsorder',
+            order_total_sat: 500_400,
+            fee_total_sat: 400,
+            state: 'EXPECT_PAYMENT',
+          },
+        },
+      }, /* spend */ true),
+      tool('lsp_get_order', { order_state: 'COMPLETED', channel: { channel_id: 'ch-1' } }),
+    ]),
+    new InProcessToolSource('rln', [
+      tool('rln_get_node_info', { pubkey: '03c31dae' }),
+      tool('rln_pay_invoice', { status: 'SUCCESS', payment_hash: 'h' }, /* spend */ true),
+      // Stateful: first call (before snapshot) shows an existing channel;
+      // second call (after) shows the existing one PLUS the new one, so the
+      // diff identifies 'newch' as freshly opened.
+      {
+        name: 'rln_list_channels',
+        description: '',
+        parameters: { type: 'object', properties: {} },
+        handler: (() => {
+          let calls = 0;
+          return async (a: any) => {
+            captured.push({ name: 'rln_list_channels', args: a });
+            calls += 1;
+            const existing = { channel_id: 'oldch', capacity_sat: 2_000_000, inbound_sat: 1_800_000, ready: true, status: 'Opened' };
+            if (calls === 1) return { channels: [existing], count: 1 };
+            return {
+              channels: [
+                existing,
+                { channel_id: 'newch', capacity_sat: 500_000, inbound_sat: 495_000, outbound_sat: 0, ready: false, status: 'opening' },
+              ],
+              count: 2,
+            };
+          };
+        })(),
+      },
+    ]),
+  ]);
+}
+
+describe('extractChannelOrder — deterministic prefilter', () => {
+  it('catches single-amount "buy a 500k inbound channel"', () => {
+    const r = extractChannelOrder('buy a 500k inbound channel');
+    expect(r).toMatchObject({ lsp_balance_sat: 500_000 });
+  });
+
+  it('catches "I need 200000 sats of inbound liquidity"', () => {
+    const r = extractChannelOrder('I need 200000 sats of inbound liquidity');
+    expect(r).toMatchObject({ lsp_balance_sat: 200_000 });
+  });
+
+  it('catches "1M inbound for 30 days"', () => {
+    const r = extractChannelOrder('open a channel from the LSP, 1M inbound for 30 days');
+    expect(r).toMatchObject({ lsp_balance_sat: 1_000_000, channel_expiry_blocks: 30 * 144 });
+  });
+
+  it('catches dual-amount with side keywords: "20000 on my side 80000 on lsp"', () => {
+    const r = extractChannelOrder('buy a channel for me 20000 on my side 80000 on lsp');
+    expect(r).toMatchObject({ client_balance_sat: 20_000, lsp_balance_sat: 80_000 });
+  });
+
+  it('catches "client_balance 5000 lsp_balance 100000"', () => {
+    const r = extractChannelOrder('open channel client_balance 5000 lsp_balance 100000');
+    expect(r).toMatchObject({ client_balance_sat: 5_000, lsp_balance_sat: 100_000 });
+  });
+
+  it('catches "with 10k push" + "500k inbound"', () => {
+    const r = extractChannelOrder('buy a channel with 10k push and 500k inbound');
+    expect(r).toMatchObject({ client_balance_sat: 10_000, lsp_balance_sat: 500_000 });
+  });
+
+  it('catches "Nk sats my side, Mk sats lsp side" (unit between number and side)', () => {
+    const r = extractChannelOrder('buy a channel: 100k sats my side, 5M sats lsp side');
+    expect(r).toMatchObject({ client_balance_sat: 100_000, lsp_balance_sat: 5_000_000 });
+  });
+
+  it('catches an asset channel: ticker + asset amount', () => {
+    const r = extractChannelOrder('buy a USDT channel: 5M sats lsp side, 100 USDT inbound');
+    expect(r).toMatchObject({
+      lsp_balance_sat: 5_000_000,
+      asset_ticker: 'USDT',
+      lsp_asset_amount: 100,
+    });
+  });
+
+  it('catches dual-side asset: 100 USDT inbound + 20 USDT pushed to my side', () => {
+    const r = extractChannelOrder(
+      'buy a USDT channel: 5M sats lsp side, 100k sats my side, 100 USDT inbound, 20 USDT pushed to my side',
+    );
+    expect(r).toMatchObject({
+      lsp_balance_sat: 5_000_000,
+      client_balance_sat: 100_000,
+      asset_ticker: 'USDT',
+      lsp_asset_amount: 100,
+      client_asset_amount: 20,
+    });
+  });
+
+  it('returns null when no concrete fields extractable (intent-only)', () => {
+    // The Funnel still fires the recipe via forceModelExtract + match(),
+    // so the LLM does the actual extraction. The extractor only contributes
+    // when it can pull a real value out.
+    expect(extractChannelOrder('I want a channel order')).toBeNull();
+    expect(extractChannelOrder('buy channel from kaleid')).toBeNull();
+  });
+
+  it('returns null on ambiguous dual-number phrasing (no side keywords)', () => {
+    // "buy channel 20000 80000" — could be either. Let the LLM decide via the
+    // recipe's forceModelExtract path.
+    expect(extractChannelOrder('buy channel 20000 80000')).toBeNull();
+  });
+
+  it('ignores unrelated text', () => {
+    expect(extractChannelOrder('what is my balance')).toBeNull();
+    expect(extractChannelOrder('swap 1000 sats to usdt')).toBeNull();
+  });
+});
+
+describe('kaleidoswapChannelOrderRecipe — selection', () => {
+  it('triggers on channel-order phrasings', () => {
+    const m = kaleidoswapChannelOrderRecipe.match!;
+    expect(m('buy a 500k inbound channel')).toBe(true);
+    expect(m("I can't receive 1M sats")).toBe(true);
+    expect(m('open a channel from the LSP, 200k inbound')).toBe(true);
+    expect(m('order a lsps1 channel')).toBe(true);
+  });
+
+  it('does NOT trigger on swap / balance / generic Lightning questions', () => {
+    const m = kaleidoswapChannelOrderRecipe.match!;
+    expect(m('what is my balance')).toBe(false);
+    expect(m('swap 1000 sats to usdt')).toBe(false);
+    expect(m('what is a Lightning channel?')).toBe(false);
+  });
+
+  it('does NOT trigger on explanatory questions about channels', () => {
+    const m = kaleidoswapChannelOrderRecipe.match!;
+    // These should route to RAG-backed knowledge answering, not the recipe.
+    expect(m('why do I need to buy a channel before swapping?')).toBe(false);
+    expect(m('how does an inbound channel work?')).toBe(false);
+    expect(m('what is inbound liquidity?')).toBe(false);
+    expect(m('do I need a channel to receive lightning payments?')).toBe(false);
+    expect(m('can I receive without an inbound channel?')).toBe(false);
+  });
+});
+
+describe('kaleidoswapChannelOrderRecipe — full chain', () => {
+  it('runs get_info → estimate_fees → get_node_info → create_order → pay_invoice (one inference)', async () => {
+    const captured: { name: string; args: any }[] = [];
+    const tools = buildStubs(captured);
+
+    const res = await runRecipe(
+      kaleidoswapChannelOrderRecipe,
+      'buy a 500000-sat inbound channel',
+      {
+        provider: refusingProvider,
+        tools,
+        onConfirm: async () => ({ approved: true }),
+        slots: { lsp_balance_sat: 500_000 }, // simulate a successful prior extraction
+      },
+    );
+
+    expect(res.status).toBe('done');
+    expect(res.inferences).toBe(0);
+    expect(captured.map((c) => c.name)).toEqual([
+      'lsp_get_info',
+      'lsp_estimate_fees',
+      'rln_get_node_info',
+      'rln_list_channels', // before-snapshot
+      'lsp_create_order',
+      'rln_pay_invoice',
+      'rln_list_channels', // after — verification (read-only final)
+    ]);
+  });
+
+  it('verification diff identifies the NEW channel (not pre-existing ones)', async () => {
+    const captured: { name: string; args: any }[] = [];
+    const tools = buildStubs(captured);
+    const res = await runRecipe(kaleidoswapChannelOrderRecipe, 'buy a 500000-sat inbound channel', {
+      provider: refusingProvider,
+      tools,
+      onConfirm: async () => ({ approved: true }),
+      slots: { lsp_balance_sat: 500_000 },
+    });
+    // The summary should reference the NEW channel (500k), not the old 2M one.
+    expect(res.text).toMatch(/New channel/);
+    expect(res.text).toMatch(/500,000-sat/);
+    expect(res.text).not.toMatch(/2,000,000/);
+  });
+
+  it("threads node.pubkey into lsp_create_order's client_pubkey", async () => {
+    const captured: { name: string; args: any }[] = [];
+    const tools = buildStubs(captured);
+    await runRecipe(kaleidoswapChannelOrderRecipe, 'buy a 500000-sat inbound channel', {
+      provider: refusingProvider,
+      tools,
+      onConfirm: async () => ({ approved: true }),
+      slots: { lsp_balance_sat: 500_000 },
+    });
+    const order = captured.find((c) => c.name === 'lsp_create_order')!;
+    expect(order.args).toMatchObject({
+      client_pubkey: '03c31dae',
+      lsp_balance_sat: 500_000,
+    });
+  });
+
+  it("threads order.payment.bolt11.invoice into rln_pay_invoice", async () => {
+    const captured: { name: string; args: any }[] = [];
+    const tools = buildStubs(captured);
+    await runRecipe(kaleidoswapChannelOrderRecipe, 'buy a 500000-sat inbound channel', {
+      provider: refusingProvider,
+      tools,
+      onConfirm: async () => ({ approved: true }),
+      slots: { lsp_balance_sat: 500_000 },
+    });
+    const pay = captured.find((c) => c.name === 'rln_pay_invoice')!;
+    expect(pay.args).toEqual({ invoice: 'lnbc500400n1lspsorder' });
+  });
+});
+
+describe('kaleidoswapChannelOrderRecipe — missing info', () => {
+  it('returns status:needs-info (not error) when lsp_balance_sat is missing', async () => {
+    // LLM emits no slots → confident() fails → recipe asks the user instead
+    // of running the chain with bad data.
+    const emptyExtractProvider: LLMProvider = {
+      name: 'empty',
+      runTurn: async () => ({ text: '', rawContent: '', toolCalls: [] }),
+    };
+    const captured: { name: string; args: any }[] = [];
+    const tools = buildStubs(captured);
+
+    const res = await runRecipe(kaleidoswapChannelOrderRecipe, 'buy a channel from kaleid', {
+      provider: emptyExtractProvider,
+      tools,
+      onConfirm: async () => ({ approved: true }),
+    });
+
+    expect(res.status).toBe('needs-info');
+    expect(res.text).toMatch(/lsp_balance_sat|specify/i);
+    // No tools should have been called.
+    expect(captured.length).toBe(0);
+  });
+});
+
+describe('kaleidoswapChannelOrderRecipe — single confirmation', () => {
+  it('fires ONE gate (before create_order), showing the fee summary', async () => {
+    const captured: { name: string; args: any }[] = [];
+    const tools = buildStubs(captured);
+    const gates: string[] = [];
+
+    const res = await runRecipe(kaleidoswapChannelOrderRecipe, 'buy a 500000-sat inbound channel', {
+      provider: refusingProvider,
+      tools,
+      onConfirm: async (call) => {
+        gates.push(call.name);
+        return { approved: true };
+      },
+      slots: { lsp_balance_sat: 500_000 },
+    });
+
+    expect(res.status).toBe('done');
+    // Exactly one gate fired, at the first spend step (create_order). Pay step
+    // ran without a second prompt — the single recipe-confirm covered it.
+    expect(gates).toEqual(['lsp_create_order']);
+  });
+
+  it('cancels the entire chain on decline (no order, no payment)', async () => {
+    const captured: { name: string; args: any }[] = [];
+    const tools = buildStubs(captured);
+
+    const res = await runRecipe(kaleidoswapChannelOrderRecipe, 'buy a 500000-sat inbound channel', {
+      provider: refusingProvider,
+      tools,
+      onConfirm: async () => ({ approved: false, reason: 'too expensive' }),
+      slots: { lsp_balance_sat: 500_000 },
+    });
+
+    expect(res.status).not.toBe('done');
+    expect(captured.some((c) => c.name === 'lsp_create_order')).toBe(false);
+    expect(captured.some((c) => c.name === 'rln_pay_invoice')).toBe(false);
+  });
+});