@kaleidorg/mind 0.0.1 → 0.2.0

package/src/memory/types.ts

@@ -0,0 +1,63 @@
+/**
+ * Memory — the agent's persistent identity + what it has learned.
+ *
+ * Two layers, mirroring how nanobot splits SOUL.md / AGENTS.md / memory:
+ *   - AgentProfile  — static identity ("who am I, how do I behave"). Injected.
+ *   - MemoryStore   — durable, growing facts/preferences/events the agent
+ *                     remembers across sessions. Pluggable storage.
+ *
+ * Pure data + interfaces — no storage or embedding deps. The host injects
+ * persistence (AsyncStorage on RN, fs/SQLite on Node) and, optionally, an
+ * EmbeddingProvider for semantic recall.
+ */
+
+/** Static agent identity, composed into the system prompt every turn. */
+export interface AgentProfile {
+  /** Display name, e.g. "KaleidoMind". */
+  name: string;
+  /** Persona / identity — the "soul". Who the agent is, its voice, its values. */
+  soul: string;
+  /** Operating instructions / house rules (optional). */
+  instructions?: string;
+}
+
+export type MemoryKind = 'fact' | 'preference' | 'event' | 'note';
+
+export interface MemoryItem {
+  id: string;
+  text: string;
+  kind: MemoryKind;
+  /** Epoch ms. */
+  createdAt: number;
+  tags?: string[];
+  /** Optional embedding for semantic recall (set when an embedder is wired). */
+  embedding?: number[];
+}
+
+/** What to add — id/createdAt/embedding are filled in by the store. */
+export type NewMemory = Omit<MemoryItem, 'id' | 'createdAt' | 'embedding'> &
+  Partial<Pick<MemoryItem, 'id' | 'createdAt' | 'embedding'>>;
+
+export interface MemoryQuery {
+  /** Free text to match (semantic if embeddings are available, else substring). */
+  text?: string;
+  kind?: MemoryKind;
+  tags?: string[];
+  /** Max items to return (default 5). */
+  limit?: number;
+}
+
+export interface MemoryStore {
+  add(item: NewMemory): Promise<MemoryItem>;
+  all(): Promise<MemoryItem[]>;
+  /** Best-matching items for the query (recency-ranked, or semantic if embedded). */
+  search(query: MemoryQuery): Promise<MemoryItem[]>;
+  remove(id: string): Promise<void>;
+  clear(): Promise<void>;
+}
+
+/** Injected persistence — load once, save on every mutation. RN/Node provide it. */
+export interface MemoryIO {
+  load(): Promise<MemoryItem[]>;
+  save(items: MemoryItem[]): Promise<void>;
+}

package/src/rag/rag.test.ts

