@kaleidorg/mind 0.2.0 → 0.4.0

package/src/skills/registry.ts

@@ -75,6 +75,23 @@ const STOPWORDS = new Set([
   'show', 'tell', 'how', 'much', 'many', 'about', 'into', 'over',
 ]);
 
+/** Escape a string for safe inclusion in a regex. */
+function reEscape(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Match a trigger phrase in the query with WORD BOUNDARIES — so the
+ * `usd` trigger on a wallet skill doesn't fire on `usdt`/`usdc`, and
+ * `cafe` doesn't fire on `cafeteria`. Multi-word triggers ("near me")
+ * still work because spaces are already word boundaries.
+ */
+function triggerMatches(query: string, trigger: string): boolean {
+  const t = trigger.toLowerCase().trim();
+  if (!t) return false;
+  return new RegExp(`\\b${reEscape(t)}\\b`).test(query);
+}
+
 /** Default selector: score by meaningful keyword overlap; triggers weigh most. */
 export const keywordSelector: SkillSelector = {
   select(query, skills) {
@@ -89,8 +106,10 @@ export const keywordSelector: SkillSelector = {
       const hayWords = haystack.split(/\W+/).filter((w) => w.length > 2 && !STOPWORDS.has(w));
       let score = 0;
       for (const w of hayWords) if (words.has(w)) score += 1;
-      // Strong boost for an explicit trigger appearing in the query.
-      for (const t of skill.triggers ?? []) if (q.includes(t.toLowerCase())) score += 3;
+      // Strong boost for an explicit trigger appearing in the query — at a
+      // word boundary, so short triggers (`usd`, `eur`, `cafe`) don't leak
+      // into longer words (`usdt`, `europe`, `cafeteria`).
+      for (const t of skill.triggers ?? []) if (triggerMatches(q, t)) score += 3;
       if (score > bestScore) {
         bestScore = score;
         best = skill;

package/src/skills/skills.test.ts

@@ -75,6 +75,48 @@ Manage Lightning channels via LSPS1.`);
   });
 });
 
+describe('SkillRegistry selection — trigger word boundaries', () => {
+  // Regression: short triggers must NOT match inside longer words.
+  // Bug observed in the CLI: a wallet skill with `usd` as a trigger was
+  // picked for "what is the quote of usdt to btc" because the old
+  // q.includes("usd") was true for "usdt", outranking the trading skill.
+  const reg = new SkillRegistry();
+  reg.addMarkdown(`---
+name: wallet-fiat
+description: Check the BTC price and convert fiat to sats. Fiat support: usd, eur, gbp.
+triggers: price, eur, usd, gbp
+---
+Wallet — fiat conversion.`);
+  reg.addMarkdown(`---
+name: trading
+description: Quote and execute swaps between BTC, USDT and XAUT on KaleidoSwap.
+triggers: quote, swap, trade, usdt, xaut
+---
+Trading on the maker.`);
+
+  it("doesn't fire the `usd` trigger inside `usdt`", () => {
+    const sel = reg.select('what is the quote of usdt to btc')?.name;
+    expect(sel).toBe('trading'); // not wallet-fiat
+  });
+
+  it('still fires the `usd` trigger when the user actually said `usd`', () => {
+    const sel = reg.select('how many sats is 30 usd')?.name;
+    expect(sel).toBe('wallet-fiat');
+  });
+
+  it("doesn't fire a short trigger inside a longer word — `cafe` not in `cafeteria`", () => {
+    const r2 = new SkillRegistry();
+    r2.addMarkdown(`---
+name: merchants
+description: Find merchants that accept Bitcoin.
+triggers: cafe, restaurant, bar
+---
+Merchant finder.`);
+    expect(r2.select('the cafeteria menu')).toBeNull(); // no match
+    expect(r2.select('any bitcoin cafe nearby')?.name).toBe('merchants');
+  });
+});
+
 describe('parseSkill — real Agent-Skills spec', () => {
   it('unquotes the description, captures metadata, tolerates no tools', () => {
     const s = parseSkill(BITREFILL_SKILL);

package/src/wallet/confirm.test.ts

@@ -0,0 +1,57 @@
+/** Confirm-sheet readback — deterministic, voice-first spend summaries. */
+
+import { describe, it, expect } from 'vitest';
+import { confirmReadback } from './confirm.js';
+
+describe('confirmReadback', () => {
+  it('send_payment: sats + recipient, grouped thousands', () => {
+    expect(confirmReadback({ name: 'send_payment', arguments: { to: 'bob', amount_sats: 4800 } }))
+      .toBe('Send 4,800 sats to bob. Confirm?');
+  });
+
+  it('send_payment: explicit layer is read back', () => {
+    expect(confirmReadback({ name: 'send_payment', arguments: { to: 'bob', amount_sats: 1000000, layer: 'spark' } }))
+      .toBe('Send 1,000,000 sats to bob over Spark. Confirm?');
+  });
+
+  it('send_payment: asset amount when no sats (core router, no layer suffix)', () => {
+    expect(confirmReadback({ name: 'send_payment', arguments: { to: 'alice', asset: 'USDT', amount: 10 } }))
+      .toBe('Send 10 USDT to alice. Confirm?');
+  });
+
+  it('spark_send: layer comes from the tool, address is shortened', () => {
+    const line = confirmReadback({
+      name: 'spark_send',
+      arguments: { amount_sats: 5000, to: 'bc1qabcdef0123456789xyzlongaddress' },
+    });
+    expect(line).toBe('Send 5,000 sats to bc1qab…ress over Spark. Confirm?');
+  });
+
+  it('rln_send_asset: asset + ticker + recipient over RLN', () => {
+    expect(confirmReadback({ name: 'rln_send_asset', arguments: { asset: 'USDT', amount: 10, to: 'bob' } }))
+      .toBe('Send 10 USDT to bob over RLN. Confirm?');
+  });
+
+  it('rln_pay_invoice: invoice shortened, over RLN', () => {
+    const line = confirmReadback({
+      name: 'rln_pay_invoice',
+      arguments: { invoice: 'lnbc1ptestinvoice0123456789abcd' },
+    });
+    expect(line).toBe('Pay Lightning invoice lnbc1p…abcd over RLN. Confirm?');
+  });
+
+  it('execute_swap: from → to with amount', () => {
+    expect(confirmReadback({ name: 'execute_swap', arguments: { from_asset: 'BTC', to_asset: 'USDT', amount: 0.01 } }))
+      .toBe('Swap 0.01 BTC for USDT. Confirm?');
+  });
+
+  it('returns null for non-spend tools', () => {
+    expect(confirmReadback({ name: 'get_balances', arguments: {} })).toBeNull();
+    expect(confirmReadback({ name: 'resolve_contact', arguments: { name: 'bob' } })).toBeNull();
+  });
+
+  it('short contact names are not truncated; long refs are', () => {
+    expect(confirmReadback({ name: 'arkade_send', arguments: { amount_sats: 100, to: 'mum' } }))
+      .toBe('Send 100 sats to mum over Arkade. Confirm?');
+  });
+});

package/src/wallet/confirm.ts

@@ -0,0 +1,74 @@
+/**
+ * Confirm-sheet readback — a deterministic, voice-first summary of a spend that
+ * the host speaks before executing it ("Send 4,800 sats to bob over Spark.
+ * Confirm?"). Built from the resolved tool call, not the model: zero inference,
+ * identical on every surface, and impossible for the model to phrase around.
+ */
+
+import { getWalletTool } from './contract.js';
+
+const LAYER_LABEL: Record<string, string> = {
+  spark: 'Spark',
+  rln: 'RLN',
+  arkade: 'Arkade',
+  liquid: 'Liquid',
+};
+
+/** Group an integer with thousands separators, locale-independently (test-stable). */
+function fmtNum(n: number): string {
+  if (!Number.isFinite(n)) return String(n);
+  const neg = n < 0;
+  const [int, frac] = Math.abs(n).toString().split('.');
+  const grouped = int!.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+  return (neg ? '-' : '') + (frac ? `${grouped}.${frac}` : grouped);
+}
+
+/** Looks like an address/invoice/lnurl (vs a human contact name). */
+function isRef(s: string): boolean {
+  return /^(ln(bc|tb|bcrt)|bc1|tb1|lq1|lnurl)/i.test(s) || (s.length > 20 && !/\s/.test(s));
+}
+
+/** Shorten an address/invoice for speech; leave contact names intact. */
+function shortRef(s: string): string {
+  const v = s.trim();
+  return isRef(v) ? `${v.slice(0, 6)}…${v.slice(-4)}` : v;
+}
+
+/** " over Spark" suffix for the call's layer (explicit arg wins, else the tool's). */
+function over(name: string, args: Record<string, unknown>): string {
+  const layer = typeof args.layer === 'string' ? args.layer : getWalletTool(name)?.layer;
+  const label = layer ? LAYER_LABEL[layer] : undefined;
+  return label ? ` over ${label}` : '';
+}
+
+const sats = (v: unknown) => `${fmtNum(Number(v))} sats`;
+const asset = (amount: unknown, ticker: unknown) => `${fmtNum(Number(amount))} ${String(ticker)}`;
+
+/** A spoken confirmation ending in "Confirm?", or null for non-spend tools. */
+export function confirmReadback(call: { name: string; arguments: Record<string, unknown> }): string | null {
+  const { name, arguments: a } = call;
+  const to = (k = 'to') => shortRef(String(a[k] ?? ''));
+  const ask = (s: string) => `${s}. Confirm?`;
+
+  switch (name) {
+    case 'send_payment': {
+      const amt = a.amount_sats != null ? sats(a.amount_sats)
+        : a.asset != null && a.amount != null ? asset(a.amount, a.asset)
+        : undefined;
+      return ask(amt ? `Send ${amt} to ${to()}${over(name, a)}` : `Send a payment to ${to()}${over(name, a)}`);
+    }
+    case 'spark_send':
+    case 'arkade_send':
+      return ask(`Send ${sats(a.amount_sats)} to ${to()}${over(name, a)}`);
+    case 'rln_send_asset':
+    case 'liquid_send':
+      return ask(`Send ${asset(a.amount, a.asset)} to ${to()}${over(name, a)}`);
+    case 'rln_pay_invoice':
+      return ask(`Pay Lightning invoice ${shortRef(String(a.invoice ?? ''))}${over(name, a)}`);
+    case 'execute_swap':
+      return ask(`Swap ${fmtNum(Number(a.amount))} ${String(a.from_asset)} for ${String(a.to_asset)}`);
+    default:
+      // Unknown but spend-flagged tool → a generic, still-honest readback.
+      return getWalletTool(name)?.spend ? ask(`Confirm ${name.replace(/_/g, ' ')}`) : null;
+  }
+}

package/skills/kaleido-wallet/SKILL.md

@@ -1,28 +0,0 @@
----
-name: kaleido-wallet
-description: "Manage a KaleidoSwap Lightning + RGB wallet: check BTC and asset balances, get a receive address, create or pay Lightning invoices, send on-chain BTC, open or list channels. Triggers when the user asks about their balance, wants to receive or send funds, pay an invoice, or manage Lightning channels."
-tools: wdk_get_balances, wdk_get_asset_balance, wdk_get_address, wdk_create_ln_invoice, wdk_pay_invoice, wdk_send_btc, wdk_list_channels, wdk_open_channel, wdk_get_node_info
-triggers: balance, receive, address, send, pay, invoice, channel, deposit, withdraw, funds
-metadata:
-  author: kaleidoswap
-  version: "0.1.0"
-  surface: "kaleido-mcp (WDK node)"
----
-
-# KaleidoSwap wallet
-
-Operate the user's KaleidoSwap node (Lightning + RGB assets) through the
-`wdk_*` MCP tools.
-
-## Rules
-
-- **Read before you write.** Check the balance (`wdk_get_balances`) before any
-  send or channel open, and confirm the node is healthy (`wdk_get_node_info`).
-- **Confirm every spend.** State the amount, destination, and resulting balance,
-  then wait for explicit approval before calling `wdk_send_btc`,
-  `wdk_pay_invoice`, or `wdk_open_channel`.
-- **Match the rail to the asset.** Lightning for fast BTC/asset payments,
-  on-chain for settlement or channel funding. Use `wdk_get_asset_balance` for
-  RGB assets (USDT, XAUT, …).
-- Never reveal seeds or private keys — this skill operates a node, it is not a
-  key vault.