@kaleidorg/mind 0.4.0 → 0.5.1

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']);
   });
 });

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.`;
   },
 };