@curless/mcp-server 0.1.10

package/dist/index.js

@@ -0,0 +1,2007 @@
+#!/usr/bin/env node
+/**
+ * Curless MCP Server — lets any MCP-aware client (Claude Desktop, Cursor,
+ * Cline, custom LangChain agent, …) drive a Curless wallet + VCC to order
+ * coffee, book hotels, and buy office supplies through the Curless backend.
+ *
+ * v0.1 = single-user demo mode. All installs share the same demo wallets
+ * (wal-001..wal-004). v0.2 will introduce per-user API keys.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { CurlessClient, HttpError, unwrap } from './client.js';
+// ─────────────────────────────────────────────────────────────────────────
+// Config
+// ─────────────────────────────────────────────────────────────────────────
+const DEFAULT_WALLET_ID = process.env.CURLESS_WALLET_ID || 'wal-002';
+const DEFAULT_AGENT_ID = process.env.CURLESS_AGENT_ID || 'agent-002';
+// Records persisted by Curless are stamped with an `mcp-` prefix so they
+// can be distinguished from web-UI traffic in the merchant dashboard.
+// Per-tool overrides where applicable so coffee orders land under
+// ProcureAI, hotel bookings under TravelBot, etc.
+const STAMP_PREFIX = process.env.CURLESS_STAMP_PREFIX || 'mcp';
+const state = {
+    lastVccId: null,
+    lastClubmedProperty: null,
+    walletId: null,
+};
+/** Resolve the wallet id for tools: runtime switch_wallet override > env. */
+function currentWalletId() {
+    return state.walletId ?? DEFAULT_WALLET_ID;
+}
+const client = new CurlessClient();
+// ─────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────
+function stampAgent(scope) {
+    const agent = scope === 'coffee' ? 'agent-002' :
+        scope === 'hotel' ? 'agent-001' :
+            scope === 'supply' ? 'agent-004' :
+                DEFAULT_AGENT_ID;
+    // SUPPLY shares per-agent state with the web UI (inventory + reorder
+    // rules + order list ALL filter by agent_id). The web UI's LLM tools
+    // write bare `agent-004` — if MCP prefixes, we end up in a separate
+    // shadow inventory and `check_inventory` returns different rows
+    // depending on whether the user asked via Claude Desktop or the web
+    // chat. Bare canonical agent for supply inventory scope.
+    if (scope === 'supply')
+        return agent;
+    return `${STAMP_PREFIX}-${agent}`;
+}
+/**
+ * Audit identity of this MCP install for payment records — distinct
+ * from inventory scope. Always carries the stamp prefix so charge
+ * records correctly attribute to the originating MCP caller, even
+ * when the inventory scope is a shared bare agent_id (e.g. supplies).
+ * Spark bug #1 (2026-05-12): supply payments were dropping the MCP
+ * caller and showing bare 'agent-004' on incoming_payments.
+ */
+function callerAgentId() {
+    return `${STAMP_PREFIX}-${DEFAULT_AGENT_ID}`;
+}
+/**
+ * Resolve a default VCC when the caller didn't supply one. Spark MCP
+ * audit bug A (2026-05-12): `state.lastVccId` is null at the start of
+ * every new MCP session — so the documented "defaults to the most
+ * recently created VCC" semantics actually fail after a server
+ * restart. Fall back to /v1/cards filtered by this install's stamp
+ * prefix, picking the most recently-created active card that satisfies
+ * the merchant lock + estimated charge.
+ *
+ * Returns null if no suitable card exists — the caller surfaces a
+ * helpful error instead of silently picking nothing.
+ */
+/**
+ * Display-name mapping for merchant_lock values. The internal enum
+ * value stays as `cotti` / `clubmed` / `procurement` so existing
+ * card rows, charge routing, and approval gates don't have to be
+ * migrated, but every surface that shows a lock to a human or LLM
+ * gets the friendly brand name through this helper.
+ *
+ * 'cotti' → 'Cotti Coffee'  (coffee merchant rebrand, May 2026)
+ * 'clubmed' → 'Club Med'
+ * 'procurement' → 'ProcureAI'
+ * 'any' / '' → 'Any merchant'
+ */
+function merchantLockLabel(lock) {
+    const v = String(lock || '').toLowerCase();
+    // 'cotti' is the canonical post-rebrand value; 'cotti' is kept
+    // as a legacy alias so any pre-migration card row still labels
+    // correctly during the rollout.
+    if (v === 'cotti' || v === 'cotti')
+        return 'Cotti Coffee';
+    if (v === 'clubmed')
+        return 'Club Med';
+    if (v === 'procurement')
+        return 'ProcureAI';
+    if (v === 'any' || v === '')
+        return 'Any merchant';
+    return v;
+}
+async function resolveDefaultVcc(opts) {
+    if (state.lastVccId)
+        return state.lastVccId;
+    try {
+        const data = unwrap(await client.get('/v1/cards'));
+        const all = Array.isArray(data) ? data : [];
+        const ownPrefix = `${STAMP_PREFIX}-`;
+        const minBalance = Number(opts.minBalance ?? 0);
+        const matching = all
+            .filter((c) => {
+            if (!String(c.agent_id ?? '').startsWith(ownPrefix))
+                return false;
+            if (c.status !== 'active')
+                return false;
+            // Alias 'cotti' → 'cotti' so legacy card rows match the new
+            // canonical lock value even before they're migrated.
+            let lock = String(c.merchant_lock ?? '').toLowerCase();
+            if (lock === 'cotti')
+                lock = 'cotti';
+            const lockOk = !opts.merchantLock
+                || lock === ''
+                || lock === 'any'
+                || lock === opts.merchantLock;
+            if (!lockOk)
+                return false;
+            if (minBalance > 0 && Number(c.balance ?? 0) < minBalance)
+                return false;
+            return true;
+        })
+            .sort((a, b) => String(b.created_at ?? '').localeCompare(String(a.created_at ?? '')));
+        if (matching.length > 0) {
+            state.lastVccId = matching[0].id; // cache for subsequent calls in this session
+            return matching[0].id;
+        }
+    }
+    catch {
+        /* fall through to null */
+    }
+    return null;
+}
+/** Strip `_iframe_navigate` from a tool result — the local client doesn't
+ *  have an iframe to drive. Everything else passes through. */
+function stripIframe(obj) {
+    if (!obj || typeof obj !== 'object')
+        return obj;
+    const { _iframe_navigate, ...rest } = obj;
+    return rest;
+}
+/** Standardised error envelope so the LLM client gets the same shape on
+ *  HTTP failures as on tool-level errors. */
+function toErrorResult(e, hint) {
+    if (e instanceof HttpError) {
+        const body = e.body;
+        if (typeof body === 'object' && body) {
+            return { error: body.error ?? 'http_error', status: e.status, hint, ...body };
+        }
+        return { error: 'http_error', status: e.status, detail: String(body), hint };
+    }
+    const message = e instanceof Error ? e.message : String(e);
+    return { error: 'unknown_error', detail: message, hint };
+}
+const TOOLS = [
+    // ─── VCC / WALLET CORE ────────────────────────────────────────────────
+    {
+        name: 'create_vcc',
+        description: '[curless-mcp-server v0.1.9] Mint a virtual credit card backed by the Curless wallet. Returns the VCC id (remembered as the default for subsequent tool calls). The card\'s merchant_lock is ENFORCED at charge time — if you lock to one merchant, the card cannot be used at other merchants. Default lock is "any" (unrestricted). VERSION STAMP NOTE: if you observe this description changing without the version suffix advancing, that\'s a governance bug — report it. Description content is part of the API contract.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                amount: {
+                    type: 'number',
+                    minimum: 1,
+                    maximum: 100000,
+                    description: 'Spending limit in USD. Default 5000.',
+                },
+                merchant_lock: {
+                    type: 'string',
+                    enum: ['any', 'clubmed', 'cotti', 'procurement'],
+                    description: 'Restrict which merchant this card can pay. ENFORCED at charge time. The enum values are INTERNAL codes — when you describe the card to the user, say "Club Med" for clubmed, "Cotti Coffee" for cotti (the coffee merchant), "ProcureAI" for procurement, "Any merchant" for any. The display name comes back on every VCC response as `merchant_lock`; the raw enum lives under `merchant_lock_id`. Use "any" (the default) for a single card that pays every demo merchant.',
+                },
+            },
+        },
+        handler: async (args) => {
+            const amount = typeof args.amount === 'number' ? args.amount : 5000;
+            // Default 'any' — gives the user a single card that works at every
+            // demo merchant. The backend risk-rule whitelist (rule-005) accepts
+            // 'any', and merchantChargeService treats 'any' as bypass for the
+            // per-merchant lock check. Locked values still work and ARE
+            // enforced at charge time.
+            const merchant_lock = typeof args.merchant_lock === 'string' ? args.merchant_lock : 'any';
+            const data = unwrap(await client.post('/v1/hotels/quick-vcc', {
+                amount,
+                merchant_lock,
+                agent_id: `${STAMP_PREFIX}-${DEFAULT_AGENT_ID}`,
+            }));
+            state.lastVccId = data.id;
+            return {
+                vcc_id: data.id,
+                last_four: data.last_four,
+                expiry: data.expiry,
+                limit_usd: data.max_amount,
+                balance_usd: 0,
+                balance_usdc: 0,
+                // merchant_lock is the DISPLAY string ('Cotti Coffee' / 'Club Med' /
+                // 'ProcureAI' / 'Any merchant'). The raw enum lives under
+                // merchant_lock_id for callers that route on it programmatically.
+                // We don't return the raw enum under `merchant_lock` because the
+                // LLM picks it up verbatim and surfaces "cotti" to users.
+                merchant_lock: merchantLockLabel(data.merchant_lock),
+                merchant_lock_id: data.merchant_lock,
+                hint: 'Card is empty — call top_up_vcc to load USD from the wallet.',
+            };
+        },
+    },
+    {
+        name: 'top_up_vcc',
+        description: 'Move funds from a wallet bucket onto a VCC card. The card balance goes up; the named wallet bucket goes down by the same amount. Uses the most-recently-created VCC by default. Two-step under the hood: withdraw from wallet bucket, then credit the card. Wallets keep INDEPENDENT per-currency balances (USD ≠ USDC) — pass `currency` to choose which bucket to draw from (defaults to USDC since that\'s the stablecoin path). If the chosen bucket has insufficient cash, the tool returns insufficient_funds even when other buckets have money.',
+        inputSchema: {
+            type: 'object',
+            required: ['amount_usdc'],
+            properties: {
+                amount_usdc: { type: 'number', minimum: 0.01, description: 'Amount to load onto the card.' },
+                vcc_id: { type: 'string', description: 'Defaults to the most recently created VCC.' },
+                wallet_id: { type: 'string', description: 'Defaults to CURLESS_WALLET_ID.' },
+                currency: {
+                    type: 'string',
+                    enum: ['USDC', 'USD', 'USDT', 'EURC', 'EUR'],
+                    description: 'Wallet bucket to draw from. Defaults to USDC.',
+                },
+            },
+        },
+        handler: async (args) => {
+            const amount = Number(args.amount_usdc);
+            const vccId = (typeof args.vcc_id === 'string' && args.vcc_id) || state.lastVccId;
+            const walletId = (typeof args.wallet_id === 'string' && args.wallet_id) || currentWalletId();
+            const currency = typeof args.currency === 'string' && args.currency
+                ? String(args.currency).toUpperCase()
+                : 'USDC';
+            if (!vccId)
+                return { error: 'no_vcc', hint: 'Call create_vcc first or pass vcc_id explicitly.' };
+            // Step 1: debit the requested wallet bucket. Backend's
+            // per-currency check is strict — a USDC withdraw won't fall
+            // back to USD if USDC is empty.
+            let walletRes;
+            try {
+                walletRes = unwrap(await client.post(`/v1/wallets/${encodeURIComponent(walletId)}/withdraw`, {
+                    amount,
+                    currency,
+                    destination: 'vcc',
+                }));
+            }
+            catch (e) {
+                return toErrorResult(e, `Wallet withdraw failed — the wallet's ${currency} bucket may not have enough cash. Check balances with get_wallet_info; other buckets won't be drawn from automatically.`);
+            }
+            // Step 2: credit card. Use pin_funding_wallet_id (not
+            // source_wallet_id) — the wallet was ALREADY debited in
+            // step 1, and source_wallet_id would trigger fundCard's
+            // atomic-debit path, draining the wallet a SECOND time
+            // (= 2026-05-13 $2,160 orphan: wallet was already $0 from
+            // step 1 so the second debit threw insufficient_funds,
+            // card credit got rolled back, but step 1's debit was
+            // already durable in PG). pin_funding_wallet_id only
+            // stamps funding_wallet_id without touching wallet balance.
+            let cardRes;
+            try {
+                cardRes = unwrap(await client.post(`/v1/cards/${encodeURIComponent(vccId)}/fund`, {
+                    amount,
+                    currency,
+                    pin_funding_wallet_id: walletId,
+                }));
+            }
+            catch (cardErr) {
+                // Defense-in-depth rollback: step 1 already moved money,
+                // but step 2 just failed. Auto-refund the SAME bucket so
+                // we never leave funds stranded. If the rollback itself
+                // fails, surface a critical message so ops can reconcile.
+                let rollbackOk = false;
+                let rollbackMsg = '';
+                try {
+                    await client.post(`/v1/wallets/${encodeURIComponent(walletId)}/fund`, {
+                        amount,
+                        currency,
+                    });
+                    rollbackOk = true;
+                }
+                catch (rbErr) {
+                    rollbackMsg = (rbErr instanceof Error ? rbErr.message : String(rbErr));
+                }
+                return toErrorResult(cardErr, rollbackOk
+                    ? `Card credit failed; wallet has been auto-refunded ${amount} ${currency}. Safe to retry top_up_vcc.`
+                    : `CRITICAL: card credit failed AND auto-refund failed (${rollbackMsg}). Wallet may be missing ${amount} ${currency}. Contact support with wallet_id=${walletId}, vcc_id=${vccId}.`);
+            }
+            let parsed = {};
+            try {
+                parsed = typeof walletRes?.balances === 'string'
+                    ? JSON.parse(walletRes.balances)
+                    : (walletRes?.balances || {});
+            }
+            catch { /* ignore */ }
+            const cardBal = Number(cardRes?.balance ?? 0);
+            return {
+                vcc_id: vccId,
+                wallet_id: walletId,
+                amount_loaded: amount,
+                loaded_currency: currency,
+                new_card_balance_usd: cardBal,
+                // Two INDEPENDENT figures — distinct buckets, not mirrors.
+                new_wallet_balance_usd: Number(parsed.USD ?? 0),
+                new_wallet_balance_usdc: Number(parsed.USDC ?? 0),
+                balances: parsed,
+                status: 'loaded',
+            };
+        },
+    },
+    {
+        name: 'unload_vcc',
+        description: '[curless-mcp-server v0.1.9] Inverse of top_up_vcc. Move funds FROM a VCC BACK INTO a wallet bucket — useful for unloading an unused card, recovering an over-topped-up balance, or consolidating funds before closing a card. The card balance goes DOWN by `amount_usdc`; the named wallet bucket goes UP by the same. Specify `currency` to choose which destination bucket gets credited (defaults to USDC, matching the default top_up direction). Wallets keep INDEPENDENT per-currency balances. Refuses if (a) the card lacks balance — returns insufficient_funds, (b) the destination wallet is frozen or closed. Atomic at the server: if the wallet credit fails, the card decrement is rolled back so the user never loses money.',
+        inputSchema: {
+            type: 'object',
+            required: ['amount_usdc'],
+            properties: {
+                amount_usdc: { type: 'number', minimum: 0.01, description: 'Amount to move off the card.' },
+                vcc_id: { type: 'string', description: 'Defaults to the most recently created VCC in this session.' },
+                wallet_id: { type: 'string', description: 'Destination wallet. Defaults to the active wallet (CURLESS_WALLET_ID env or last switch_wallet).' },
+                currency: {
+                    type: 'string',
+                    enum: ['USDC', 'USD', 'USDT', 'EURC', 'EUR'],
+                    description: 'Destination bucket on the wallet. Defaults to USDC.',
+                },
+            },
+        },
+        handler: async (args) => {
+            const amount = Number(args.amount_usdc);
+            const vccId = (typeof args.vcc_id === 'string' && args.vcc_id) || state.lastVccId;
+            const walletId = (typeof args.wallet_id === 'string' && args.wallet_id) || currentWalletId();
+            // Choose which destination bucket to credit on the wallet.
+            // Defaults to USDC — that's the inverse of the typical
+            // stablecoin top_up. Pass currency='USD' to land in the fiat
+            // bucket instead.
+            const currency = typeof args.currency === 'string' && args.currency
+                ? String(args.currency).toUpperCase()
+                : 'USDC';
+            if (!vccId)
+                return { error: 'no_vcc', hint: 'No VCC to unload from. Pass vcc_id or create_vcc first.' };
+            if (!Number.isFinite(amount) || amount <= 0)
+                return { error: 'bad_amount', hint: 'amount_usdc must be a positive number.' };
+            try {
+                const res = unwrap(await client.post(`/v1/cards/${encodeURIComponent(vccId)}/unload`, {
+                    wallet_id: walletId,
+                    amount,
+                    currency,
+                }));
+                const cardBal = Number(res?.card_balance_after ?? 0);
+                // Pull the post-unload wallet snapshot. The legacy
+                // `wallet_usdc_after` field may not split per-currency,
+                // so prefer the balances JSON when present.
+                let parsedWallet = {};
+                try {
+                    const b = res?.balances ?? res?.wallet_balances;
+                    parsedWallet = typeof b === 'string' ? JSON.parse(b) : (b || {});
+                }
+                catch { /* ignore */ }
+                return {
+                    vcc_id: vccId,
+                    wallet_id: walletId,
+                    amount_unloaded: amount,
+                    unloaded_currency: currency,
+                    new_card_balance_usd: cardBal,
+                    // Two INDEPENDENT figures (USD bucket vs USDC bucket).
+                    new_wallet_balance_usd: Number(parsedWallet.USD ?? 0),
+                    new_wallet_balance_usdc: Number(parsedWallet.USDC ?? res?.wallet_usdc_after ?? 0),
+                    balances: parsedWallet,
+                    status: 'unloaded',
+                };
+            }
+            catch (e) {
+                return toErrorResult(e, 'Unload failed — check that the card has enough balance and the wallet is active.');
+            }
+        },
+    },
+    {
+        name: 'update_vcc_limit',
+        description: 'Raise or lower the spending limit of a VCC.',
+        inputSchema: {
+            type: 'object',
+            required: ['new_limit_usd'],
+            properties: {
+                new_limit_usd: { type: 'number', minimum: 1, maximum: 100000 },
+                vcc_id: { type: 'string', description: 'Defaults to the most recently created VCC.' },
+            },
+        },
+        handler: async (args) => {
+            const vccId = (typeof args.vcc_id === 'string' && args.vcc_id) || state.lastVccId;
+            if (!vccId)
+                return { error: 'no_vcc', hint: 'Call create_vcc first or pass vcc_id explicitly.' };
+            const newLimit = Number(args.new_limit_usd);
+            try {
+                const data = unwrap(await client.put(`/v1/vcc/${encodeURIComponent(vccId)}/limit`, { max_amount: newLimit }));
+                return {
+                    vcc_id: vccId,
+                    new_limit_usd: data?.max_amount ?? newLimit,
+                    status: 'updated',
+                };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'get_vcc_info',
+        description: 'Look up details of a VCC: last four, expiry, spending limit, current balance, merchant lock, status. Returns archived=true for cards that have been closed (residual balance was zeroed). Backend now PG-fallbacks for cross-lambda visibility, so newly-minted cards no longer 404.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                vcc_id: { type: 'string', description: 'Defaults to the most recently created VCC.' },
+            },
+        },
+        handler: async (args) => {
+            const vccId = (typeof args.vcc_id === 'string' && args.vcc_id) || state.lastVccId;
+            if (!vccId)
+                return { error: 'no_vcc' };
+            try {
+                const data = unwrap(await client.get(`/v1/vcc/${encodeURIComponent(vccId)}`));
+                // Prefer the new balance_usd field from the hydrated /v1/vcc/:id
+                // endpoint; fall back to legacy `balance` if the backend hasn't
+                // deployed yet (graceful during rollout).
+                const bal = Number(data?.balance_usd ?? data?.balance ?? 0);
+                return {
+                    vcc_id: vccId,
+                    last_four: data?.last_four,
+                    expiry: data?.expiry,
+                    limit_usd: data?.max_amount,
+                    balance_usd: bal,
+                    balance_usdc: bal,
+                    // Display string only — raw enum lives under merchant_lock_id.
+                    merchant_lock: merchantLockLabel(data?.merchant_lock),
+                    merchant_lock_id: data?.merchant_lock,
+                    status: data?.status,
+                    archived: Boolean(data?.archived),
+                };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'get_wallet_info',
+        description: '[curless-mcp-server v0.1.9] Return the active wallet (id, per-currency balances, on-chain deposit address, network, status). Wallets keep INDEPENDENT per-currency buckets: USD (fiat) and USDC (stablecoin) are tracked SEPARATELY — `balance_usd` and `balance_usdc` are two different numbers, NOT the same balance under two names. `balances` map exposes every currency held. Active wallet defaults to CURLESS_WALLET_ID env, or whatever switch_wallet last set. The `status` field tells you whether the wallet is `active`, `frozen`, or `closed` — only `active` wallets can receive deposits or pay charges.',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            try {
+                const walletId = currentWalletId();
+                const wallets = unwrap(await client.get('/v1/wallets'));
+                const w = (Array.isArray(wallets) ? wallets : []).find((x) => x.id === walletId);
+                if (!w)
+                    return { error: 'wallet_not_found', wallet_id: walletId };
+                // Independent per-currency buckets. USD (fiat) ≠ USDC
+                // (stablecoin) — they're separate balances the user can
+                // hold and operate on independently.
+                let parsed = {};
+                try {
+                    parsed = typeof w.balances === 'string' ? JSON.parse(w.balances) : (w.balances || {});
+                }
+                catch { /* ignore */ }
+                const balance_usd = Number(parsed.USD ?? 0);
+                const balance_usdc = Number(parsed.USDC ?? 0);
+                return {
+                    wallet_id: w.id,
+                    name: w.name,
+                    // Surface status so the LLM knows whether this wallet can
+                    // receive deposits or pay charges without an extra round-trip.
+                    status: w.status ?? 'unknown',
+                    // Two INDEPENDENT numbers — USD bucket vs USDC bucket.
+                    balance_usd,
+                    balance_usdc,
+                    // Full per-currency map for callers that hold USDT, EURC, EUR too.
+                    balances: parsed,
+                    // Wallet's declared primary stablecoin (used as a display hint).
+                    primary_currency: (w.stablecoin || 'USD').toUpperCase(),
+                    deposit_address: w.wallet_address ?? w.deposit_address ?? null,
+                    network: w.network ?? 'base',
+                };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'fund_wallet',
+        description: '[curless-mcp-server v0.1.9] Show how to send money INTO the active Curless wallet. Two rails, picked by `currency`: currency="USDC" (default) returns the on-chain deposit address + QR code — the user scans/copies it and sends USDC on the indicated network, balance updates after on-chain confirmation. currency="USD" returns FIAT BANK-TRANSFER details (account name, account number, bank, SWIFT, bank address) — the user wires real USD to that account; show every field to the user and tell them to put the transfer_reference in the wire memo. Server-side `assertFundable` gate refuses frozen / closed wallets BEFORE returning anything. NOTE: this is the REAL funding path; for demo/test scenarios that need instant credit, call simulate_wallet_funding instead.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                currency: {
+                    type: 'string',
+                    enum: ['USDC', 'USD'],
+                    description: 'Funding rail. "USDC" (default) → on-chain deposit address + QR. "USD" → fiat bank-transfer details. Pick "USD" when the user wants to fund in 美金 / fiat / by bank transfer.',
+                },
+                amount_usdc: {
+                    type: 'number',
+                    minimum: 0.01,
+                    description: 'Optional. Just a display hint shown next to the QR / bank details — no enforcement (the user can send any amount).',
+                },
+            },
+        },
+        handler: async (args) => {
+            const walletId = currentWalletId();
+            const currency = args.currency === 'USD' ? 'USD' : 'USDC';
+            const hintAmount = typeof args.amount_usdc === 'number' && args.amount_usdc > 0
+                ? args.amount_usdc
+                : null;
+            try {
+                // Hit the centralized deposit-info endpoint — runs the shared
+                // assertFundable gate server-side. Frozen / closed wallets
+                // come back as HTTP 400 with a precise error, propagated to
+                // the LLM as a `wallet_not_fundable` result instead of a
+                // bogus QR / bank block.
+                const info = unwrap(await client.get(`/v1/wallets/${encodeURIComponent(walletId)}/deposit-info?currency=${currency}`));
+                // ── Fiat USD rail — bank transfer ──────────────────────────
+                if (currency === 'USD') {
+                    const bank = info?.bank_transfer;
+                    if (!bank) {
+                        return { error: 'no_bank_info', wallet_id: walletId, hint: 'Bank-transfer details unavailable for this wallet.' };
+                    }
+                    return {
+                        wallet_id: walletId,
+                        status: info.status,
+                        funding_method: 'bank_transfer',
+                        currency: 'USD',
+                        suggested_amount_usd: hintAmount,
+                        bank_transfer: bank,
+                        transfer_reference: info.transfer_reference ?? walletId,
+                        instructions: `Wire ${hintAmount ? `$${hintAmount} ` : ''}USD to:\nAccount Name: ${bank.account_name}\nAccount Number: ${bank.account_number}\nBank Name: ${bank.bank_name}\nSwift Code: ${bank.swift_code}\nBank Address: ${bank.bank_address}\n\nPut "${info.transfer_reference ?? walletId}" in the transfer reference / memo. Balance updates after the transfer settles. Show ALL fields to the user verbatim.`,
+                    };
+                }
+                // ── Crypto USDC rail — on-chain deposit address ────────────
+                const address = info?.deposit_address;
+                if (!address) {
+                    return { error: 'no_deposit_address', wallet_id: walletId, hint: 'Wallet has no on-chain address configured.' };
+                }
+                const network = info.network ?? 'base';
+                const qrUrl = `https://api.qrserver.com/v1/create-qr-code/?size=300x300&data=${encodeURIComponent(address)}`;
+                return {
+                    wallet_id: walletId,
+                    status: info.status,
+                    funding_method: 'crypto',
+                    deposit_address: address,
+                    network,
+                    stablecoin: info.stablecoin ?? 'USDC',
+                    suggested_amount_usdc: hintAmount,
+                    qr_url: qrUrl,
+                    instructions: `Open your wallet app, scan the QR (or copy the address), and send ${hintAmount ?? 'any amount of'} USDC on the ${network} network. Balance updates after on-chain confirmation.`,
+                };
+            }
+            catch (e) {
+                // assertFundable failures come through HttpError(400/404) —
+                // toErrorResult passes the body through so the LLM sees e.g.
+                // { error: 'Wallet is frozen — only active wallets can receive funds', status: 400 }.
+                return toErrorResult(e, `Wallet ${walletId} cannot receive funds right now. Check status with get_wallet_info or switch_wallet to a different wallet.`);
+            }
+        },
+    },
+    {
+        name: 'simulate_wallet_funding',
+        description: '[DEMO ONLY] Instantly credit a wallet bucket without an on-chain transfer. Skips the QR/scan flow — useful for tests, walkthroughs, and CI. Specify `currency` to choose which bucket gets credited (USDC, USD, USDT, EURC, EUR). Defaults to USDC — that\'s the on-chain stablecoin path this tool simulates. Wallets keep INDEPENDENT per-currency balances; this only credits the bucket you name. Production usage should call fund_wallet instead.',
+        inputSchema: {
+            type: 'object',
+            required: ['amount_usdc'],
+            properties: {
+                amount_usdc: { type: 'number', minimum: 0.01 },
+                currency: {
+                    type: 'string',
+                    enum: ['USDC', 'USD', 'USDT', 'EURC', 'EUR'],
+                    description: 'Wallet bucket to credit. Defaults to USDC.',
+                },
+            },
+        },
+        handler: async (args) => {
+            const amount = Number(args.amount_usdc);
+            const currency = typeof args.currency === 'string' && args.currency
+                ? String(args.currency).toUpperCase()
+                : 'USDC';
+            try {
+                const walletId = currentWalletId();
+                const data = unwrap(await client.post(`/v1/wallets/${encodeURIComponent(walletId)}/fund`, {
+                    amount,
+                    currency,
+                }));
+                let parsed = {};
+                try {
+                    parsed = typeof data?.balances === 'string' ? JSON.parse(data.balances) : (data?.balances || {});
+                }
+                catch { /* ignore */ }
+                return {
+                    wallet_id: walletId,
+                    deposited_amount: amount,
+                    deposited_currency: currency,
+                    // Two INDEPENDENT figures — USD bucket vs USDC bucket.
+                    new_balance_usd: Number(parsed.USD ?? 0),
+                    new_balance_usdc: Number(parsed.USDC ?? 0),
+                    balances: parsed,
+                    status: 'funded',
+                    mode: 'simulated',
+                };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'list_wallets',
+        description: '[curless-mcp-server v0.1.9] List every wallet available to this Curless install (id, name, status, USD balance, network, deposit address). Use this before switch_wallet to discover what wallets you can target. The `status` field (active / frozen / closed) tells you which wallets can currently receive deposits or pay charges — frozen or closed wallets reject fund_wallet / simulate_wallet_funding / charge attempts with HTTP 400. Default-active wallet is whichever currentWalletId() returns; this list is the catalog.',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            try {
+                const wallets = unwrap(await client.get('/v1/wallets'));
+                const list = Array.isArray(wallets) ? wallets : [];
+                const items = list.map((w) => {
+                    let parsed = {};
+                    try {
+                        parsed = typeof w.balances === 'string' ? JSON.parse(w.balances) : (w.balances || {});
+                    }
+                    catch { /* ignore */ }
+                    return {
+                        wallet_id: w.id,
+                        name: w.name,
+                        // Surface status so callers can filter for active wallets
+                        // before routing money. Spark 2026-05-12.
+                        status: w.status ?? 'unknown',
+                        // Independent per-currency buckets. USD (fiat) and USDC
+                        // (stablecoin) are SEPARATE balances — two different numbers.
+                        balance_usd: Number(parsed.USD ?? 0),
+                        balance_usdc: Number(parsed.USDC ?? 0),
+                        balances: parsed,
+                        primary_currency: (w.stablecoin || 'USD').toUpperCase(),
+                        network: w.network ?? 'base',
+                        deposit_address: w.wallet_address ?? w.deposit_address ?? null,
+                        is_active: w.id === currentWalletId(),
+                    };
+                });
+                return { items, active_wallet_id: currentWalletId() };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'switch_wallet',
+        description: 'Change the active wallet for subsequent tool calls in this MCP session. Affects fund_wallet, get_wallet_info, top_up_vcc, simulate_wallet_funding, and any tool that uses the active wallet by default. Reverts to CURLESS_WALLET_ID env when the MCP server restarts. Use list_wallets first to find a valid wallet_id.',
+        inputSchema: {
+            type: 'object',
+            required: ['wallet_id'],
+            properties: {
+                wallet_id: { type: 'string', description: 'Target wallet id (e.g. "wal-002").' },
+            },
+        },
+        handler: async (args) => {
+            const requested = String(args.wallet_id ?? '').trim();
+            if (!requested)
+                return { error: 'no_wallet_id' };
+            // Validate the wallet exists before flipping
+            try {
+                const wallets = unwrap(await client.get('/v1/wallets'));
+                const list = Array.isArray(wallets) ? wallets : [];
+                const w = list.find((x) => x.id === requested);
+                if (!w) {
+                    return {
+                        error: 'wallet_not_found',
+                        wallet_id: requested,
+                        available: list.map((x) => x.id),
+                        hint: 'Call list_wallets for the canonical set.',
+                    };
+                }
+                const previous = currentWalletId();
+                state.walletId = requested;
+                return {
+                    previous_wallet_id: previous,
+                    active_wallet_id: requested,
+                    name: w.name,
+                    status: 'switched',
+                };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'list_vccs',
+        description: '[curless-mcp-server v0.1.9] List virtual credit cards. Returns id, last four, current loaded balance, spending limit, merchant_lock (display string), merchant_lock_id (raw enum), status. Use this to recover the list of cards available for charges, especially after restarting the MCP server (which clears the lastVccId memory). CONTRACT: by default `scope="install"` filters to cards minted by THIS MCP install (agent_id prefix = "${STAMP_PREFIX}-"). Pass `scope="all"` to see every card in the Curless account, including those minted via the web UI or other MCP installs. Status defaults to "active" — pass status="all" to include archived/frozen. The `merchant_lock` field is the DISPLAY name ("Club Med" / "Cotti Coffee" / "ProcureAI" / "Any merchant"); `merchant_lock_id` is the raw enum (any/clubmed/cotti/procurement; "cotti" appears in pre-rebrand rows as an alias for "cotti"). Use `merchant_lock` when describing cards to users.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: {
+                    type: 'string',
+                    enum: ['active', 'archived', 'frozen', 'all'],
+                    description: 'Filter by card status. Default "active".',
+                },
+                scope: {
+                    type: 'string',
+                    enum: ['install', 'all'],
+                    description: 'Ownership scope. "install" (default) returns cards minted by this MCP install (agent_id starts with the configured stamp prefix). "all" returns every card in the account.',
+                },
+                limit: { type: 'integer', minimum: 1, maximum: 100, default: 50 },
+            },
+        },
+        handler: async (args) => {
+            const statusFilter = typeof args.status === 'string' ? args.status : 'active';
+            const scopeFilter = typeof args.scope === 'string' ? args.scope : 'install';
+            const limit = Math.max(1, Math.min(100, Number(args.limit ?? 50)));
+            try {
+                // /v1/cards returns ALL cards by default. We filter client-side
+                // since the backend doesn't accept agent_id as a query param.
+                const data = unwrap(await client.get('/v1/cards'));
+                const all = Array.isArray(data) ? data : [];
+                const ownAgentPrefix = `${STAMP_PREFIX}-`;
+                const filtered = all
+                    .filter((c) => {
+                    const inScope = scopeFilter === 'all' ||
+                        String(c.agent_id ?? '').startsWith(ownAgentPrefix);
+                    const statusOk = statusFilter === 'all' || c.status === statusFilter;
+                    return inScope && statusOk;
+                })
+                    .slice(0, limit)
+                    .map((c) => {
+                    const bal = Number(c.balance ?? 0);
+                    return {
+                        vcc_id: c.id,
+                        last_four: c.last_four,
+                        balance_usd: bal,
+                        balance_usdc: bal,
+                        spending_limit_usd: c.spending_limit,
+                        // Display string only — raw enum lives under merchant_lock_id.
+                        merchant_lock: merchantLockLabel(c.merchant_lock),
+                        merchant_lock_id: c.merchant_lock ?? null,
+                        agent_id: c.agent_id,
+                        status: c.status,
+                        expiry: c.expiry,
+                        created_at: c.created_at,
+                    };
+                });
+                return {
+                    items: filtered,
+                    count: filtered.length,
+                    filter_status: statusFilter,
+                    filter_scope: scopeFilter,
+                    stamp_prefix: STAMP_PREFIX,
+                    last_vcc_id_in_session: state.lastVccId,
+                };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    // ─── COFFEE (Cotti) ───────────────────────────────────────────────────
+    {
+        name: 'list_coffees',
+        description: 'Return the Cotti Coffee menu (8 drinks), the self-pickup store directory, AND the drink customization options. Menu `price` is in CNY (¥); the VCC settles in USD — the server converts at checkout. `pickup_stores` = curated Shanghai Cotti locations (pass a store id to order_coffee for self_pickup). `drink_options` = valid cup sizes (with CNY price deltas — small −¥3, large +¥6), sugar levels, temperatures, milk toggle, plus `currency` carrying the cny_per_usd rate — source of truth for order_coffee args. Quote ¥ prices to the user; mention the ≈ USD charge when relevant. ⚠️ VERBATIM CHINESE: when you show a drink name, store name, or option label to the user, COPY the exact `name` / `name_zh` / `label_zh` string from THIS response character-for-character. NEVER re-type Chinese from memory or translate it back — doing so corrupts the characters (椰漾拿铁 → 淇漾拿铁). The strings in this JSON are authoritative.',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            try {
+                const data = unwrap(await client.get('/api/cotti/products'));
+                let pickup_stores = [];
+                try {
+                    const storeData = unwrap(await client.get('/api/cotti/pickup-stores'));
+                    pickup_stores = storeData?.stores ?? [];
+                }
+                catch { /* non-fatal */ }
+                let drink_options = null;
+                try {
+                    drink_options = unwrap(await client.get('/api/cotti/options'));
+                }
+                catch { /* non-fatal */ }
+                return {
+                    items: data?.products ?? data,
+                    menu_currency: 'CNY',
+                    pickup_stores,
+                    drink_options,
+                    fulfillment_hint: 'Menu is priced in CNY (¥); the VCC charges the USD conversion. Default fulfillment is delivery — for self-pickup, offer pickup_stores then call order_coffee with fulfillment_type="self_pickup" + pickup_store_id. Cup size / sugar / milk / temperature default to medium / standard / with-milk / hot — only pass what the user specifies.',
+                };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'order_coffee',
+        description: '[curless-mcp-server v0.1.9] Order a coffee from Cotti Coffee. Charges the active VCC. `product` accepts the canonical id (e.g. "cotti-yeyan"), Chinese name ("椰漾拿铁"), or English name — resolved automatically. (cotti-* slugs are INTERNAL ids — render the merchant as "Cotti Coffee" / "Cotti咖啡".) ⚠️ ORDER THE STEPS — fulfillment → drink → spec → order: STEP 1 ask delivery or self-pickup (配送还是自提); if self-pickup, call list_coffees, show pickup_stores, get the chosen store. STEP 2 settle WHICH drink and acknowledge it. STEP 3 — only after the drink is settled — ask the spec, picking within THAT drink\'s spec.options from list_coffees (e.g. Cold Brew is iced-only): cup_size (杯型), sugar_level (糖度), with_milk (要不要奶), temperature (冷/热). All four are REQUIRED. Calling without them returns error="spec_required"; calling with a value outside the drink\'s options returns error="spec_not_available". Do NOT silently default the spec, and do NOT ask spec before the drink is chosen. If the user says "默认/随便", pass the drink\'s spec.defaults explicitly. EXCEPTION: if the user names the drink AND all four spec fields inline ("大杯冰美式不要糖"), STEP 2+3 are covered at once. CURRENCY: the menu is priced in CNY (¥); the VCC settles in USD. The server converts at checkout — the result returns total_amount_cny (quote this) AND total_amount_usd (what was charged). Tell the user both, e.g. "¥56 (≈ $7.78 charged)". cup_size affects the price: small −¥3 / medium base / large +¥6. FULFILLMENT: defaults to delivery (delivery_address auto-fills). For self-pickup / 自提 / 到店取, pass fulfillment_type="self_pickup" AND pickup_store_id (call list_coffees for the store list). APPROVAL GATE: orders whose USD total ≥ approval threshold (default $100) return `{status: "pending_approval", approval_id, approval_url}` — surface the URL, then RETRY with `approval_id`. VCC RESOLUTION: if `vcc_id` omitted, falls back to the session\'s last-created VCC, then the most recent install-stamped active VCC whose merchant_lock allows Cotti Coffee and covers the charge. Pass `inline_screenshot` to embed a rendered page screenshot. ⚠️ VERBATIM CHINESE: when you echo a drink name, store name, or option label to the user, COPY the exact string from the list_coffees / order result JSON character-for-character. NEVER re-type Chinese from memory — it corrupts the characters (椰漾拿铁 → 淇漾拿铁, 温度 → 熨毆度).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                product: { type: 'string' },
+                quantity: { type: 'integer', minimum: 1, maximum: 200, default: 1 },
+                cup_size: { type: 'string', enum: ['small', 'medium', 'large'], description: '小杯 / 中杯 / 大杯. Default "medium". small −¥3, large +¥6 per cup (CNY).' },
+                sugar_level: { type: 'string', enum: ['none', 'less', 'standard'], description: '无糖 / 少糖 / 标准糖. Default "standard".' },
+                with_milk: { type: 'boolean', description: '要奶 / 不要奶. Default true.' },
+                temperature: { type: 'string', enum: ['hot', 'iced'], description: '热 / 冷. Default "hot".' },
+                fulfillment_type: { type: 'string', enum: ['delivery', 'self_pickup'], description: 'Default "delivery". Use "self_pickup" for 自提 / 到店取.' },
+                pickup_store_id: { type: 'string', description: 'Required when fulfillment_type="self_pickup". A store id from list_coffees → pickup_stores; a store name or district also resolves.' },
+                delivery_address: { type: 'string', description: 'Defaults to the saved demo address. Ignored for self_pickup.' },
+                customer_name: { type: 'string', description: 'Defaults to "Spark".' },
+                vcc_id: { type: 'string', description: 'Optional. Defaults to (1) session\'s last-created VCC, then (2) most recent install-stamped active VCC with cotti-compatible merchant_lock and sufficient balance.' },
+                approval_id: { type: 'string', description: 'Retry a previously gated order. Server replays the originally-approved payload — other args are ignored on replay.' },
+                inline_screenshot: { type: 'boolean', description: 'Embed an inline screenshot of the order confirmation page in the reply. DEFAULTS TO TRUE — the user wants to see the order page. Pass false to skip it (faster, no ~3-5s screenshot fetch).' },
+                // auto_open removed 2026-05-13: storefront page no longer
+                // auto-launches in the OS browser. Click the markdown link in
+                // the response instead.
+            },
+        },
+        handler: async (args) => {
+            // ── Replay branch ───────────────────────────────────────────
+            const approvalId = typeof args.approval_id === 'string' ? args.approval_id.trim() : '';
+            if (approvalId) {
+                try {
+                    const result = unwrap(await client.post('/api/cotti/checkout', { approval_id: approvalId }));
+                    if (result?.status === 'pending_approval') {
+                        return {
+                            status: 'pending_approval',
+                            approval_id: result.approval_id,
+                            approval_url: result.approval_url,
+                            amount_usd: result.amount_usd,
+                            expires_at: result.expires_at,
+                            hint: result.hint ?? 'Approval still pending. Open the URL and decide before retrying.',
+                        };
+                    }
+                    return stripIframe({
+                        order_id: result.id ?? result.order_id,
+                        product_id: result.product_id,
+                        product_name: result.product_name,
+                        quantity: result.quantity,
+                        // Menu is CNY; VCC charged the USD conversion. Surface both.
+                        total_amount_cny: result.total_amount_cny,
+                        total_amount_usd: result.total_amount_usd,
+                        exchange_rate: result.exchange_rate,
+                        menu_currency: 'CNY',
+                        charge_currency: 'USD',
+                        status: result.status,
+                        payment_id: result.payment_id,
+                        cup_size: result.cup_size ?? 'medium',
+                        sugar_level: result.sugar_level ?? 'standard',
+                        with_milk: result.with_milk ?? true,
+                        temperature: result.temperature ?? 'hot',
+                        fulfillment_type: result.fulfillment_type ?? 'delivery',
+                        pickup_store_id: result.pickup_store_id ?? null,
+                        pickup_store_name: result.pickup_store_name ?? null,
+                        pickup_store_address: result.pickup_store_address ?? null,
+                        delivery_address: result.delivery_address,
+                        vcc_last_four: result.vcc_last_four,
+                        approval_id: approvalId,
+                        view_url: (result.id ?? result.order_id) ? `https://cotti.curless.ai/order/${result.id ?? result.order_id}` : undefined,
+                        _inline_screenshot: args.inline_screenshot !== false,
+                    });
+                }
+                catch (e) {
+                    return toErrorResult(e);
+                }
+            }
+            // ── Fresh branch ────────────────────────────────────────────
+            const product = String(args.product || '').trim();
+            if (!product)
+                return { error: 'no_product' };
+            const quantity = Math.max(1, Math.min(200, Number(args.quantity ?? 1)));
+            // Resolve product against catalog first so we know the price.
+            let products = [];
+            try {
+                const cat = unwrap(await client.get('/api/cotti/products'));
+                products = cat?.products ?? cat ?? [];
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+            const lower = product.toLowerCase();
+            let resolved = products.find((p) => p.id === product) ||
+                products.find((p) => p.name === product || (p.name_en || '').toLowerCase() === lower) ||
+                products.find((p) => p.name.includes(product) || (p.name_en || '').toLowerCase().includes(lower));
+            if (!resolved) {
+                return {
+                    error: 'product_not_found',
+                    hint: `Use one of: ${products.map((p) => p.id).join(', ')}`,
+                };
+            }
+            // ── Spec gate ─────────────────────────────────────────────
+            // The agent MUST ask the user for the full drink spec before
+            // ordering — no silently-defaulted orders. Enforced at the
+            // tool boundary: reject with spec_required if any of the four
+            // spec fields is missing. The model re-calls once it has the
+            // answers (or the user said "默认/随便" → pass defaults).
+            const specHasCup = ['small', 'medium', 'large'].includes(args.cup_size);
+            const specHasSugar = ['none', 'less', 'standard'].includes(args.sugar_level);
+            const specHasTemp = args.temperature === 'hot' || args.temperature === 'iced';
+            const specHasMilk = typeof args.with_milk === 'boolean';
+            if (!specHasCup || !specHasSugar || !specHasTemp || !specHasMilk) {
+                const missing = [];
+                if (!specHasCup)
+                    missing.push('cup_size (杯型: 小杯/中杯/大杯)');
+                if (!specHasSugar)
+                    missing.push('sugar_level (糖度: 无糖/少糖/标准糖)');
+                if (!specHasMilk)
+                    missing.push('with_milk (要奶/不要奶)');
+                if (!specHasTemp)
+                    missing.push('temperature (冷热: 热/冰)');
+                return {
+                    error: 'spec_required',
+                    product_id: resolved.id,
+                    product_name: resolved.name,
+                    quantity,
+                    missing,
+                    hint: `MUST ask the user for the drink spec before ordering — do NOT order with silent defaults. In ONE short message ask for: 杯型 (小杯 −¥3 / 中杯 / 大杯 +¥6)、糖度 (无糖/少糖/标准糖)、要不要加奶、冷的还是热的. Once the user answers — or says "默认/随便" — call order_coffee AGAIN for ${quantity}× ${resolved.name} with cup_size, sugar_level, with_milk, temperature ALL set. Still missing: ${missing.join(', ')}.`,
+                };
+            }
+            // Catalog prices are CNY. The VCC settles in USD, so derive a
+            // rough USD estimate for the VCC-balance heuristic below. Fetch
+            // the live rate from /options; fall back to 7.2 if unavailable.
+            let cnyPerUsd = 7.2;
+            try {
+                const opts = unwrap(await client.get('/api/cotti/options'));
+                const r = Number(opts?.currency?.cny_per_usd);
+                if (Number.isFinite(r) && r > 0)
+                    cnyPerUsd = r;
+            }
+            catch { /* keep fallback */ }
+            const estimatedTotalCny = +(resolved.price * quantity).toFixed(2);
+            const estimatedTotalUsd = +(estimatedTotalCny / cnyPerUsd).toFixed(2);
+            // Fulfillment. Default delivery; self_pickup needs a store id.
+            const fulfillmentType = args.fulfillment_type === 'self_pickup' ? 'self_pickup' : 'delivery';
+            const pickupStoreId = typeof args.pickup_store_id === 'string' && args.pickup_store_id.trim()
+                ? args.pickup_store_id.trim()
+                : undefined;
+            if (fulfillmentType === 'self_pickup' && !pickupStoreId) {
+                return {
+                    error: 'pickup_store_required',
+                    hint: 'fulfillment_type="self_pickup" needs pickup_store_id. Call list_coffees, show the user the pickup_stores list, and pass the chosen store id.',
+                };
+            }
+            // Drink customization — backend applies defaults + size pricing.
+            const cupSize = ['small', 'medium', 'large'].includes(args.cup_size)
+                ? args.cup_size : 'medium';
+            const sugarLevel = ['none', 'less', 'standard'].includes(args.sugar_level)
+                ? args.sugar_level : 'standard';
+            const temperature = args.temperature === 'iced' ? 'iced' : 'hot';
+            const withMilk = args.with_milk !== false;
+            // Resolve VCC with merchant_lock + balance constraints (Spark bug A).
+            // VCC balances are USD — use the USD estimate, not the CNY total.
+            const vccId = (typeof args.vcc_id === 'string' && args.vcc_id) ||
+                (await resolveDefaultVcc({ merchantLock: 'cotti', minBalance: estimatedTotalUsd }));
+            if (!vccId) {
+                return {
+                    error: 'no_vcc',
+                    hint: `No suitable install-stamped VCC found with merchant_lock allowing Cotti Coffee and balance ≥ $${estimatedTotalUsd} (¥${estimatedTotalCny} converted). Run create_vcc(merchant_lock="any") + top_up_vcc(${estimatedTotalUsd}).`,
+                };
+            }
+            try {
+                const result = unwrap(await client.post('/api/cotti/checkout', {
+                    product_id: resolved.id,
+                    quantity,
+                    delivery_address: (typeof args.delivery_address === 'string' && args.delivery_address.trim()) ||
+                        '上海市黄浦区南京东路1号 · 国金中心商场 35F · Spark',
+                    customer_name: (typeof args.customer_name === 'string' && args.customer_name.trim()) ||
+                        'Spark',
+                    vcc_id: vccId,
+                    agent_id: stampAgent('coffee'),
+                    caller_agent_id: callerAgentId(),
+                    fulfillment_type: fulfillmentType,
+                    ...(pickupStoreId ? { pickup_store_id: pickupStoreId } : {}),
+                    cup_size: cupSize,
+                    sugar_level: sugarLevel,
+                    with_milk: withMilk,
+                    temperature: temperature,
+                }));
+                // Approval gate fired — surface the URL to the LLM.
+                if (result?.status === 'pending_approval') {
+                    return {
+                        status: 'pending_approval',
+                        approval_id: result.approval_id,
+                        approval_url: result.approval_url,
+                        amount_cny: result.amount_cny,
+                        amount_usd: result.amount_usd,
+                        exchange_rate: result.exchange_rate,
+                        threshold_usd: result.threshold_usd,
+                        expires_at: result.expires_at,
+                        hint: result.hint ?? `Coffee order requires human approval. Open ${result.approval_url}, decide, then re-run order_coffee with approval_id="${result.approval_id}".`,
+                    };
+                }
+                const out = stripIframe({
+                    order_id: result.id,
+                    product_id: resolved.id,
+                    product_name: resolved.name,
+                    quantity,
+                    // Menu is CNY; VCC charged the USD conversion. Surface both.
+                    total_amount_cny: result.total_amount_cny ?? estimatedTotalCny,
+                    total_amount_usd: result.total_amount_usd ?? estimatedTotalUsd,
+                    exchange_rate: result.exchange_rate ?? cnyPerUsd,
+                    menu_currency: 'CNY',
+                    charge_currency: 'USD',
+                    status: result.status,
+                    payment_id: result.payment_id,
+                    cup_size: result.cup_size ?? cupSize,
+                    sugar_level: result.sugar_level ?? sugarLevel,
+                    with_milk: result.with_milk ?? withMilk,
+                    temperature: result.temperature ?? temperature,
+                    fulfillment_type: result.fulfillment_type ?? fulfillmentType,
+                    pickup_store_id: result.pickup_store_id ?? null,
+                    pickup_store_name: result.pickup_store_name ?? null,
+                    pickup_store_address: result.pickup_store_address ?? null,
+                    delivery_address: result.delivery_address,
+                    vcc_id: vccId,
+                    vcc_last_four: result.vcc_last_four,
+                    view_url: result.id ? `https://cotti.curless.ai/order/${result.id}` : undefined,
+                    // order_coffee embeds the order-page screenshot by default —
+                    // pass inline_screenshot=false to opt out.
+                    _inline_screenshot: args.inline_screenshot !== false,
+                });
+                return out;
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    // ─── HOTEL (Club Med) ─────────────────────────────────────────────────
+    {
+        name: 'list_properties',
+        description: 'Return all Club Med properties available for booking (10 worldwide).',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            try {
+                const data = unwrap(await client.get('/api/clubmed/properties'));
+                const props = Array.isArray(data) ? data : (data?.properties ?? data?.items ?? []);
+                return { items: props };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'list_rooms',
+        description: 'List room types available at a specific Club Med property.',
+        inputSchema: {
+            type: 'object',
+            required: ['property'],
+            properties: {
+                property: {
+                    type: 'string',
+                    description: 'Property id ("bali", "phuket", "maldives", "cancun", "punta-cana", "mauritius", "seychelles", "val-thorens", "sahoro", "turkoise") or full/Chinese name.',
+                },
+            },
+        },
+        handler: async (args) => {
+            const property = String(args.property || '').trim();
+            if (!property)
+                return { error: 'no_property' };
+            try {
+                // Backend response shape is { property: {...}, room_types: [...] }
+                // — earlier code read flat fields (data.id, data.rooms) which is why
+                // every property looked empty regardless of how many rooms it had.
+                // Bug from 2026-05-11 report: list_rooms(mauritius) → rooms: [].
+                const data = unwrap(await client.get(`/api/clubmed/properties/${encodeURIComponent(property)}`));
+                const prop = data?.property ?? {};
+                const rooms = (data?.room_types ?? []);
+                state.lastClubmedProperty = prop.id ?? property;
+                return {
+                    property_id: prop.id ?? property,
+                    property_name: prop.name,
+                    city: prop.city,
+                    country: prop.country,
+                    rooms: rooms.map((r) => ({
+                        room_id: r.id,
+                        name: r.name,
+                        description: r.description,
+                        max_guests: r.max_guests,
+                        price_per_night_usd: r.price_per_night,
+                        features: r.features,
+                    })),
+                    // Fallback convention so agents have a predictable id even
+                    // when this list is empty (which it shouldn't be after this
+                    // fix, but defense-in-depth):
+                    fallback_standard_room_id: `${prop.id ?? property}-standard`,
+                };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'book_room',
+        description: '[curless-mcp-server v0.1.9] Book a Club Med room. If room_id is omitted, picks the property\'s standard room. Charges the active VCC. VCC RESOLUTION: if `vcc_id` is omitted, the server tries the session\'s last-created VCC first; if none (fresh MCP session), it falls back to the most recent install-stamped active VCC whose merchant_lock allows Club Med. APPROVAL GATE: bookings whose total ≥ approval threshold (default $3000) DO NOT charge immediately. Instead the tool returns `{status: "pending_approval", approval_id, approval_url}`. Surface the URL to the user, wait for them to approve via the page, then RETRY this exact tool call with `approval_id` set — the server replays the originally-approved booking. SCREENSHOT: book_room embeds an inline screenshot of the booking confirmation page BY DEFAULT — the user wants to see the booking page. Pass inline_screenshot=false only if they ask to skip it.',
+        inputSchema: {
+            type: 'object',
+            required: ['property', 'check_in', 'check_out'],
+            properties: {
+                property: { type: 'string', description: 'Property id, full name, or Chinese name.' },
+                check_in: { type: 'string', description: 'ISO date YYYY-MM-DD.' },
+                check_out: { type: 'string', description: 'ISO date YYYY-MM-DD.' },
+                room_id: { type: 'string', description: 'Optional — defaults to property standard room.' },
+                guests: { type: 'integer', minimum: 1, maximum: 4, default: 2 },
+                guest_name: { type: 'string', description: 'Defaults to "Spark".' },
+                vcc_id: { type: 'string', description: 'Optional. Defaults to (1) session\'s last-created VCC, then (2) most recent install-stamped active VCC with clubmed-compatible merchant_lock.' },
+                approval_id: { type: 'string', description: 'When retrying a booking that was previously gated for human approval, pass the approval_id returned by the first call. The server replays the originally-approved booking — other args are ignored on replay to prevent tampering.' },
+                inline_screenshot: { type: 'boolean', description: 'Embed an inline screenshot of the booking confirmation page in the reply. DEFAULTS TO TRUE for book_room — the user wants to see the booking page. Pass false to skip it (faster, no ~3-5s screenshot fetch).' },
+                // auto_open removed 2026-05-13: booking page no longer
+                // auto-launches in the OS browser. Click the markdown link
+                // in the response instead.
+            },
+        },
+        handler: async (args) => {
+            // ── Replay branch: caller is retrying with approval_id ──────
+            // Don't re-resolve VCC / room / etc — the server has the
+            // originally-approved payload. We only need to forward the
+            // approval_id. Server replays the stored booking and returns
+            // the same shape as a fresh successful booking, OR an
+            // approval-state error (pending / rejected / expired).
+            const approvalId = typeof args.approval_id === 'string' ? args.approval_id.trim() : '';
+            if (approvalId) {
+                try {
+                    const result = unwrap(await client.post('/api/clubmed/checkout', { approval_id: approvalId }));
+                    // If the result still says pending_approval, surface it
+                    // verbatim so the LLM tells the user "still waiting".
+                    if (result?.status === 'pending_approval') {
+                        return {
+                            status: 'pending_approval',
+                            approval_id: result.approval_id,
+                            approval_url: result.approval_url,
+                            amount_usd: result.amount_usd,
+                            expires_at: result.expires_at,
+                            hint: result.hint ?? 'Approval still pending. Open the URL and decide before retrying.',
+                        };
+                    }
+                    return stripIframe({
+                        booking_id: result.booking_id ?? result.id,
+                        confirmation_code: result.confirmation_code,
+                        property_id: result.property_id,
+                        room_type_id: result.room_type_id,
+                        check_in: result.check_in,
+                        check_out: result.check_out,
+                        total_amount_usd: result.total_amount_usd,
+                        currency: 'USD',
+                        status: result.status,
+                        payment_id: result.payment_id,
+                        approval_id: approvalId,
+                        view_url: (result.booking_id ?? result.id) ? `https://clubmed.curless.ai/booking/${result.booking_id ?? result.id}` : undefined,
+                        // book_room embeds the booking-page screenshot by default —
+                        // pass inline_screenshot=false to opt out.
+                        _inline_screenshot: args.inline_screenshot !== false,
+                        _auto_open: args.auto_open === true,
+                    });
+                }
+                catch (e) {
+                    return toErrorResult(e);
+                }
+            }
+            // ── Fresh booking branch ────────────────────────────────────
+            const property = String(args.property || '').trim();
+            const checkIn = String(args.check_in || '').trim();
+            const checkOut = String(args.check_out || '').trim();
+            if (!property || !checkIn || !checkOut)
+                return { error: 'missing_fields' };
+            // Resolve VCC (Spark bug A). Hotels are large charges — we don't
+            // know the exact total here without an extra round-trip, so the
+            // balance check is omitted and we trust merchant-side balance
+            // validation. merchant_lock filter still applies.
+            const vccId = (typeof args.vcc_id === 'string' && args.vcc_id) ||
+                (await resolveDefaultVcc({ merchantLock: 'clubmed' }));
+            if (!vccId) {
+                return {
+                    error: 'no_vcc',
+                    hint: 'No suitable install-stamped VCC found with merchant_lock allowing clubmed. Run create_vcc(merchant_lock="any") + top_up_vcc.',
+                };
+            }
+            try {
+                const result = unwrap(await client.post('/api/clubmed/checkout', {
+                    property_id: property,
+                    room_id: typeof args.room_id === 'string' ? args.room_id : undefined,
+                    check_in: checkIn,
+                    check_out: checkOut,
+                    guests: Number(args.guests ?? 2),
+                    guest_name: (typeof args.guest_name === 'string' && args.guest_name.trim()) ||
+                        'Spark',
+                    vcc_id: vccId,
+                    agent_id: stampAgent('hotel'),
+                    caller_agent_id: callerAgentId(),
+                }));
+                // Approval gate fired — return the pending state to the LLM
+                // so it can show the URL to the human and stop.
+                if (result?.status === 'pending_approval') {
+                    return {
+                        status: 'pending_approval',
+                        approval_id: result.approval_id,
+                        approval_url: result.approval_url,
+                        amount_usd: result.amount_usd,
+                        threshold_usd: result.threshold_usd,
+                        expires_at: result.expires_at,
+                        hint: result.hint ?? `Booking requires human approval. Open ${result.approval_url}, decide, then re-run book_room with approval_id="${result.approval_id}" (other args are ignored on replay).`,
+                    };
+                }
+                return stripIframe({
+                    booking_id: result.booking_id ?? result.id,
+                    confirmation_code: result.confirmation_code,
+                    property_id: result.property_id,
+                    room_type_id: result.room_type_id,
+                    check_in: result.check_in,
+                    check_out: result.check_out,
+                    total_amount_usd: result.total_amount_usd,
+                    currency: 'USD',
+                    status: result.status,
+                    payment_id: result.payment_id,
+                    vcc_id: vccId,
+                    // Desktop client equivalent of the iframe nav — clickable URL
+                    // to the Club Med booking confirmation page.
+                    view_url: (result.booking_id ?? result.id) ? `https://clubmed.curless.ai/booking/${result.booking_id ?? result.id}` : undefined,
+                    // book_room embeds the booking-page screenshot by default —
+                    // pass inline_screenshot=false to opt out.
+                    _inline_screenshot: args.inline_screenshot !== false,
+                    _auto_open: args.auto_open === true,
+                });
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    // ─── OFFICE SUPPLIES (Procurement) ────────────────────────────────────
+    {
+        name: 'list_supplies',
+        description: 'Return the office-supplies catalog (A4 paper, toner cartridges, pens, …).',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            try {
+                const data = unwrap(await client.get('/api/procurement/products'));
+                return { items: data?.products ?? data };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'check_inventory',
+        description: 'Show current on-hand quantity for office supplies, with low-stock flags. Suggests items that would benefit from a reorder.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                item: { type: 'string', description: 'Optional — restrict to one item by id or name.' },
+            },
+        },
+        handler: async (args) => {
+            try {
+                const agentId = stampAgent('supply');
+                const [catalog, inv, rules] = await Promise.all([
+                    client.get('/api/procurement/products'),
+                    client.get('/api/procurement/inventory', { agent_id: agentId }),
+                    client.get('/api/procurement/reorder-rules', { agent_id: agentId }),
+                ]);
+                const products = (unwrap(catalog)?.products ?? catalog ?? []);
+                const inventory = (unwrap(inv)?.inventory ?? inv?.inventory ?? []);
+                const ruleList = (unwrap(rules)?.rules ?? rules?.rules ?? []);
+                const itemFilter = typeof args.item === 'string' ? args.item.trim().toLowerCase() : '';
+                const merged = products
+                    .filter((p) => !itemFilter
+                    || p.id.includes(itemFilter)
+                    || (p.name || '').toLowerCase().includes(itemFilter)
+                    || (p.name_en || '').toLowerCase().includes(itemFilter))
+                    .map((p) => {
+                    const inv = inventory.find((i) => i.item_id === p.id);
+                    const rule = ruleList.find((r) => r.item_id === p.id);
+                    const qty = Number(inv?.current_quantity ?? 0);
+                    const threshold = rule ? Number(rule.threshold) : null;
+                    const low = threshold != null && qty < threshold;
+                    return {
+                        item_id: p.id,
+                        name: p.name,
+                        name_en: p.name_en,
+                        current_quantity: qty,
+                        reorder_threshold: threshold,
+                        reorder_quantity: rule ? Number(rule.reorder_quantity) : null,
+                        low_stock: low,
+                        unit_price_usd: p.price,
+                    };
+                });
+                return {
+                    items: merged,
+                    low_stock_count: merged.filter((m) => m.low_stock).length,
+                };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'order_supplies',
+        description: '[curless-mcp-server v0.1.9] Place an office-supplies order. `item` accepts id, Chinese, or English name. If `scheduled_for` (ISO date) is given, the order is queued for later; otherwise it charges immediately and bumps inventory. APPROVAL GATE: orders ≥ approval threshold (default $200) return `{status: "pending_approval", approval_id, approval_url}` instead of charging. Surface the URL to the user; once they approve, retry with `approval_id` — server replays the stored payload. VCC RESOLUTION: if `vcc_id` is omitted, the server tries the session\'s last-created VCC first; if there isn\'t one (e.g. fresh MCP session), it falls back to the most recently-created active install-stamped VCC whose merchant_lock allows procurement AND whose balance covers the charge.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                item: { type: 'string' },
+                quantity: { type: 'integer', minimum: 1, maximum: 500, default: 1 },
+                scheduled_for: { type: 'string', description: 'Optional ISO date YYYY-MM-DD.' },
+                vcc_id: { type: 'string', description: 'Optional. Defaults to (1) this session\'s last-created VCC, then (2) the most recent install-stamped active VCC whose merchant_lock allows procurement and balance ≥ estimated charge.' },
+                approval_id: { type: 'string', description: 'Retry a previously gated supply order. Server replays the originally-approved payload — other args are ignored on replay.' },
+                inline_screenshot: { type: 'boolean', description: 'Embed an inline screenshot of the order confirmation page in the reply. DEFAULTS TO TRUE — the user wants to see the order page. Pass false to skip it (faster, no ~3-5s screenshot fetch).' },
+                // auto_open removed 2026-05-13: storefront page no longer
+                // auto-launches in the OS browser. Click the markdown link in
+                // the response instead.
+            },
+        },
+        handler: async (args) => {
+            // ── Replay branch ───────────────────────────────────────────
+            const approvalId = typeof args.approval_id === 'string' ? args.approval_id.trim() : '';
+            if (approvalId) {
+                try {
+                    const result = unwrap(await client.post('/api/procurement/checkout', { approval_id: approvalId }));
+                    if (result?.status === 'pending_approval') {
+                        return {
+                            status: 'pending_approval',
+                            approval_id: result.approval_id,
+                            approval_url: result.approval_url,
+                            amount_usd: result.amount_usd,
+                            expires_at: result.expires_at,
+                            hint: result.hint ?? 'Approval still pending. Open the URL and decide before retrying.',
+                        };
+                    }
+                    return stripIframe({
+                        order_id: result.id ?? result.order_id,
+                        item_id: result.item_id,
+                        item_name: result.item_name,
+                        quantity: result.quantity,
+                        unit_price_usd: result.unit_price_usd,
+                        total_amount_usd: result.total_amount_usd,
+                        currency: 'USD',
+                        status: result.status,
+                        payment_id: result.payment_id,
+                        vcc_last_four: result.vcc_last_four,
+                        approval_id: approvalId,
+                        view_url: (result.id ?? result.order_id) ? `https://procurement.curless.ai/order/${result.id ?? result.order_id}` : undefined,
+                        _inline_screenshot: args.inline_screenshot !== false,
+                        _auto_open: args.auto_open === true,
+                    });
+                }
+                catch (e) {
+                    return toErrorResult(e);
+                }
+            }
+            // ── Fresh branch ────────────────────────────────────────────
+            const item = String(args.item || '').trim();
+            if (!item)
+                return { error: 'no_item' };
+            const quantity = Math.max(1, Math.min(500, Number(args.quantity ?? 1)));
+            const scheduledFor = typeof args.scheduled_for === 'string' && args.scheduled_for.trim()
+                ? args.scheduled_for.trim()
+                : undefined;
+            // Resolve product first so we know the price → can resolve VCC
+            // by balance sufficiency (Spark bug A).
+            let products = [];
+            try {
+                const cat = unwrap(await client.get('/api/procurement/products'));
+                products = cat?.products ?? cat ?? [];
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+            const lower = item.toLowerCase();
+            let resolved = products.find((p) => p.id === item) ||
+                products.find((p) => p.name === item || (p.name_en || '').toLowerCase() === lower) ||
+                products.find((p) => p.name.includes(item) || (p.name_en || '').toLowerCase().includes(lower));
+            if (!resolved) {
+                return {
+                    error: 'product_not_found',
+                    hint: `Use one of: ${products.map((p) => p.id).join(', ')}`,
+                };
+            }
+            const estimatedTotal = +(resolved.price * quantity).toFixed(2);
+            // Resolve VCC: explicit → session memory → smart fallback.
+            let vccId = (typeof args.vcc_id === 'string' && args.vcc_id) ||
+                (scheduledFor ? null : await resolveDefaultVcc({ merchantLock: 'procurement', minBalance: estimatedTotal }));
+            if (!vccId && !scheduledFor) {
+                return {
+                    error: 'no_vcc',
+                    hint: `No suitable install-stamped VCC found with merchant_lock allowing procurement and balance ≥ $${estimatedTotal}. Run create_vcc(merchant_lock="any") + top_up_vcc(${estimatedTotal}), or pass scheduled_for for a deferred order.`,
+                };
+            }
+            try {
+                const result = unwrap(await client.post('/api/procurement/checkout', {
+                    item_id: resolved.id,
+                    quantity,
+                    vcc_id: vccId,
+                    // Inventory scope stays as the shared 'agent-004' bucket so
+                    // MCP and web UI see the same on-hand counts.
+                    agent_id: stampAgent('supply'),
+                    // Audit identity is the actual MCP caller — Spark bug #1.
+                    caller_agent_id: callerAgentId(),
+                    scheduled_for: scheduledFor,
+                }));
+                // Approval gate fired — surface the URL to the LLM.
+                if (result?.status === 'pending_approval') {
+                    return {
+                        status: 'pending_approval',
+                        approval_id: result.approval_id,
+                        approval_url: result.approval_url,
+                        amount_usd: result.amount_usd,
+                        threshold_usd: result.threshold_usd,
+                        expires_at: result.expires_at,
+                        hint: result.hint ?? `Supply order requires human approval. Open ${result.approval_url}, decide, then re-run order_supplies with approval_id="${result.approval_id}".`,
+                    };
+                }
+                return stripIframe({
+                    order_id: result.id,
+                    item_id: resolved.id,
+                    item_name: resolved.name,
+                    quantity,
+                    unit_price_usd: resolved.price,
+                    total_amount_usd: result.total_amount_usd ?? estimatedTotal,
+                    currency: 'USD',
+                    status: result.status,
+                    scheduled_for: result.scheduled_for,
+                    payment_id: result.payment_id,
+                    vcc_id: vccId,
+                    view_url: result.id ? `https://procurement.curless.ai/order/${result.id}` : undefined,
+                    // order_supplies embeds the order-page screenshot by default —
+                    // pass inline_screenshot=false to opt out.
+                    _inline_screenshot: args.inline_screenshot !== false,
+                    _auto_open: args.auto_open === true,
+                });
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'set_reorder_rule',
+        description: 'Configure auto-reorder for an item: when on-hand drops below `threshold`, automatically place an order of `reorder_quantity` units. The rule runs server-side on every inventory change.',
+        inputSchema: {
+            type: 'object',
+            required: ['item', 'threshold', 'reorder_quantity'],
+            properties: {
+                item: { type: 'string' },
+                threshold: { type: 'integer', minimum: 0, maximum: 100000 },
+                reorder_quantity: { type: 'integer', minimum: 1, maximum: 500 },
+            },
+        },
+        handler: async (args) => {
+            const item = String(args.item || '').trim();
+            const threshold = Math.max(0, Math.min(100000, Number(args.threshold)));
+            const reorderQty = Math.max(1, Math.min(500, Number(args.reorder_quantity)));
+            if (!item)
+                return { error: 'no_item' };
+            // Resolve product
+            let products = [];
+            try {
+                const cat = unwrap(await client.get('/api/procurement/products'));
+                products = cat?.products ?? cat ?? [];
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+            const lower = item.toLowerCase();
+            let resolved = products.find((p) => p.id === item) ||
+                products.find((p) => p.name === item || (p.name_en || '').toLowerCase() === lower) ||
+                products.find((p) => p.name.includes(item) || (p.name_en || '').toLowerCase().includes(lower));
+            if (!resolved) {
+                return { error: 'product_not_found', hint: `Use one of: ${products.map((p) => p.id).join(', ')}` };
+            }
+            try {
+                const rule = unwrap(await client.post('/api/procurement/reorder-rules', {
+                    item_id: resolved.id,
+                    agent_id: stampAgent('supply'),
+                    threshold,
+                    reorder_quantity: reorderQty,
+                }));
+                return {
+                    rule_id: rule?.id,
+                    item_id: resolved.id,
+                    item_name: resolved.name,
+                    threshold,
+                    reorder_quantity: reorderQty,
+                    status: 'active',
+                };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'consume_supplies',
+        description: 'Consume / use up office-supplies inventory — decrements on-hand stock by `quantity`. Use when the user reports USING supplies ("用掉了 20 包 A4 纸", "消耗了 3 支硒鼓", "deduct 5 folders"). Inverse of order_supplies. AUTO-REORDER IS ATOMIC: if the consumption drops on-hand below an item\'s reorder-rule threshold (set via set_reorder_rule), the backend resolves a VCC + charges it IMMEDIATELY + replenishes the shelf ONLY on payment success. reorder_triggered=true means a real charge landed (reorder_payment.payment_id non-null, order status=paid). reorder_triggered=false with reorder_skip_reason names the precise blocker — \'no_rule\' (suggest set_reorder_rule), \'rule_disabled\', \'above_threshold\' (working as intended), \'no_charger_available\' (config bug), \'auto_reorder_charge_failed\' (consume succeeded but reorder charge failed — reorder_charge_error has the underlying code: VCC_INSUFFICIENT → top up, NO_VCC_FOR_REORDER → create / top-up a procurement-locked card, VCC_MERCHANT_LOCKED → wrong card lock). `item` accepts id / Chinese / English / fuzzy keyword. `vcc_id` is optional — when omitted the backend auto-picks an active procurement-compatible VCC with enough balance.',
+        inputSchema: {
+            type: 'object',
+            required: ['item', 'quantity'],
+            properties: {
+                item: { type: 'string', description: 'Item id, Chinese name, English name, or keyword.' },
+                quantity: { type: 'integer', minimum: 1, maximum: 100000, description: 'How many units were consumed.' },
+                vcc_id: { type: 'string', description: 'Optional. VCC to charge if a reorder fires. Defaults to an auto-picked procurement-compatible VCC with enough balance.' },
+            },
+        },
+        handler: async (args) => {
+            const item = String(args.item || '').trim();
+            const quantity = Math.max(1, Math.min(100000, Math.floor(Number(args.quantity ?? 0))));
+            const vccId = typeof args.vcc_id === 'string' && args.vcc_id.trim() ? args.vcc_id.trim() : undefined;
+            if (!item)
+                return { error: 'no_item' };
+            if (!Number.isFinite(quantity) || quantity < 1) {
+                return { error: 'bad_quantity', hint: 'quantity must be a positive integer.' };
+            }
+            try {
+                const result = unwrap(await client.post('/api/procurement/consume', {
+                    item,
+                    quantity,
+                    agent_id: stampAgent('supply'),
+                    caller_agent_id: callerAgentId(),
+                    ...(vccId ? { vcc_id: vccId } : {}),
+                }));
+                return {
+                    item_id: result.item_id,
+                    item_name: result.item_name,
+                    unit: result.unit,
+                    consumed: result.consumed,
+                    previous_quantity: result.previous_quantity,
+                    quantity_after_consume: result.quantity_after_consume,
+                    current_quantity: result.current_quantity,
+                    // Auto-reorder outcome — ATOMIC. reorder_triggered=true ONLY
+                    // when a real charge landed (reorder_payment populated, order
+                    // status='paid', shelf replenished). Otherwise
+                    // reorder_skip_reason + reorder_charge_error name the
+                    // precise blocker so the agent can guide recovery.
+                    reorder_triggered: result.reorder_triggered,
+                    reorder_rule: result.reorder_rule,
+                    reorder_skip_reason: result.reorder_skip_reason,
+                    reorder_order: result.reorder_order,
+                    reorder_payment: result.reorder_payment,
+                    reorder_charge_error: result.reorder_charge_error,
+                };
+            }
+            catch (e) {
+                return toErrorResult(e, 'Consume failed — call list_supplies to confirm the item, or check_inventory for current stock.');
+            }
+        },
+    },
+    {
+        name: 'list_supply_orders',
+        description: 'Return recent office-supplies orders (paid, scheduled, failed).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'integer', minimum: 1, maximum: 50, default: 10 },
+            },
+        },
+        handler: async (args) => {
+            const limit = Math.max(1, Math.min(50, Number(args.limit ?? 10)));
+            try {
+                const data = unwrap(await client.get('/api/procurement/orders', {
+                    agent_id: stampAgent('supply'),
+                    limit,
+                }));
+                return { orders: data?.orders ?? data };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    // ─── TRANSACTIONS ─────────────────────────────────────────────────────
+    {
+        name: 'list_transactions',
+        description: 'Recent merchant payments (across all merchants). Useful for receipts / debugging.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'integer', minimum: 1, maximum: 50, default: 10 },
+            },
+        },
+        handler: async (args) => {
+            const limit = Math.max(1, Math.min(50, Number(args.limit ?? 10)));
+            try {
+                const data = unwrap(await client.get('/v1/merchant/payments', { limit, fresh: '1' }));
+                return { items: data?.items ?? data };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    // ─── CAROUSELL (二手商品 / APass / ATOKEN) ────────────────────────────
+    //
+    // New scenario — wallet-identified (chain + address) rather than
+    // agent-id gated. Buyer + seller wallets are passed explicitly; if
+    // omitted we fall back to CAROUSELL_DEFAULT_CHAIN + CAROUSELL_WALLET
+    // env vars on the MCP host.
+    {
+        name: 'list_carousell_listings',
+        description: '[curless-mcp-server v0.1.10] Browse second-hand goods on carousell.curless.ai. All prices in USDC. Filter by query (matches title + description), category (electronics / fashion / home / sports / other), condition (new / like_new / good / fair), max_price_usdc, min_price_usdc. Always call this BEFORE buy_carousell_listing — the user almost always wants to compare options.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+                category: { type: 'string' },
+                condition: { type: 'string', enum: ['new', 'like_new', 'good', 'fair'] },
+                min_price_usdc: { type: 'number', minimum: 0 },
+                max_price_usdc: { type: 'number', minimum: 0 },
+                limit: { type: 'integer', minimum: 1, maximum: 50, default: 12 },
+            },
+        },
+        handler: async (args) => {
+            const params = {};
+            for (const k of ['query', 'category', 'condition']) {
+                const v = args[k];
+                if (typeof v === 'string' && v.trim())
+                    params[k] = v.trim();
+            }
+            for (const k of ['min_price_usdc', 'max_price_usdc']) {
+                const v = args[k];
+                if (typeof v === 'number' && Number.isFinite(v))
+                    params[k] = v;
+            }
+            params.limit = Math.max(1, Math.min(50, Number(args.limit ?? 12)));
+            try {
+                const data = unwrap(await client.get('/api/carousell/listings', params));
+                return {
+                    listings: (data.listings ?? []).map((l) => ({
+                        id: l.id, title: l.title, price_usdc: l.price_usdc, category: l.category,
+                        condition: l.condition, image_url: l.image_url, location: l.location,
+                        seller_chain: l.seller_chain, seller_address: l.seller_address,
+                        view_url: `https://carousell.curless.ai/listing/${l.id}`,
+                    })),
+                };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'get_carousell_listing',
+        description: '[curless-mcp-server v0.1.10] Get a single Carousell listing\'s full detail. Use after list_carousell_listings when the user picks one and you need title/description/price before calling buy.',
+        inputSchema: {
+            type: 'object',
+            required: ['listing_id'],
+            properties: { listing_id: { type: 'string', description: 'CL-... id' } },
+        },
+        handler: async (args) => {
+            const id = String(args.listing_id || '').trim();
+            if (!id)
+                return { error: 'missing_listing_id' };
+            try {
+                const data = unwrap(await client.get(`/api/carousell/listings/${encodeURIComponent(id)}`));
+                return { ...data, view_url: `https://carousell.curless.ai/listing/${data.id}` };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'post_carousell_listing',
+        description: '[curless-mcp-server v0.1.10] Publish a second-hand item for sale on carousell.curless.ai. Price in USDC. Requires the seller wallet to have a Cleanverse APass — if missing returns `{status: "needs_apass", magiclink_url}` (NOT an error: surface URL, ask user to register, then retry). image_url is REQUIRED (suggest unsplash.com to users who have no photo). On success returns the listing + view_url.',
+        inputSchema: {
+            type: 'object',
+            required: ['title', 'description', 'price_usdc', 'category', 'condition', 'image_url'],
+            properties: {
+                title: { type: 'string', maxLength: 200 },
+                description: { type: 'string', maxLength: 4000 },
+                price_usdc: { type: 'number', minimum: 0.01, maximum: 100000 },
+                category: { type: 'string', description: 'electronics | fashion | home | sports | other' },
+                condition: { type: 'string', enum: ['new', 'like_new', 'good', 'fair'] },
+                image_url: { type: 'string', description: 'Public image URL.' },
+                location: { type: 'string' },
+                chain: { type: 'string', description: `Seller wallet chain. Defaults to env CAROUSELL_DEFAULT_CHAIN (${process.env.CAROUSELL_DEFAULT_CHAIN || 'base'}).` },
+                address: { type: 'string', description: 'Seller wallet address. Defaults to env CAROUSELL_WALLET_ADDRESS.' },
+            },
+        },
+        handler: async (args) => {
+            const chain = (typeof args.chain === 'string' && args.chain.trim()) || process.env.CAROUSELL_DEFAULT_CHAIN || 'base';
+            const address = (typeof args.address === 'string' && args.address.trim()) || process.env.CAROUSELL_WALLET_ADDRESS;
+            if (!address) {
+                return {
+                    error: 'wallet_required',
+                    hint: 'Ask the user for their on-chain wallet address (e.g. "What\'s your Base/Solana wallet address?"), or set CAROUSELL_WALLET_ADDRESS in this MCP install\'s env.',
+                };
+            }
+            try {
+                const data = unwrap(await client.post('/api/carousell/listings', {
+                    seller_chain: chain, seller_address: address,
+                    title: args.title, description: args.description,
+                    price_usdc: Number(args.price_usdc),
+                    category: String(args.category || '').toLowerCase().trim(),
+                    condition: args.condition, image_url: args.image_url,
+                    location: args.location, caller_agent_id: callerAgentId(),
+                }));
+                if (data?.status === 'needs_apass') {
+                    return {
+                        status: 'needs_apass', magiclink_url: data.magiclink_url, expires_at: data.expires_at,
+                        hint: 'Seller wallet needs a Cleanverse APass first. Surface magiclink_url, ask user to register, then retry this tool with the same args.',
+                    };
+                }
+                return {
+                    listing_id: data.id, title: data.title, price_usdc: data.price_usdc, status: data.status,
+                    view_url: `https://carousell.curless.ai/listing/${data.id}`,
+                };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'buy_carousell_listing',
+        description: '[curless-mcp-server v0.1.10] Buy a Carousell listing with atoken (1:1 USDC settlement). THREE pre-settlement gates: (1) needs_apass — surface magiclink_url, register, retry. (2) pending_approval (≥ $200) — surface approval_url, ask user to approve, retry with same approval_id. (3) insufficient_atoken_balance — top up buyer wallet. On success returns settled order + atoken_tx_hash + view_url. Listing auto-marks sold; duplicate buy attempts return error="listing_unavailable".',
+        inputSchema: {
+            type: 'object',
+            required: ['listing_id'],
+            properties: {
+                listing_id: { type: 'string' },
+                chain: { type: 'string', description: 'Buyer wallet chain (defaults to env CAROUSELL_DEFAULT_CHAIN).' },
+                address: { type: 'string', description: 'Buyer wallet address (defaults to env CAROUSELL_WALLET_ADDRESS).' },
+                approval_id: { type: 'string', description: 'Pass to retry a previously-gated buy after human approval.' },
+            },
+        },
+        handler: async (args) => {
+            const id = String(args.listing_id || '').trim();
+            if (!id)
+                return { error: 'missing_listing_id' };
+            const chain = (typeof args.chain === 'string' && args.chain.trim()) || process.env.CAROUSELL_DEFAULT_CHAIN || 'base';
+            const address = (typeof args.address === 'string' && args.address.trim()) || process.env.CAROUSELL_WALLET_ADDRESS;
+            if (!address) {
+                return { error: 'wallet_required', hint: 'Set CAROUSELL_WALLET_ADDRESS env or pass `address` arg.' };
+            }
+            try {
+                const data = unwrap(await client.post('/api/carousell/buy', {
+                    listing_id: id, buyer_chain: chain, buyer_address: address,
+                    caller_agent_id: callerAgentId(),
+                    ...(args.approval_id ? { approval_id: String(args.approval_id) } : {}),
+                }));
+                if (data?.status === 'needs_apass') {
+                    return { status: 'needs_apass', magiclink_url: data.magiclink_url, expires_at: data.expires_at };
+                }
+                if (data?.status === 'pending_approval') {
+                    return {
+                        status: 'pending_approval', approval_id: data.approval_id,
+                        approval_url: data.approval_url, amount_usd: data.amount_usd,
+                        threshold_usd: data.threshold_usd, hint: data.hint,
+                    };
+                }
+                return {
+                    order_id: data.id, listing_id: data.listing_id, price_usdc: data.price_usdc,
+                    atoken_tx_hash: data.atoken_tx_hash, status: data.status,
+                    view_url: `https://carousell.curless.ai/order/${data.id}`,
+                };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'list_my_carousell_orders',
+        description: '[curless-mcp-server v0.1.10] My Carousell orders. role="buyer" (default) for purchases, role="seller" for sales.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                role: { type: 'string', enum: ['buyer', 'seller'], default: 'buyer' },
+                chain: { type: 'string' },
+                address: { type: 'string' },
+                status: { type: 'string', enum: ['pending_atoken', 'settled', 'failed', 'refunded', 'any'] },
+                limit: { type: 'integer', minimum: 1, maximum: 100, default: 20 },
+            },
+        },
+        handler: async (args) => {
+            const chain = (typeof args.chain === 'string' && args.chain.trim()) || process.env.CAROUSELL_DEFAULT_CHAIN || 'base';
+            const address = (typeof args.address === 'string' && args.address.trim()) || process.env.CAROUSELL_WALLET_ADDRESS;
+            if (!address)
+                return { error: 'wallet_required', hint: 'Set CAROUSELL_WALLET_ADDRESS env or pass address.' };
+            const role = (args.role === 'seller') ? 'seller' : 'buyer';
+            const params = role === 'buyer'
+                ? { buyer_chain: chain, buyer_address: address }
+                : { seller_chain: chain, seller_address: address };
+            if (typeof args.status === 'string')
+                params.status = args.status;
+            params.limit = Math.max(1, Math.min(100, Number(args.limit ?? 20)));
+            try {
+                const data = unwrap(await client.get('/api/carousell/orders', params));
+                return { role, orders: data.orders ?? [] };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'get_apass_status',
+        description: '[curless-mcp-server v0.1.10] Check whether a wallet has an active Cleanverse APass. Returns `{registered, reason?, apass_address?, expiration_time?}`. Use BEFORE calling register_apass to avoid double-registering.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                chain: { type: 'string' },
+                address: { type: 'string' },
+            },
+        },
+        handler: async (args) => {
+            const chain = (typeof args.chain === 'string' && args.chain.trim()) || process.env.CAROUSELL_DEFAULT_CHAIN || 'base';
+            const address = (typeof args.address === 'string' && args.address.trim()) || process.env.CAROUSELL_WALLET_ADDRESS;
+            if (!address)
+                return { error: 'wallet_required', hint: 'Set CAROUSELL_WALLET_ADDRESS env or pass address.' };
+            try {
+                const data = unwrap(await client.get('/api/apass/status', { chain, address }));
+                return { chain, address, ...data };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+    {
+        name: 'register_apass',
+        description: '[curless-mcp-server v0.1.10] Start a Cleanverse APass registration for a wallet. Returns `{magiclink_url, state_nonce, expires_at}`. Share the magiclink_url with the user — they click it to register. After they confirm, retry whichever Carousell action triggered the apass gate.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                chain: { type: 'string' },
+                address: { type: 'string' },
+                purpose: { type: 'string', enum: ['list', 'buy', 'direct'], default: 'direct' },
+            },
+        },
+        handler: async (args) => {
+            const chain = (typeof args.chain === 'string' && args.chain.trim()) || process.env.CAROUSELL_DEFAULT_CHAIN || 'base';
+            const address = (typeof args.address === 'string' && args.address.trim()) || process.env.CAROUSELL_WALLET_ADDRESS;
+            if (!address)
+                return { error: 'wallet_required', hint: 'Set CAROUSELL_WALLET_ADDRESS env or pass address.' };
+            try {
+                const data = unwrap(await client.post('/api/apass/start', {
+                    chain, address,
+                    purpose: ['list', 'buy', 'direct'].includes(String(args.purpose)) ? args.purpose : 'direct',
+                }));
+                return {
+                    chain, address,
+                    state_nonce: data.state_nonce, magiclink_url: data.magiclink_url, expires_at: data.expires_at,
+                };
+            }
+            catch (e) {
+                return toErrorResult(e);
+            }
+        },
+    },
+];
+// ─────────────────────────────────────────────────────────────────────────
+// MCP Server wiring
+// ─────────────────────────────────────────────────────────────────────────
+const server = new Server({ name: 'curless-mcp-server', version: '0.1.10' }, { capabilities: { tools: {} } });
+// Auto-open of the storefront confirmation page was disabled by
+// product decision (2026-05-13). Users found the surprise browser
+// jump after every successful order_coffee / book_room / order_supplies
+// disruptive — especially on macOS where it steals focus from Claude
+// Desktop. The view_url is still surfaced as a clickable markdown
+// link in the chat; users who want the page open can click it.
+// The env var CURLESS_AUTO_OPEN_URLS is now ignored.
+const AUTO_OPEN_URLS = false;
+// Opt-in: render an inline screenshot of the storefront confirmation
+// page right in the chat. Closest thing to "open the iframe in Claude
+// Desktop" — Claude Desktop has no embedded webview, but it DOES render
+// inline images (same path as the QR code). Free public service does
+// the screenshot, no API key needed. Adds ~3-5s to every order; keep
+// it off for low-latency demos.
+const INLINE_PAGE_SCREENSHOT = (process.env.CURLESS_INLINE_PAGE_SCREENSHOT || '').toLowerCase() === 'true' ||
+    process.env.CURLESS_INLINE_PAGE_SCREENSHOT === '1';
+/**
+ * Fetch a rendered screenshot of an arbitrary URL via a free public
+ * screenshot service and return it as an MCP image content block.
+ * The page is rendered with a real headless browser server-side so
+ * Vue SPAs (cotti/clubmed/procurement order pages) hydrate before the
+ * snapshot is taken. Returns null on failure — caller falls back to
+ * the markdown link.
+ */
+async function screenshotContentFromUrl(url) {
+    // image.thum.io: free, no auth, returns PNG. Use the 'wait' param so
+    // the SPA has time to hydrate and fetch its order detail.
+    const shotUrl = `https://image.thum.io/get/width/900/crop/1200/wait/3/png/${url}`;
+    return imageContentFromUrl(shotUrl);
+}
+async function openInBrowser(url) {
+    // Best-effort cross-platform launcher. Never throws into the caller;
+    // failure here just means the URL didn't open, which is fine — the
+    // user still has it as clickable text in the chat.
+    try {
+        const { exec } = await import('node:child_process');
+        const cmd = process.platform === 'darwin' ? `open "${url}"` :
+            process.platform === 'win32' ? `start "" "${url}"` :
+                `xdg-open "${url}"`;
+        exec(cmd, () => { });
+    }
+    catch {
+        /* swallow */
+    }
+}
+/**
+ * Fetch an external image (e.g. a generated QR code) and return it as a
+ * base64 string + mime, ready to embed in an MCP `image` content block.
+ * MCP clients that support inline images (Claude Desktop, Cursor) will
+ * render this directly in chat — no browser hop needed for QR scans.
+ * Returns null on any failure so the caller can fall back to a text URL.
+ */
+async function imageContentFromUrl(url) {
+    try {
+        const res = await fetch(url);
+        if (!res.ok)
+            return null;
+        const mime = res.headers.get('content-type') || 'image/png';
+        const buf = Buffer.from(await res.arrayBuffer());
+        return { type: 'image', data: buf.toString('base64'), mimeType: mime };
+    }
+    catch {
+        return null;
+    }
+}
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOLS.map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema,
+    })),
+}));
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const tool = TOOLS.find((t) => t.name === req.params.name);
+    if (!tool) {
+        return {
+            isError: true,
+            content: [{ type: 'text', text: `Unknown tool: ${req.params.name}` }],
+        };
+    }
+    const args = (req.params.arguments ?? {});
+    try {
+        const result = await tool.handler(args);
+        const isError = Boolean(result && typeof result === 'object' && result.error);
+        const resultObj = (result && typeof result === 'object'
+            ? result
+            : {});
+        // Pull per-call viewer overrides BEFORE serializing — these are
+        // internal control flags, not user-facing data. Spark bug D.
+        const inlineOverride = resultObj._inline_screenshot === true;
+        const wantsInline = INLINE_PAGE_SCREENSHOT || inlineOverride;
+        // Auto-open is permanently disabled (see AUTO_OPEN_URLS comment
+        // above). We still strip the legacy `_auto_open` flag from the
+        // payload so it doesn't leak through into the serialized result.
+        delete resultObj._inline_screenshot;
+        delete resultObj._auto_open;
+        const text = JSON.stringify(result, null, 2);
+        const content = [{ type: 'text', text }];
+        // 1. Inline QR image for fund_wallet etc. — bytes embedded so the
+        //    user sees the QR right in chat without leaving Claude Desktop.
+        const qrUrl = !isError ? resultObj.qr_url : undefined;
+        if (typeof qrUrl === 'string' && qrUrl) {
+            const img = await imageContentFromUrl(qrUrl);
+            if (img)
+                content.push(img);
+            content.push({
+                type: 'text',
+                text: `\n📥 **Scan with your wallet app** (USDC) → ${resultObj.deposit_address ?? '(see deposit_address above)'}`,
+            });
+        }
+        // 2. Surface view_url as a markdown link (post-order storefront page).
+        //    The link is clickable in the chat; we no longer auto-launch
+        //    the OS browser (see AUTO_OPEN_URLS comment above) — users
+        //    asked for that to stop because it stole focus on every order.
+        const viewUrl = !isError ? resultObj.view_url : undefined;
+        if (typeof viewUrl === 'string' && viewUrl) {
+            if (wantsInline) {
+                const shot = await screenshotContentFromUrl(viewUrl);
+                if (shot)
+                    content.push(shot);
+            }
+            const hint = wantsInline
+                ? ''
+                : '\n\n(pass `inline_screenshot=true` to embed a rendered page screenshot · or set env CURLESS_INLINE_PAGE_SCREENSHOT=true to default it on)';
+            content.push({
+                type: 'text',
+                text: `\n🔗 **Open in browser**: ${viewUrl}${hint}`,
+            });
+        }
+        return { isError, content };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return {
+            isError: true,
+            content: [{ type: 'text', text: `Tool ${tool.name} crashed: ${msg}` }],
+        };
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // stderr is the only safe place to print — stdout is reserved for MCP.
+    console.error(`[curless-mcp-server] Ready. Backend=${process.env.CURLESS_BASE_URL ?? 'https://openclaw.curless.ai'} · wallet=${DEFAULT_WALLET_ID}`);
+}
+main().catch((e) => {
+    console.error('[curless-mcp-server] Fatal:', e);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map