@darksol/terminal 0.5.9 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darksol/terminal",
-  "version": "0.5.9",
+  "version": "0.6.1",
   "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

@@ -29,7 +29,7 @@ const config = new Conf({
     services: {
       type: 'object',
       default: {
-        oracle: 'https://acp.darksol.net/oracle',
+        oracle: 'https://acp.darksol.net/api/oracle',
         casino: 'https://casino.darksol.net',
         cards: 'https://acp.darksol.net',
         facilitator: 'https://facilitator.darksol.net',

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

@@ -19,14 +19,19 @@ export async function facilitatorHealth() {
       ['Version', data.version || '-'],
       ['Protocol', data.protocol || 'x402'],
       ['Fee', data.fee || '0%'],
-      ['Chains', Array.isArray(data.chains) ? data.chains.join(', ') : (data.chains || 'Base, Polygon')],
+      ['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 (data.contracts) {
+    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)}`);

package/src/services/oracle.js

@@ -1,16 +1,97 @@
 import { fetchJSON } from '../utils/fetch.js';
 import fetch from 'node-fetch';
-import { getServiceURL } from '../config/store.js';
+import { getServiceURL, getConfig } from '../config/store.js';
 import { theme } from '../ui/theme.js';
-import { spinner, kvDisplay, success, error } from '../ui/components.js';
+import { spinner, kvDisplay, success, error, warn, info } from '../ui/components.js';
 import { showSection } from '../ui/banner.js';
 
-const getURL = () => getServiceURL('oracle') || 'https://acp.darksol.net/oracle';
+// Oracle lives under acp.darksol.net/api/oracle/
+// Endpoints: health (free), coin/dice/number/shuffle (x402 — $0.05 USDC on Base)
+const getURL = () => {
+  const custom = getServiceURL('oracle');
+  if (custom) return custom;
+  return 'https://acp.darksol.net/api/oracle';
+};
+
+function handleX402(response) {
+  if (response === 402 || (response && response.status === 402)) {
+    warn('Oracle requires x402 payment ($0.05 USDC on Base)');
+    info('Use with agent signer: darksol signer start → requests auto-pay');
+    info('Or pay manually via facilitator: darksol facilitator');
+    return true;
+  }
+  return false;
+}
+
+async function oracleRequest(path, opts = {}) {
+  const url = `${getURL()}${path}`;
+  const resp = await fetch(url, opts);
+
+  if (resp.status === 402) {
+    // Return x402 info so caller can handle
+    const paymentHeader = resp.headers.get('payment-required');
+    let paymentInfo = null;
+    if (paymentHeader) {
+      try {
+        paymentInfo = JSON.parse(Buffer.from(paymentHeader, 'base64').toString());
+      } catch {}
+    }
+    return { x402: true, paymentInfo, status: 402 };
+  }
+
+  const ct = resp.headers.get('content-type') || '';
+  if (!ct.includes('json')) {
+    throw new Error(`Oracle returned non-JSON response (${resp.status})`);
+  }
+  return await resp.json();
+}
+
+export async function oracleHealth() {
+  const spin = spinner('Checking oracle...').start();
+  try {
+    const data = await oracleRequest('/health');
+    if (data.x402) {
+      spin.succeed('Oracle online (health should be free)');
+      return;
+    }
+    spin.succeed('Oracle online');
+
+    showSection('ORACLE STATUS');
+    kvDisplay([
+      ['Status', data.status === 'ok' ? theme.success('● Online') : theme.error('○ ' + data.status)],
+      ['Contract', data.contract || '-'],
+      ['Chain', data.chain || 'base'],
+      ['Block', String(data.blockNumber || '-')],
+    ]);
+    console.log('');
+    info('Endpoints require x402 payment ($0.05 USDC on Base)');
+    info('Games: coin flip, dice, random number, shuffle');
+    info('Docs: https://acp.darksol.net/oracle');
+  } catch (err) {
+    spin.fail('Oracle unreachable');
+    error(err.message);
+  }
+}
 
 export async function oracleFlip() {
   const spin = spinner('Flipping coin...').start();
   try {
-    const data = await fetchJSON(`${getURL()}/api/coin`);
+    const data = await oracleRequest('/coin');
+    if (data.x402) {
+      spin.info('Payment required');
+      handleX402(data);
+      if (data.paymentInfo) {
+        const accepts = data.paymentInfo.accepts?.[0];
+        if (accepts) {
+          kvDisplay([
+            ['Amount', `$${(parseInt(accepts.amount) / 1e6).toFixed(2)} USDC`],
+            ['Network', 'Base'],
+            ['Pay To', accepts.payTo || '-'],
+          ]);
+        }
+      }
+      return;
+    }
     spin.succeed('Coin flipped');
     showSection('ORACLE — COIN FLIP');
     kvDisplay([
@@ -26,7 +107,12 @@ export async function oracleFlip() {
 export async function oracleDice(sides = 6) {
   const spin = spinner(`Rolling d${sides}...`).start();
   try {
-    const data = await fetchJSON(`${getURL()}/api/dice?sides=${sides}`);
+    const data = await oracleRequest(`/dice?sides=${sides}`);
+    if (data.x402) {
+      spin.info('Payment required');
+      handleX402(data);
+      return;
+    }
     spin.succeed('Dice rolled');
     showSection(`ORACLE — D${sides}`);
     kvDisplay([
@@ -43,7 +129,12 @@ export async function oracleDice(sides = 6) {
 export async function oracleNumber(min = 1, max = 100) {
   const spin = spinner(`Generating number ${min}-${max}...`).start();
   try {
-    const data = await fetchJSON(`${getURL()}/api/number?min=${min}&max=${max}`);
+    const data = await oracleRequest(`/number?min=${min}&max=${max}`);
+    if (data.x402) {
+      spin.info('Payment required');
+      handleX402(data);
+      return;
+    }
     spin.succeed('Number generated');
     showSection('ORACLE — RANDOM NUMBER');
     kvDisplay([
@@ -60,11 +151,16 @@ export async function oracleNumber(min = 1, max = 100) {
 export async function oracleShuffle(items) {
   const spin = spinner('Shuffling...').start();
   try {
-    const data = await fetchJSON(`${getURL()}/api/shuffle`, {
+    const data = await oracleRequest('/shuffle', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ items }),
     });
+    if (data.x402) {
+      spin.info('Payment required');
+      handleX402(data);
+      return;
+    }
     spin.succeed('Shuffled');
     showSection('ORACLE — SHUFFLE');
     console.log(theme.gold('  Result: ') + (data.result || data.value || []).join(', '));
@@ -73,16 +169,3 @@ export async function oracleShuffle(items) {
     error(err.message);
   }
 }
-
-export async function oracleHealth() {
-  const spin = spinner('Checking oracle...').start();
-  try {
-    const data = await fetchJSON(`${getURL()}/api/health`);
-    spin.succeed('Oracle online');
-    showSection('ORACLE STATUS');
-    kvDisplay(Object.entries(data).map(([k, v]) => [k, String(v)]));
-  } catch (err) {
-    spin.fail('Oracle unreachable');
-    error(err.message);
-  }
-}

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);
       }
@@ -1121,24 +1121,38 @@ async function executeCardOrder(orderMeta, ws) {
 // ORACLE
 // ══════════════════════════════════════════════════
 async function cmdOracle(args, ws) {
+  ws.sendLine(`${ANSI.gold}  ◆ RANDOM ORACLE 🎲${ANSI.reset}`);
+  ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
   try {
-    const resp = await fetch('https://acp.darksol.net/oracle');
+    const resp = await fetch('https://acp.darksol.net/api/oracle/health');
+    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}  ◆ ORACLE${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}acp.darksol.net/oracle${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.darkGold}Status${ANSI.reset}       ${data.status === 'ok' ? `${ANSI.green}● Online${ANSI.reset}` : `${ANSI.red}○ ${data.status}${ANSI.reset}`}`);
+    ws.sendLine(`  ${ANSI.darkGold}Contract${ANSI.reset}     ${ANSI.dim}${data.contract || '-'}${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.darkGold}Chain${ANSI.reset}        ${ANSI.white}${data.chain || 'base'}${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.darkGold}Block${ANSI.reset}        ${ANSI.white}${data.blockNumber || '-'}${ANSI.reset}`);
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.gold}ENDPOINTS${ANSI.reset}  ${ANSI.dim}x402-gated ($0.05 USDC on Base)${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.white}🪙 /coin${ANSI.reset}      ${ANSI.dim}Fair coin flip${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.white}🎲 /dice${ANSI.reset}      ${ANSI.dim}Roll with N sides${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.white}🔢 /number${ANSI.reset}    ${ANSI.dim}Random in range${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.white}🔀 /shuffle${ANSI.reset}   ${ANSI.dim}Shuffle a list${ANSI.reset}`);
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.dim}CLI: darksol oracle flip / dice / number / shuffle${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}Docs: https://acp.darksol.net/oracle${ANSI.reset}`);
     ws.sendLine('');
   } catch {
-    ws.sendLine(`  ${ANSI.dim}Oracle unreachable${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.red}○ Oracle unreachable${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}Check: https://acp.darksol.net/oracle${ANSI.reset}`);
     ws.sendLine('');
   }
   return {};
 }
 
 async function cmdCasino(args, ws) {
-  ws.sendLine(`${ANSI.gold}  ◆ CASINO${ANSI.reset}`);
+  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/api/stats');
@@ -1146,12 +1160,19 @@ async function cmdCasino(args, ws) {
     if (!ct.includes('json')) throw new Error('not json');
     const data = await resp.json();
 
-    ws.sendLine(`  ${ANSI.darkGold}Status${ANSI.reset}     ${ANSI.green}● Online${ANSI.reset}`);
-    ws.sendLine(`  ${ANSI.darkGold}Bankroll${ANSI.reset}   ${ANSI.white}$${data.bankrollUsdc || '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(`  ${ANSI.darkGold}Endpoint${ANSI.reset}   ${ANSI.blue}casino.darksol.net${ANSI.reset}`);
-    ws.sendLine(`  ${ANSI.darkGold}Docs${ANSI.reset}       ${ANSI.blue}casino.darksol.net/docs${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.red}○ Casino unreachable${ANSI.reset}`);
@@ -1174,7 +1195,7 @@ async function cmdFacilitator(args, ws) {
     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.join(', ') : 'Base, Polygon'}${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 {