@@ -0,0 +1,85 @@
+/** RAG tests — vector store, chunking, retriever + tool with a fake embedder. */
+
+import { describe, it, expect } from 'vitest';
+import { cosineSimilarity, InMemoryVectorStore } from './vector-store.js';
+import { Retriever, chunkText } from './retriever.js';
+import { createRagToolSource } from './tool.js';
+import type { EmbeddingProvider } from './types.js';
+
+// Deterministic bag-of-words embedder over a tiny vocab.
+const VOCAB = ['btc', 'lightning', 'channel', 'swap', 'balance', 'rgb', 'price', 'esim'];
+const fakeEmbeddings: EmbeddingProvider = {
+  dimension: VOCAB.length,
+  async embed(texts) {
+    return texts.map((t) => {
+      const lower = t.toLowerCase();
+      return VOCAB.map((w) => (lower.match(new RegExp(w, 'g'))?.length ?? 0));
+    });
+  },
+};
+
+describe('cosineSimilarity', () => {
+  it('is 1 for identical, 0 for orthogonal / degenerate', () => {
+    expect(cosineSimilarity([1, 2, 3], [1, 2, 3])).toBeCloseTo(1);
+    expect(cosineSimilarity([1, 0], [0, 1])).toBe(0);
+    expect(cosineSimilarity([0, 0], [1, 1])).toBe(0);
+  });
+});
+
+describe('chunkText', () => {
+  it('returns one chunk when short', () => {
+    expect(chunkText('hello world', 800)).toEqual(['hello world']);
+  });
+  it('splits long text with overlap on boundaries', () => {
+    const text = Array.from({ length: 50 }, (_, i) => `Sentence number ${i}.`).join(' ');
+    const chunks = chunkText(text, 120, 20);
+    expect(chunks.length).toBeGreaterThan(1);
+    expect(chunks.every((c) => c.length <= 140)).toBe(true);
+  });
+});
+
+describe('InMemoryVectorStore', () => {
+  it('upserts (dedup by id) and queries by similarity', async () => {
+    const store = new InMemoryVectorStore();
+    await store.upsert([
+      { id: 'a', text: 'about balance', embedding: [0, 0, 0, 0, 1, 0, 0, 0] },
+      { id: 'b', text: 'about price', embedding: [0, 0, 0, 0, 0, 0, 1, 0] },
+    ]);
+    await store.upsert([{ id: 'a', text: 'about balance v2', embedding: [0, 0, 0, 0, 1, 0, 0, 0] }]);
+    expect(await store.size()).toBe(2); // 'a' replaced, not duplicated
+
+    const hits = await store.query([0, 0, 0, 0, 1, 0, 0, 0], 1);
+    expect(hits[0].text).toBe('about balance v2');
+    expect(hits[0].score).toBeCloseTo(1);
+  });
+});
+
+describe('Retriever + RAG tool', () => {
+  it('ingests, then retrieves the most relevant chunk', async () => {
+    const retriever = new Retriever({ embeddings: fakeEmbeddings });
+    const n = await retriever.ingest([
+      { id: 'd1', text: 'How to open a lightning channel and manage balance.' },
+      { id: 'd2', text: 'eSIM data plans and price comparison.' },
+    ]);
+    expect(n).toBeGreaterThanOrEqual(2);
+
+    const hits = await retriever.search('what is my balance on lightning', 1);
+    expect(hits[0].text).toMatch(/lightning channel/i);
+  });
+
+  it('search_knowledge tool returns formatted snippets', async () => {
+    const retriever = new Retriever({ embeddings: fakeEmbeddings });
+    await retriever.ingest([{ id: 'd', text: 'BTC swap and channel fees explained.' }]);
+    const src = createRagToolSource(retriever, { k: 2 });
+    expect(src.has('search_knowledge')).toBe(true);
+    const out = await src.execute('search_knowledge', { query: 'swap channel' });
+    expect(String(out)).toMatch(/swap and channel/i);
+  });
+
+  it('returns a friendly message when nothing matches', async () => {
+    const retriever = new Retriever({ embeddings: fakeEmbeddings });
+    const src = createRagToolSource(retriever);
+    const out = await src.execute('search_knowledge', { query: 'anything' });
+    expect(String(out)).toMatch(/No relevant passages/);
+  });
+});

package/src/rag/retriever.ts

