@darksol/terminal 0.5.8 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darksol/terminal",
-  "version": "0.5.8",
+  "version": "0.6.0",
   "description": "DARKSOL Terminal — unified CLI for all DARKSOL services. Market intel, trading, oracle, casino, and more.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -15,7 +15,7 @@ import { snipeToken, watchSnipe } from './trading/snipe.js';
 import { createDCA, listDCA, cancelDCA, runDCA } from './trading/dca.js';
 import { topMovers, tokenDetail, compareTokens } from './services/market.js';
 import { oracleFlip, oracleDice, oracleNumber, oracleShuffle, oracleHealth } from './services/oracle.js';
-import { casinoBet, casinoTables, casinoStats, casinoReceipt } from './services/casino.js';
+import { casinoBet, casinoTables, casinoStats, casinoReceipt, casinoHealth, casinoVerify } from './services/casino.js';
 import { cardsCatalog, cardsOrder, cardsStatus } from './services/cards.js';
 import { facilitatorHealth, facilitatorVerify, facilitatorSettle } from './services/facilitator.js';
 import { buildersLeaderboard, buildersLookup, buildersFeed } from './services/builders.js';
@@ -238,15 +238,26 @@ export function cli(argv) {
     .description('The Clawsino — on-chain betting');
 
   casino
-    .command('bet <game> [choice]')
-    .description('Place a bet (coin-flip, dice, hilo, slots)')
-    .option('-n, --number <n>', 'Number for dice over/under')
-    .option('-w, --wallet <addr>', 'Wallet address')
-    .action((game, choice, opts) => casinoBet(game, { choice, ...opts }));
+    .command('status')
+    .description('House status, balance, games')
+    .action(() => casinoHealth());
+
+  casino
+    .command('bet [game]')
+    .description('Place a $1 USDC bet (interactive if game omitted)')
+    .option('-c, --choice <choice>', 'heads/tails, higher/lower')
+    .option('-d, --direction <dir>', 'over/under (dice)')
+    .option('-t, --threshold <n>', 'Dice threshold 2-5')
+    .option('-w, --wallet <addr>', 'Payout wallet address')
+    .action((game, opts) => casinoBet(game, {
+      choice: opts.choice,
+      direction: opts.direction,
+      threshold: opts.threshold ? parseInt(opts.threshold) : undefined,
+    }, { wallet: opts.wallet }));
 
   casino
     .command('tables')
-    .description('View game tables')
+    .description('Recent bets')
     .action(() => casinoTables());
 
   casino
@@ -256,9 +267,14 @@ export function cli(argv) {
 
   casino
     .command('receipt <id>')
-    .description('Verify bet receipt')
+    .description('Get bet receipt')
     .action((id) => casinoReceipt(id));
 
+  casino
+    .command('verify <id>')
+    .description('Verify bet on-chain')
+    .action((id) => casinoVerify(id));
+
   // ═══════════════════════════════════════
   // CARDS COMMANDS
   // ═══════════════════════════════════════

package/src/config/store.js

@@ -31,7 +31,7 @@ const config = new Conf({
       default: {
         oracle: 'https://acp.darksol.net/oracle',
         casino: 'https://casino.darksol.net',
-        cards: 'https://acp.darksol.net/cards',
+        cards: 'https://acp.darksol.net',
         facilitator: 'https://facilitator.darksol.net',
         builders: 'https://builders.darksol.net',
         market: 'https://acp.darksol.net/market',

package/src/llm/intent.js

@@ -65,8 +65,16 @@ ACTIONS (use the most specific one):
 - "analyze" — deep analysis of a token
 - "gas" — gas price check
 - "cards" — order a prepaid Visa/Mastercard with crypto (e.g. "order a $50 card", "get me a prepaid card")
+- "casino" — play a casino game (coinflip, dice, hilo, slots). All bets are $1 USDC. (e.g. "flip a coin", "bet on heads", "play slots", "roll dice over 3")
 - "unknown" — can't determine what the user wants
 
+CASINO GAMES:
+- coinflip: { "choice": "heads" | "tails" } → 1.90x payout
+- dice: { "direction": "over"|"under", "threshold": 2-5 } → variable payout
+- hilo: { "choice": "higher" | "lower" } → ~2.06x payout
+- slots: {} → Match-3: 5.00x, Match-2: 1.50x
+All bets are exactly $1 USDC. House edge: 5%. Results verified on-chain.
+
 CARDS ORDERING:
 When the user wants to order a prepaid card, you MUST collect:
 1. amount — ONLY these denominations: $10, $25, $50, $100, $250, $500, $1000
@@ -91,7 +99,7 @@ If they mention AgentMail or "my email", suggest using their configured agent em
 
 When parsing, respond with ONLY valid JSON:
 {
-  "action": "swap|send|snipe|dca|price|balance|info|analyze|gas|cards|unknown",
+  "action": "swap|send|snipe|dca|price|balance|info|analyze|gas|cards|casino|unknown",
   "tokenIn": "symbol or address (for swaps)",
   "tokenOut": "symbol or address (for swaps)",
   "token": "symbol (for send/price/analyze)",
@@ -100,6 +108,8 @@ When parsing, respond with ONLY valid JSON:
   "email": "delivery email (for cards)",
   "provider": "card provider (for cards, default: swype)",
   "ticker": "payment crypto (for cards, default: usdc)",
+  "gameType": "casino game: coinflip|dice|hilo|slots",
+  "betParams": "casino bet parameters object",
   "chain": "chain name if specified, null if not",
   "interval": "for DCA: 1h, 4h, 1d, etc.",
   "orders": "for DCA: number of orders",
@@ -147,6 +157,7 @@ COMMAND MAPPING:
 - balance → darksol wallet balance
 - gas → darksol gas <chain>
 - cards → darksol cards order -p <provider> -a <amount> -e <email> --ticker <crypto>
+- casino → darksol casino bet <game> -c <choice>
 - analyze → darksol ai analyze <token>`;
 
 // ──────────────────────────────────────────────────
@@ -292,7 +303,7 @@ export async function startChat(opts = {}) {
       }
 
       // Try to detect actionable intent
-      const actionKeywords = /\b(swap|send|transfer|buy|sell|snipe|dca|price|balance|gas|card|cards|order|prepaid|visa|mastercard)\b/i;
+      const actionKeywords = /\b(swap|send|transfer|buy|sell|snipe|dca|price|balance|gas|card|cards|order|prepaid|visa|mastercard|casino|bet|coinflip|coin|flip|dice|slots|hilo|gamble|play)\b/i;
       const isActionable = actionKeywords.test(input);
 
       let result;
@@ -628,6 +639,17 @@ export async function executeIntent(intent, opts = {}) {
         return { success: true, action: 'gas' };
       }
 
+      case 'casino': {
+        const { casinoBet } = await import('../services/casino.js');
+        const gameType = intent.gameType || 'coinflip';
+        const betParams = intent.betParams || {};
+        // Map common AI outputs
+        if (intent.choice) betParams.choice = intent.choice;
+        if (intent.direction) betParams.direction = intent.direction;
+        if (intent.threshold) betParams.threshold = intent.threshold;
+        return await casinoBet(gameType, betParams, { wallet: opts.wallet });
+      }
+
       case 'cards': {
         if (!intent.amount) {
           info('What denomination? We have $10, $25, $50, $100, $250, $500, $1000');

package/src/services/casino.js

@@ -1,92 +1,291 @@
 import { fetchJSON } from '../utils/fetch.js';
 import fetch from 'node-fetch';
 import { getServiceURL } from '../config/store.js';
+import { getConfig } from '../config/store.js';
 import { theme } from '../ui/theme.js';
-import { spinner, kvDisplay, success, error, table } from '../ui/components.js';
+import { spinner, kvDisplay, success, error, warn, info, table } from '../ui/components.js';
 import { showSection } from '../ui/banner.js';
 
 const getURL = () => getServiceURL('casino') || 'https://casino.darksol.net';
 
-export async function casinoBet(game, opts = {}) {
-  const spin = spinner(`Placing ${game} bet...`).start();
+// Available games with their bet params
+const GAMES = {
+  coinflip: {
+    name: '🪙 Coin Flip',
+    payout: '1.90x',
+    params: { choice: ['heads', 'tails'] },
+    desc: 'Call heads or tails',
+  },
+  dice: {
+    name: '🎲 Dice',
+    payout: 'variable',
+    params: { direction: ['over', 'under'], threshold: [2, 3, 4, 5] },
+    desc: 'Over/under a number (2-5)',
+  },
+  hilo: {
+    name: '🃏 Hi-Lo',
+    payout: '~2.06x',
+    params: { choice: ['higher', 'lower'] },
+    desc: 'Higher or lower',
+  },
+  slots: {
+    name: '🎰 Slots',
+    payout: '1.50-5.00x',
+    params: {},
+    desc: 'Match symbols — no params needed',
+  },
+};
+
+export { GAMES };
+
+/**
+ * Check casino health + x402 payment info
+ */
+export async function casinoHealth() {
+  const spin = spinner('Checking casino...').start();
+  try {
+    const stats = await fetchJSON(`${getURL()}/api/stats`);
+    spin.succeed('Casino online');
+
+    showSection('THE CLAWSINO 🎰');
+    kvDisplay([
+      ['Status', stats.acceptingBets ? theme.success('● Open') : theme.error('○ Closed')],
+      ['House Balance', `$${stats.houseBalanceUsdc || '0'} USDC`],
+      ['Total Bets', String(stats.totalBets || 0)],
+      ['Total Wagered', `$${stats.totalWageredUsdc || '0'} USDC`],
+      ['Total Payouts', `$${stats.totalPayoutsUsdc || '0'} USDC`],
+      ['Win Rate', stats.winRate || '0%'],
+    ]);
+
+    console.log('');
+    showSection('GAMES');
+    for (const [id, g] of Object.entries(GAMES)) {
+      console.log(`  ${theme.gold(g.name.padEnd(20))} ${theme.dim(g.payout.padEnd(12))} ${g.desc}`);
+    }
+    console.log('');
+    info('All bets are $1 USDC. House edge: 5%.');
+    info('Docs: https://casino.darksol.net/docs');
+  } catch (err) {
+    spin.fail('Casino unreachable');
+    error(err.message);
+    info('Check: https://casino.darksol.net/docs');
+  }
+}
+
+/**
+ * Place a bet — requires wallet address for payouts
+ */
+export async function casinoBet(gameType, betParams = {}, opts = {}) {
+  const inquirer = (await import('inquirer')).default;
+  const game = GAMES[gameType];
+
+  // Validate or prompt for game type
+  if (!game) {
+    if (gameType) warn(`Unknown game: ${gameType}`);
+    const { picked } = await inquirer.prompt([{
+      type: 'list',
+      name: 'picked',
+      message: theme.gold('Pick a game:'),
+      choices: Object.entries(GAMES).map(([id, g]) => ({ name: `${g.name}  ${g.payout}  — ${g.desc}`, value: id })),
+    }]);
+    gameType = picked;
+  }
+
+  const gameInfo = GAMES[gameType];
+
+  // Collect bet params based on game
+  if (gameType === 'coinflip' && !betParams.choice) {
+    const { choice } = await inquirer.prompt([{
+      type: 'list',
+      name: 'choice',
+      message: theme.gold('Heads or tails?'),
+      choices: ['heads', 'tails'],
+    }]);
+    betParams.choice = choice;
+  }
+
+  if (gameType === 'dice') {
+    if (!betParams.direction) {
+      const { direction } = await inquirer.prompt([{
+        type: 'list',
+        name: 'direction',
+        message: theme.gold('Over or under?'),
+        choices: ['over', 'under'],
+      }]);
+      betParams.direction = direction;
+    }
+    if (!betParams.threshold) {
+      const { threshold } = await inquirer.prompt([{
+        type: 'list',
+        name: 'threshold',
+        message: theme.gold('Threshold (2-5):'),
+        choices: ['2', '3', '4', '5'],
+      }]);
+      betParams.threshold = parseInt(threshold);
+    }
+  }
+
+  if (gameType === 'hilo' && !betParams.choice) {
+    const { choice } = await inquirer.prompt([{
+      type: 'list',
+      name: 'choice',
+      message: theme.gold('Higher or lower?'),
+      choices: ['higher', 'lower'],
+    }]);
+    betParams.choice = choice;
+  }
+
+  // Get wallet address
+  let agentWallet = opts.wallet;
+  if (!agentWallet) {
+    const activeWallet = getConfig('activeWallet');
+    if (activeWallet) {
+      try {
+        const { loadWallet } = await import('../wallet/keystore.js');
+        const w = loadWallet(activeWallet);
+        agentWallet = w.address;
+      } catch {}
+    }
+  }
+  if (!agentWallet) {
+    const { addr } = await inquirer.prompt([{
+      type: 'input',
+      name: 'addr',
+      message: theme.gold('Your wallet address (for payouts):'),
+      validate: v => v.startsWith('0x') && v.length === 42 ? true : 'Enter a valid 0x address',
+    }]);
+    agentWallet = addr;
+  }
+
+  // Confirm
+  console.log('');
+  kvDisplay([
+    ['Game', gameInfo.name],
+    ['Bet', '$1 USDC'],
+    ['Params', JSON.stringify(betParams)],
+    ['Payout Wallet', agentWallet],
+    ['Payout', gameInfo.payout],
+  ]);
+  console.log('');
+
+  const { confirm } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'confirm',
+    message: theme.gold('Place $1 USDC bet?'),
+    default: false,
+  }]);
+
+  if (!confirm) {
+    warn('Bet cancelled');
+    return;
+  }
+
+  const spin = spinner(`Playing ${gameInfo.name}...`).start();
   try {
     const data = await fetchJSON(`${getURL()}/api/bet`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        game,
-        choice: opts.choice,
-        number: opts.number,
-        wallet: opts.wallet,
-      }),
+      body: JSON.stringify({ gameType, betParams, agentWallet }),
     });
-    spin.succeed('Bet placed');
 
-    showSection(`CASINO — ${game.toUpperCase()}`);
+    if (data.won) {
+      spin.succeed(theme.success(`YOU WON! $${data.payoutAmount} USDC`));
+    } else {
+      spin.fail('You lost.');
+    }
+
+    console.log('');
+    showSection(`${gameInfo.name} RESULT`);
     kvDisplay([
-      ['Game', game],
-      ['Your Call', opts.choice || opts.number || 'N/A'],
-      ['Result', data.result ? theme.gold.bold(data.result) : 'N/A'],
-      ['Won', data.won ? theme.success.bold('YES!') : theme.error('No')],
-      ['Payout', data.payout ? `$${data.payout}` : '$0'],
-      ['TX', data.txHash || 'N/A'],
+      ['Bet ID', data.id || '-'],
+      ['Result', data.result || '-'],
+      ['Won', data.won ? theme.success('YES! 🎉') : theme.error('No')],
+      ['Payout', data.won ? `$${data.payoutAmount} USDC` : '$0'],
+      ['Oracle TX', data.oracleTxHash ? data.oracleTxHash.slice(0, 20) + '...' : '-'],
+      ['Payout TX', data.payoutTxHash ? data.payoutTxHash.slice(0, 20) + '...' : '-'],
     ]);
+
+    if (data.id) {
+      console.log('');
+      info(`Verify on-chain: darksol casino verify ${data.id}`);
+    }
+    console.log('');
   } catch (err) {
     spin.fail('Bet failed');
     error(err.message);
+    if (err.message.includes('not accepting') || err.message.includes('closed')) {
+      info('The casino may be temporarily closed. Check: darksol casino status');
+    }
   }
 }
 
+/**
+ * Show recent bets
+ */
 export async function casinoTables() {
-  const spin = spinner('Loading tables...').start();
+  const spin = spinner('Loading recent bets...').start();
   try {
     const data = await fetchJSON(`${getURL()}/api/tables`);
-    spin.succeed('Tables loaded');
-
-    showSection('CASINO TABLES');
-    const tables = data.tables || data;
-    if (Array.isArray(tables)) {
-      const rows = tables.map(t => [
-        theme.gold(t.name || t.game),
-        t.multiplier || 'N/A',
-        t.minBet || '$1',
-        t.status || 'Open',
-      ]);
-      table(['Game', 'Multiplier', 'Min Bet', 'Status'], rows);
-    } else {
-      kvDisplay(Object.entries(tables).map(([k, v]) => [k, String(v)]));
+    spin.succeed('Loaded');
+
+    const items = data.items || [];
+    if (items.length === 0) {
+      info('No recent bets');
+      return;
     }
+
+    showSection('RECENT BETS');
+    const rows = items.map(b => [
+      b.gameType || '-',
+      b.result || '-',
+      b.won ? theme.success('Won') : theme.error('Lost'),
+      b.payoutAmount ? `$${b.payoutAmount}` : '$0',
+      b.agentWallet ? b.agentWallet.slice(0, 8) + '...' : '-',
+    ]);
+    table(['Game', 'Result', 'Won', 'Payout', 'Wallet'], rows);
   } catch (err) {
-    spin.fail('Failed to load tables');
+    spin.fail('Failed');
     error(err.message);
   }
 }
 
+/**
+ * Get stats
+ */
 export async function casinoStats() {
-  const spin = spinner('Loading stats...').start();
+  return await casinoHealth();
+}
+
+/**
+ * Get receipt for a bet
+ */
+export async function casinoReceipt(id) {
+  const spin = spinner(`Loading receipt ${id}...`).start();
   try {
-    const data = await fetchJSON(`${getURL()}/api/stats`);
-    spin.succeed('Stats loaded');
+    const data = await fetchJSON(`${getURL()}/api/receipt/${id}`);
+    spin.succeed('Receipt loaded');
 
-    showSection('CASINO STATS');
+    showSection(`BET RECEIPT — ${id}`);
     kvDisplay(Object.entries(data).map(([k, v]) => [k, typeof v === 'object' ? JSON.stringify(v) : String(v)]));
   } catch (err) {
-    spin.fail('Failed to load stats');
+    spin.fail('Receipt not found');
     error(err.message);
   }
 }
 
-export async function casinoReceipt(id) {
-  const spin = spinner(`Loading receipt ${id}...`).start();
+/**
+ * Verify a bet on-chain
+ */
+export async function casinoVerify(id) {
+  const spin = spinner(`Verifying ${id}...`).start();
   try {
-    const data = await fetchJSON(`${getURL()}/api/receipt/${id}`);
-    spin.succeed('Receipt loaded');
+    const data = await fetchJSON(`${getURL()}/api/verify/${id}`);
+    spin.succeed('Verified');
 
-    showSection(`CASINO RECEIPT — ${id}`);
+    showSection(`ON-CHAIN VERIFICATION — ${id}`);
     kvDisplay(Object.entries(data).map(([k, v]) => [k, String(v)]));
   } catch (err) {
-    spin.fail('Receipt not found');
+    spin.fail('Verification failed');
     error(err.message);
   }
 }
-

package/src/services/facilitator.js

@@ -1,29 +1,55 @@
 import { fetchJSON } from '../utils/fetch.js';
 import { getServiceURL } from '../config/store.js';
 import { theme } from '../ui/theme.js';
-import { spinner, kvDisplay, error } from '../ui/components.js';
+import { spinner, kvDisplay, error, info } from '../ui/components.js';
 import { showSection } from '../ui/banner.js';
 
+// Facilitator root returns service info (no /api/health path)
 const getURL = () => getServiceURL('facilitator') || 'https://facilitator.darksol.net';
 
 export async function facilitatorHealth() {
   const spin = spinner('Checking facilitator...').start();
   try {
-    const data = await fetchJSON(`${getURL()}/api/health`);
+    const data = await fetchJSON(`${getURL()}/`);
     spin.succeed('Facilitator online');
 
-    showSection('FACILITATOR STATUS');
-    kvDisplay(Object.entries(data).map(([k, v]) => [k, typeof v === 'object' ? JSON.stringify(v) : String(v)]));
+    showSection('x402 FACILITATOR');
+    kvDisplay([
+      ['Service', data.service || 'DARKSOL Facilitator'],
+      ['Version', data.version || '-'],
+      ['Protocol', data.protocol || 'x402'],
+      ['Fee', data.fee || '0%'],
+      ['Chains', Array.isArray(data.chains) ? data.chains.map(c => c.chain || c).join(', ') : (data.chains || 'Base, Polygon')],
+      ['Status', theme.success('● Online')],
+    ]);
+    if (data.description) {
+      console.log('');
+      console.log(theme.dim(`  ${data.description}`));
+    }
+    if (Array.isArray(data.chains)) {
+      console.log('');
+      for (const c of data.chains) {
+        console.log(`  ${theme.gold((c.chain || '').padEnd(10))} ${theme.dim(c.facilitator || '')}  ${c.status === 'operational' ? theme.success('●') : theme.error('○')} ${c.settlements || 0} settlements, $${c.volumeUSDC || '0'} USDC`);
+      }
+    } else if (data.contracts) {
+      console.log('');
+      for (const [chain, addr] of Object.entries(data.contracts)) {
+        console.log(`  ${theme.gold(chain.padEnd(10))} ${theme.dim(addr)}`);
+      }
+    }
+    console.log('');
+    info('Docs: https://acp.darksol.net/facilitator');
   } catch (err) {
     spin.fail('Facilitator unreachable');
     error(err.message);
+    info('Check: https://facilitator.darksol.net');
   }
 }
 
 export async function facilitatorVerify(payment) {
   const spin = spinner('Verifying payment...').start();
   try {
-    const data = await fetchJSON(`${getURL()}/api/verify`, {
+    const data = await fetchJSON(`${getURL()}/verify`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(typeof payment === 'string' ? JSON.parse(payment) : payment),
@@ -41,7 +67,7 @@ export async function facilitatorVerify(payment) {
 export async function facilitatorSettle(payment) {
   const spin = spinner('Settling on-chain...').start();
   try {
-    const data = await fetchJSON(`${getURL()}/api/settle`, {
+    const data = await fetchJSON(`${getURL()}/settle`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(typeof payment === 'string' ? JSON.parse(payment) : payment),

package/src/web/commands.js

@@ -457,7 +457,7 @@ export async function handleCommand(cmd, ws) {
       return await cmdChatLogs(args, ws);
     default: {
       // Fuzzy: if it looks like natural language, route to AI
-      const nlKeywords = /\b(swap|buy|sell|send|transfer|price|what|how|should|analyze|check|balance|gas|dca|order|card|prepaid|visa|mastercard)\b/i;
+      const nlKeywords = /\b(swap|buy|sell|send|transfer|price|what|how|should|analyze|check|balance|gas|dca|order|card|prepaid|visa|mastercard|bet|coinflip|flip|dice|slots|hilo|gamble|play|casino)\b/i;
       if (nlKeywords.test(cmd)) {
         return await cmdAI(cmd.split(/\s+/), ws);
       }
@@ -1138,34 +1138,55 @@ async function cmdOracle(args, ws) {
 }
 
 async function cmdCasino(args, ws) {
+  ws.sendLine(`${ANSI.gold}  ◆ THE CLAWSINO 🎰${ANSI.reset}`);
+  ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
   try {
-    const resp = await fetch('https://casino.darksol.net/health');
+    const resp = await fetch('https://casino.darksol.net/api/stats');
+    const ct = resp.headers.get('content-type') || '';
+    if (!ct.includes('json')) throw new Error('not json');
     const data = await resp.json();
 
-    ws.sendLine(`${ANSI.gold}  ◆ CASINO${ANSI.reset}`);
-    ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
-    ws.sendLine(`  ${ANSI.darkGold}Status${ANSI.reset}     ${data.status || 'unknown'}`);
-    ws.sendLine(`  ${ANSI.darkGold}Endpoint${ANSI.reset}   ${ANSI.blue}casino.darksol.net${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.darkGold}Status${ANSI.reset}       ${data.acceptingBets ? `${ANSI.green}● Open${ANSI.reset}` : `${ANSI.red}○ Closed${ANSI.reset}`}`);
+    ws.sendLine(`  ${ANSI.darkGold}House${ANSI.reset}        ${ANSI.white}$${data.houseBalanceUsdc || '0'} USDC${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.darkGold}Total Bets${ANSI.reset}   ${ANSI.white}${data.totalBets || 0}${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.darkGold}Win Rate${ANSI.reset}     ${ANSI.white}${data.winRate || '0%'}${ANSI.reset}`);
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.gold}GAMES${ANSI.reset}  ${ANSI.dim}All bets $1 USDC • 5% house edge${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.white}🪙 Coin Flip${ANSI.reset}   ${ANSI.dim}1.90x — heads or tails${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.white}🎲 Dice${ANSI.reset}        ${ANSI.dim}variable — over/under 2-5${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.white}🃏 Hi-Lo${ANSI.reset}       ${ANSI.dim}~2.06x — higher or lower${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.white}🎰 Slots${ANSI.reset}       ${ANSI.dim}1.50-5.00x — match symbols${ANSI.reset}`);
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.dim}Play via CLI: darksol casino bet${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}Or ask AI: "flip a coin" / "bet on heads"${ANSI.reset}`);
     ws.sendLine('');
   } catch {
-    ws.sendLine(`  ${ANSI.dim}Casino unreachable${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.red}○ Casino unreachable${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}Check: https://casino.darksol.net/docs${ANSI.reset}`);
     ws.sendLine('');
   }
   return {};
 }
 
 async function cmdFacilitator(args, ws) {
+  ws.sendLine(`${ANSI.gold}  ◆ x402 FACILITATOR${ANSI.reset}`);
+  ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
   try {
-    const resp = await fetch('https://facilitator.darksol.net/health');
+    const resp = await fetch('https://facilitator.darksol.net/');
+    const ct = resp.headers.get('content-type') || '';
+    if (!ct.includes('json')) throw new Error('not json');
     const data = await resp.json();
 
-    ws.sendLine(`${ANSI.gold}  ◆ FACILITATOR${ANSI.reset}`);
-    ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
-    ws.sendLine(`  ${ANSI.darkGold}Status${ANSI.reset}     ${data.status || 'unknown'}`);
-    ws.sendLine(`  ${ANSI.darkGold}Endpoint${ANSI.reset}   ${ANSI.blue}facilitator.darksol.net${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.darkGold}Status${ANSI.reset}     ${ANSI.green}● Online${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.darkGold}Service${ANSI.reset}    ${ANSI.white}${data.service || 'DARKSOL Facilitator'}${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.darkGold}Protocol${ANSI.reset}   ${ANSI.white}${data.protocol || 'x402'}${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.darkGold}Fee${ANSI.reset}        ${ANSI.green}${data.fee || '0%'}${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.darkGold}Chains${ANSI.reset}     ${ANSI.white}${Array.isArray(data.chains) ? data.chains.map(c => `${c.chain} (${c.status})`) .join(', ') : 'Base, Polygon'}${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.darkGold}Docs${ANSI.reset}       ${ANSI.blue}acp.darksol.net/facilitator${ANSI.reset}`);
     ws.sendLine('');
   } catch {
-    ws.sendLine(`  ${ANSI.dim}Facilitator unreachable${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.red}○ Facilitator unreachable${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}Check: https://acp.darksol.net/facilitator${ANSI.reset}`);
     ws.sendLine('');
   }
   return {};