@@ -0,0 +1,94 @@
+/**
+ * Retriever — ties an injected EmbeddingProvider to a VectorStore: ingest
+ * documents (chunk → embed → upsert) and search (embed query → top-k). Pure
+ * TS; the embedding model is the host's (QVAC `embed()` on device).
+ */
+
+import { InMemoryVectorStore } from './vector-store.js';
+import type {
+  EmbeddingProvider,
+  RagDocument,
+  RetrievedChunk,
+  VectorStore,
+} from './types.js';
+
+export interface RetrieverOptions {
+  embeddings: EmbeddingProvider;
+  /** Vector index (defaults to a fresh in-memory cosine store). */
+  store?: VectorStore;
+  /** Approx chars per chunk (default 800 ≈ 200 tokens). */
+  chunkSize?: number;
+  /** Chars of overlap between chunks (default 100). */
+  chunkOverlap?: number;
+}
+
+/** Split text into overlapping chunks, preferring paragraph/sentence breaks. */
+export function chunkText(text: string, size = 800, overlap = 100): string[] {
+  const clean = text.replace(/\r\n/g, '\n').trim();
+  if (clean.length <= size) return clean ? [clean] : [];
+  const chunks: string[] = [];
+  let start = 0;
+  while (start < clean.length) {
+    let end = Math.min(start + size, clean.length);
+    if (end < clean.length) {
+      // Back up to the nearest paragraph/sentence/space boundary.
+      const slice = clean.slice(start, end);
+      const brk = Math.max(
+        slice.lastIndexOf('\n\n'),
+        slice.lastIndexOf('\n'),
+        slice.lastIndexOf('. '),
+        slice.lastIndexOf(' '),
+      );
+      if (brk > size * 0.5) end = start + brk + 1;
+    }
+    const piece = clean.slice(start, end).trim();
+    if (piece) chunks.push(piece);
+    if (end >= clean.length) break;
+    start = Math.max(end - overlap, start + 1);
+  }
+  return chunks;
+}
+
+export class Retriever {
+  private readonly embeddings: EmbeddingProvider;
+  private readonly store: VectorStore;
+  private readonly chunkSize: number;
+  private readonly chunkOverlap: number;
+
+  constructor(opts: RetrieverOptions) {
+    this.embeddings = opts.embeddings;
+    this.store = opts.store ?? new InMemoryVectorStore();
+    this.chunkSize = opts.chunkSize ?? 800;
+    this.chunkOverlap = opts.chunkOverlap ?? 100;
+  }
+
+  /** Chunk, embed, and index documents. Returns the number of chunks stored. */
+  async ingest(docs: RagDocument[]): Promise<number> {
+    const pending: { id: string; text: string; metadata?: Record<string, unknown> }[] = [];
+    for (const doc of docs) {
+      const pieces = chunkText(doc.text, this.chunkSize, this.chunkOverlap);
+      pieces.forEach((text, i) => {
+        const baseId = doc.id ?? `doc_${pending.length}`;
+        pending.push({ id: `${baseId}#${i}`, text, metadata: doc.metadata });
+      });
+    }
+    if (pending.length === 0) return 0;
+    const vectors = await this.embeddings.embed(pending.map((p) => p.text));
+    await this.store.upsert(
+      pending.map((p, i) => ({ ...p, embedding: vectors[i] })),
+    );
+    return pending.length;
+  }
+
+  /** Embed the query and return the top-k most similar chunks. */
+  async search(query: string, k = 4): Promise<RetrievedChunk[]> {
+    if (!query.trim()) return [];
+    const [qv] = await this.embeddings.embed([query]);
+    if (!qv) return [];
+    return this.store.query(qv, k);
+  }
+
+  vectorStore(): VectorStore {
+    return this.store;
+  }
+}

package/src/rag/tool.ts

@@ -0,0 +1,55 @@
+/**
+ * RAG tool source — exposes `search_knowledge` so the model can pull in
+ * relevant context on demand (agentic RAG). Preferred over always-injecting
+ * retrieved text, which burns the small-model context window.
+ */
+
+import type { ToolDef } from '../types.js';
+import type { ToolSource } from '../tools/source.js';
+import type { Retriever } from './retriever.js';
+
+const SEARCH = 'search_knowledge';
+
+export interface RagToolOptions {
+  /** Chunks to return (default 4). */
+  k?: number;
+  /** Override the tool description for your corpus, e.g. "Search the docs." */
+  description?: string;
+}
+
+export function createRagToolSource(retriever: Retriever, opts: RagToolOptions = {}): ToolSource {
+  const tool: ToolDef = {
+    name: SEARCH,
+    description:
+      opts.description ??
+      'Search the knowledge base for passages relevant to a question and return ' +
+        'the best matches. Use this before answering when the answer might be in ' +
+        'ingested documents.',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'What to look up' },
+        k: { type: 'number', description: 'How many passages (default 4)' },
+      },
+      required: ['query'],
+    },
+  };
+
+  async function execute(_name: string, args: Record<string, unknown>): Promise<unknown> {
+    const query = String(args.query ?? '').trim();
+    if (!query) throw new Error('search_knowledge: query is required');
+    const k = Number(args.k) > 0 ? Number(args.k) : (opts.k ?? 4);
+    const hits = await retriever.search(query, k);
+    if (hits.length === 0) return 'No relevant passages found.';
+    return hits
+      .map((h, i) => `[${i + 1}] (score ${h.score.toFixed(2)}) ${h.text}`)
+      .join('\n\n');
+  }
+
+  return {
+    id: 'rag',
+    listTools: () => [tool],
+    has: (name) => name === SEARCH,
+    execute,
+  };
+}

package/src/rag/types.ts

@@ -0,0 +1,49 @@
+/**
+ * RAG types — retrieval-augmented generation primitives.
+ *
+ * The heavy parts (the embedding model, the vector index) are interfaces the
+ * host injects. On QVAC the EmbeddingProvider wraps the SDK `embed()` API
+ * (on-device); a server host could inject a remote embedder. The default
+ * VectorStore is a pure-JS in-memory cosine index (good for thousands of
+ * chunks); a host can swap in SQLite/native for more.
+ */
+
+/** Turns text into vectors. Injected — QVAC `embed()` on device, etc. */
+export interface EmbeddingProvider {
+  embed(texts: string[]): Promise<number[][]>;
+  /** Vector dimension, when known (informational). */
+  dimension?: number;
+}
+
+export interface Chunk {
+  id: string;
+  text: string;
+  metadata?: Record<string, unknown>;
+  embedding?: number[];
+}
+
+export interface RetrievedChunk extends Chunk {
+  /** Similarity score in [-1, 1] (cosine). */
+  score: number;
+}
+
+/** A document to ingest; chunked + embedded by the Retriever. */
+export interface RagDocument {
+  id?: string;
+  text: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface VectorStore {
+  upsert(chunks: Chunk[]): Promise<void>;
+  /** Top-k by cosine similarity to `embedding`. */
+  query(embedding: number[], k: number): Promise<RetrievedChunk[]>;
+  size(): Promise<number>;
+  clear(): Promise<void>;
+}
+
+/** Injected persistence for the vector store (optional). */
+export interface VectorStoreIO {
+  load(): Promise<Chunk[]>;
+  save(chunks: Chunk[]): Promise<void>;
+}

package/src/rag/vector-store.ts

@@ -0,0 +1,78 @@
+/**
+ * In-memory vector store — pure-JS cosine similarity index. Zero deps, so it
+ * bundles in Bare/RN. Good for thousands of chunks; swap in a native/SQLite
+ * store via the VectorStore interface for larger corpora.
+ */
+
+import type { Chunk, RetrievedChunk, VectorStore, VectorStoreIO } from './types.js';
+
+/** Cosine similarity of two equal-length vectors. Returns 0 on degenerate input. */
+export function cosineSimilarity(a: number[], b: number[]): number {
+  const n = Math.min(a.length, b.length);
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < n; i++) {
+    dot += a[i]! * b[i]!;
+    na += a[i]! * a[i]!;
+    nb += b[i]! * b[i]!;
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+
+export interface InMemoryVectorStoreOptions {
+  io?: VectorStoreIO;
+}
+
+export class InMemoryVectorStore implements VectorStore {
+  private chunks: Chunk[] = [];
+  private hydrated = false;
+  private readonly io?: VectorStoreIO;
+
+  constructor(opts: InMemoryVectorStoreOptions = {}) {
+    this.io = opts.io;
+  }
+
+  private async hydrate(): Promise<void> {
+    if (this.hydrated) return;
+    this.hydrated = true;
+    if (this.io) {
+      try {
+        this.chunks = await this.io.load();
+      } catch {
+        this.chunks = [];
+      }
+    }
+  }
+
+  async upsert(chunks: Chunk[]): Promise<void> {
+    await this.hydrate();
+    for (const c of chunks) {
+      const i = this.chunks.findIndex((x) => x.id === c.id);
+      if (i >= 0) this.chunks[i] = c;
+      else this.chunks.push(c);
+    }
+    if (this.io) await this.io.save(this.chunks);
+  }
+
+  async query(embedding: number[], k: number): Promise<RetrievedChunk[]> {
+    await this.hydrate();
+    return this.chunks
+      .filter((c) => c.embedding && c.embedding.length > 0)
+      .map((c) => ({ ...c, score: cosineSimilarity(embedding, c.embedding!) }))
+      .sort((a, b) => b.score - a.score)
+      .slice(0, k);
+  }
+
+  async size(): Promise<number> {
+    await this.hydrate();
+    return this.chunks.length;
+  }
+
+  async clear(): Promise<void> {
+    await this.hydrate();
+    this.chunks = [];
+    if (this.io) await this.io.save(this.chunks);
+  }
+}

package/src/recipe/asset-send.ts

@@ -0,0 +1,79 @@
+/**
+ * Built-in "send an RGB asset" recipe — distinct from the BTC payments recipe
+ * because an asset amount must NOT be treated as fiat.
+ *
+ *   "send 10 USDT to bob"     → resolve_contact → rln_send_asset 🔒
+ *   "pay alice 5 XAUT"        → resolve_contact → rln_send_asset 🔒
+ *
+ * Fixes the bug where the payments recipe parsed "USDT" as a fiat currency and
+ * ran fiat_to_sats. Payments now excludes RGB assets; this recipe owns them.
+ */
+
+import type { Recipe, RecipeContext } from './types.js';
+
+const RGB_ASSET = /\b(usdt|tether|xaut|gold)\b/i;
+const isOnchainOrInvoice = (s: string) => /^(ln(bc|tb|bcrt)|bc1|tb1|lnurl|rgb:|[a-z0-9._-]+@)/i.test(s.trim());
+
+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 a.toUpperCase();
+}
+function parseAmount(t: string): number | undefined {
+  const m = t.match(/(\d[\d.,]*)\s*([km])?\b/i);
+  if (!m) return undefined;
+  let n = Number(m[1]!.replace(/,/g, ''));
+  if (m[2]) n *= m[2].toLowerCase() === 'k' ? 1_000 : 1_000_000;
+  return Number.isNaN(n) ? undefined : n;
+}
+
+/** "send 10 USDT to bob" / "pay alice 5 xaut". */
+export function extractAssetSend(text: string): Record<string, unknown> | null {
+  const t = text.trim();
+  if (!/\b(send|pay|transfer)\b/i.test(t)) return null;
+  const asset = normAsset(t.match(RGB_ASSET)?.[1]);
+  if (!asset) return null; // not an asset send → let the payments recipe handle it
+  const amount = parseAmount(t);
+  let recipient = t.match(/\bto\s+([^\s,]+)/i)?.[1];
+  if (!recipient) {
+    const after = t.match(/\b(?:pay|send|transfer)\s+([^\s,]+)/i)?.[1];
+    if (after && !/^\d/.test(after) && !RGB_ASSET.test(after)) recipient = after;
+  }
+  if (!recipient && amount == null) return null;
+  return { recipient, asset, amount };
+}
+
+export const assetSendRecipe: Recipe = {
+  name: 'pay-asset',
+  description: 'Send an RGB asset (USDT, XAUT) to a contact or address — resolves the contact, then sends (with confirmation).',
+  match: (t) => /\b(send|pay|transfer)\b/i.test(t) && RGB_ASSET.test(t) && !/\b(invoice|receive|swap|buy|sell|for)\b/i.test(t),
+  triggers: ['send', 'pay', 'transfer'],
+  slots: [
+    { name: 'recipient', type: 'string', description: 'Contact name, address, or RGB invoice', required: true },
+    { name: 'asset', type: 'string', description: 'RGB asset: USDT or XAUT', required: true },
+    { name: 'amount', type: 'number', description: 'Asset amount' },
+  ],
+  extract: extractAssetSend,
+  confident: (s) => !!s.recipient && !!s.asset,
+  steps: [
+    {
+      tool: 'resolve_contact',
+      as: 'contact',
+      args: (ctx) => ({ name: ctx.slots.recipient }),
+      skipIf: (ctx) => !ctx.slots.recipient || isOnchainOrInvoice(String(ctx.slots.recipient)),
+    },
+  ],
+  final: {
+    tool: 'rln_send_asset',
+    args: (ctx: RecipeContext) => {
+      const contact = ctx.results.contact as { ln_address?: string } | undefined;
+      return { asset: ctx.slots.asset, amount: ctx.slots.amount, to: contact?.ln_address ?? ctx.slots.recipient };
+    },
+  },
+  summary: (ctx) => {
+    const to = (ctx.results.contact as { name?: string } | undefined)?.name ?? ctx.slots.recipient;
+    return `Sent ${ctx.slots.amount} ${ctx.slots.asset} to ${to}.`;
+  },
+};

package/src/recipe/payments.ts

@@ -0,0 +1,116 @@
+/**
+ * Built-in "pay a contact" recipe — the flagship mobile multi-step flow.
+ *
+ *   "pay bob 3 EUR"  →  resolve_contact → fiat_to_sats → send_payment 🔒
+ *   "send 5000 sats to alice"  →  resolve_contact → send_payment 🔒
+ *
+ * Uses the canonical contract tools. The deterministic extractor handles most
+ * phrasings with no LLM at all (Tier-0); the runner falls back to one LLM
+ * extraction otherwise.
+ */
+
+import type { Recipe, RecipeContext } from './types.js';
+
+const CURRENCIES = /\b(sats?|sat|btc|usdt|xaut|eur|usd|gbp|dollars?|euros?|pounds?)\b/i;
+const isOnchainOrInvoice = (s: string) => /^(ln(bc|tb|bcrt)|bc1|tb1|lnurl|[a-z0-9._-]+@)/i.test(s.trim());
+
+function normCurrency(c?: string): string | undefined {
+  if (!c) return undefined;
+  const x = c.toLowerCase();
+  if (/^sat/.test(x)) return 'sats';
+  if (x === 'btc') return 'btc';
+  if (/dollar|^usd/.test(x)) return 'usd';
+  if (/euro|^eur/.test(x)) return 'eur';
+  if (/pound|^gbp/.test(x)) return 'gbp';
+  return x.toUpperCase();
+}
+
+/** "pay bob 3 eur", "send 5,000 sats to alice", "pay lnbc... ", "send 0.001 btc to bob" */
+export function extractPayment(text: string): Record<string, unknown> | null {
+  const t = text.trim();
+  if (!/\b(pay|send|transfer)\b/i.test(t)) return null;
+
+  // Amount with optional k/m shorthand: "5k" → 5000, "2m" → 2_000_000.
+  const amtMatch = t.match(/(\d[\d.,]*)\s*([km])?\b/i);
+  let amountNum = amtMatch ? Number(amtMatch[1]!.replace(/,/g, '')) : undefined;
+  if (amountNum != null && amtMatch?.[2]) amountNum *= amtMatch[2].toLowerCase() === 'k' ? 1_000 : 1_000_000;
+  const amount = amountNum != null && !Number.isNaN(amountNum) ? String(amountNum) : undefined;
+  const currency = normCurrency(t.match(CURRENCIES)?.[1]);
+
+  // recipient: prefer "to <x>", else the token right after pay/send that isn't a number/currency
+  let recipient = t.match(/\bto\s+([^\s,]+)/i)?.[1];
+  if (!recipient) {
+    const after = t.match(/\b(?:pay|send|transfer)\s+([^\s,]+)/i)?.[1];
+    if (after && !/^\d/.test(after) && !CURRENCIES.test(after)) recipient = after;
+  }
+  if (!recipient && !amount) return null;
+  return {
+    recipient,
+    amount: amount ? Number(amount) : undefined,
+    currency,
+  };
+}
+
+/** Compute the sats amount when no fiat conversion step is needed. */
+function directSats(ctx: RecipeContext): number | undefined {
+  const amount = Number(ctx.slots.amount);
+  if (!amount || Number.isNaN(amount)) return undefined;
+  const cur = String(ctx.slots.currency ?? 'sats').toLowerCase();
+  if (cur === 'btc') return Math.round(amount * 1e8);
+  return Math.round(amount); // sats (default)
+}
+
+const isFiat = (ctx: RecipeContext) => {
+  const c = String(ctx.slots.currency ?? '').toLowerCase();
+  return c !== '' && c !== 'sats' && c !== 'btc';
+};
+
+export const paymentsRecipe: Recipe = {
+  name: 'pay-contact',
+  description: 'Pay a contact or address — resolves the contact, converts fiat to sats, then sends (with confirmation).',
+  // A BTC/fiat spend intent — NOT a receive/invoice, and NOT an RGB-asset send
+  // ("send 10 USDT to bob" is handled by the asset-send recipe, so USDT/XAUT
+  // amounts are never mis-parsed as fiat).
+  match: (t) => /\b(pay|send|transfer)\b/i.test(t) && !/\b(invoice|receive|request|address|qr|deposit|usdt|tether|xaut|gold)\b/i.test(t),
+  triggers: ['pay', 'send', 'transfer'],
+  slots: [
+    { name: 'recipient', type: 'string', description: 'Who to pay: a contact name, Lightning address, or invoice', required: true },
+    { name: 'amount', type: 'number', description: 'The amount to send' },
+    { name: 'currency', type: 'string', description: 'Unit of the amount: sats, btc, or a fiat code like eur/usd' },
+  ],
+  extract: extractPayment,
+  confident: (s) => !!s.recipient,
+  steps: [
+    {
+      // Resolve a contact name → payable address (skip if already an address/invoice).
+      tool: 'resolve_contact',
+      as: 'contact',
+      args: (ctx) => ({ name: ctx.slots.recipient }),
+      skipIf: (ctx) => !ctx.slots.recipient || isOnchainOrInvoice(String(ctx.slots.recipient)),
+    },
+    {
+      // Convert fiat → sats (skip when the amount is already sats/btc or absent).
+      tool: 'fiat_to_sats',
+      as: 'conv',
+      args: (ctx) => ({ amount: ctx.slots.amount, currency: ctx.slots.currency }),
+      skipIf: (ctx) => !ctx.slots.amount || !isFiat(ctx),
+    },
+  ],
+  final: {
+    tool: 'send_payment',
+    args: (ctx) => {
+      const contact = ctx.results.contact as { ln_address?: string } | undefined;
+      const conv = ctx.results.conv as { sats?: number } | undefined;
+      return {
+        to: contact?.ln_address ?? ctx.slots.recipient,
+        amount_sats: conv?.sats ?? directSats(ctx),
+      };
+    },
+  },
+  summary: (ctx) => {
+    const conv = ctx.results.conv as { sats?: number } | undefined;
+    const sats = conv?.sats ?? directSats(ctx);
+    const to = (ctx.results.contact as { name?: string } | undefined)?.name ?? ctx.slots.recipient;
+    return sats ? `Sent ${sats.toLocaleString()} sats to ${to}.` : `Payment sent to ${to}.`;
+  },
+};