@decibelsystems/tools 2.0.1 → 2.1.0

package/dist/tools/deck.js

@@ -1,32 +1,28 @@
 /**
- * Deck Tools - MTG Buylist Price Database
+ * Deck Tools - MTG Card Database (Supabase)
  *
- * Tools for searching and browsing Magic: The Gathering card buylist prices
- * from multiple stores. Data stored in Render Postgres (deck-db).
+ * Card catalog, price history, and market movers for Magic: The Gathering.
+ * Data lives in the Core Supabase project (dqftcixhsvcjtyxsxoao).
  *
- * Env var: DECK_DATABASE_URL
+ * Env var: DECK_SUPABASE_KEY (service role or anon key — tables have public SELECT policies)
  */
-import pg from 'pg';
-const { Pool } = pg;
-// Lazy-init pool
-let pool = null;
-function getPool() {
-    if (!pool) {
-        const connectionString = process.env.DECK_DATABASE_URL;
-        if (!connectionString) {
-            throw new Error('DECK_DATABASE_URL environment variable not set');
-        }
-        pool = new Pool({
-            connectionString,
-            ssl: { rejectUnauthorized: false }, // Render requires SSL
-            max: 5,
-            idleTimeoutMillis: 30000,
+import { createClient } from '@supabase/supabase-js';
+const CORE_SUPABASE_URL = 'https://dqftcixhsvcjtyxsxoao.supabase.co';
+// Anon key for public read access (all deck tables have public SELECT RLS policies)
+const CORE_ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImRxZnRjaXhoc3ZjanR5eHN4b2FvIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjcyMTgzMTYsImV4cCI6MjA4Mjc5NDMxNn0.erZq0zJMF-tATX7b0mofGsajFUvcqlZE5PQ4qcggmGc';
+// Lazy-init client
+let client = null;
+function getClient() {
+    if (!client) {
+        const key = process.env.DECK_SUPABASE_KEY || CORE_ANON_KEY;
+        client = createClient(CORE_SUPABASE_URL, key, {
+            auth: { persistSession: false, autoRefreshToken: false },
         });
     }
-    return pool;
+    return client;
 }
 // =============================================================================
-// Helper
+// Helpers
 // =============================================================================
 function jsonResult(data, isError = false) {
     return {
@@ -34,15 +30,81 @@ function jsonResult(data, isError = false) {
         isError,
     };
 }
+/**
+ * Fallback to Scryfall API when a card isn't found in the local database.
+ * Returns results shaped like the Supabase cards table for consistency.
+ */
+async function scryfallSearch(name, setCode) {
+    let query = `name:${name}`;
+    if (setCode)
+        query += ` set:${setCode}`;
+    const url = `https://api.scryfall.com/cards/search?q=${encodeURIComponent(query)}&order=usd&dir=desc`;
+    const res = await fetch(url);
+    if (!res.ok)
+        return [];
+    const json = (await res.json());
+    if (!json.data?.length)
+        return [];
+    return json.data.slice(0, 50).map((card) => ({
+        name: card.name,
+        set_code: card.set,
+        set_name: card.set_name,
+        rarity: card.rarity,
+        price_usd: card.prices?.usd ?? null,
+        price_usd_foil: card.prices?.usd_foil ?? null,
+        legalities: card.legalities,
+        scryfall_id: card.id,
+        image_uri: card.image_uris?.normal ??
+            card.image_uris?.large ??
+            null,
+        type_line: card.type_line,
+        mana_cost: card.mana_cost,
+        source: 'scryfall',
+    }));
+}
+// =============================================================================
+// Validation Helpers
+// =============================================================================
+const VALID_FORMATS = [
+    'standard', 'modern', 'pioneer', 'commander', 'legacy', 'vintage',
+    'pauper', 'historic', 'explorer', 'brawl', 'alchemy', 'penny', 'oathbreaker',
+];
+const VALID_RARITIES = ['common', 'uncommon', 'rare', 'mythic'];
+function validateFormat(format) {
+    const f = format.toLowerCase();
+    if (!VALID_FORMATS.includes(f)) {
+        throw new Error(`Invalid format "${format}". Valid: ${VALID_FORMATS.join(', ')}`);
+    }
+    return f;
+}
+function validateRarity(rarity) {
+    const r = rarity.toLowerCase();
+    if (!VALID_RARITIES.includes(r)) {
+        throw new Error(`Invalid rarity "${rarity}". Valid: ${VALID_RARITIES.join(', ')}`);
+    }
+    return r;
+}
+/** Grade price stability from coefficient of variation */
+function gradeStability(cv) {
+    if (cv < 5)
+        return { grade: 'A', label: 'Very Stable' };
+    if (cv < 10)
+        return { grade: 'B', label: 'Stable' };
+    if (cv < 20)
+        return { grade: 'C', label: 'Moderate' };
+    if (cv < 35)
+        return { grade: 'D', label: 'Volatile' };
+    return { grade: 'F', label: 'Highly Volatile' };
+}
 // =============================================================================
 // Tool Specs
 // =============================================================================
-const deckBuylistSearch = {
+const deckSearch = {
     definition: {
-        name: 'deck_buylist_search',
-        description: 'Search MTG card buylist prices by card name. Returns prices from multiple stores.',
+        name: 'deck_search',
+        description: 'Search MTG cards by name. Returns card details with current prices.',
         annotations: {
-            title: 'Search Buylist',
+            title: 'Search Cards',
             readOnlyHint: true,
             destructiveHint: false,
             openWorldHint: true,
@@ -54,9 +116,9 @@ const deckBuylistSearch = {
                     type: 'string',
                     description: 'Card name to search for (partial match, case-insensitive)',
                 },
-                store: {
+                set_code: {
                     type: 'string',
-                    description: 'Optional: filter by specific store name',
+                    description: 'Optional: filter by set code (e.g. "MH3", "LCI")',
                 },
             },
             required: ['name'],
@@ -64,21 +126,34 @@ const deckBuylistSearch = {
     },
     handler: async (args) => {
         try {
-            const db = getPool();
-            const query = `
-        SELECT card_name, set_code, set_name, is_foil, nm_price, lp_price, mp_price, hp_price,
-               store, scryfall_id
-        FROM buylist_prices
-        WHERE card_name ILIKE '%' || $1 || '%'
-          AND ($2::text IS NULL OR store = $2)
-        ORDER BY nm_price DESC NULLS LAST
-        LIMIT 50
-      `;
-            const result = await db.query(query, [args.name, args.store || null]);
+            const db = getClient();
+            let query = db
+                .from('cards')
+                .select('name, set_code, set_name, rarity, price_usd, price_usd_foil, legalities, scryfall_id, image_uri, type_line, mana_cost')
+                .ilike('name', `%${args.name}%`)
+                .order('price_usd', { ascending: false, nullsFirst: false })
+                .limit(50);
+            if (args.set_code) {
+                query = query.eq('set_code', args.set_code.toLowerCase());
+            }
+            const { data, error } = await query;
+            if (error)
+                throw new Error(error.message);
+            // Fallback to Scryfall API when local DB returns no results
+            if (!data || data.length === 0) {
+                const fallback = await scryfallSearch(args.name, args.set_code);
+                return jsonResult({
+                    success: true,
+                    cards: fallback,
+                    count: fallback.length,
+                    source: fallback.length > 0 ? 'scryfall_fallback' : 'none',
+                });
+            }
             return jsonResult({
                 success: true,
-                cards: result.rows,
-                count: result.rows.length,
+                cards: data,
+                count: data.length,
+                source: 'database',
             });
         }
         catch (error) {
@@ -87,12 +162,12 @@ const deckBuylistSearch = {
         }
     },
 };
-const deckBuylistList = {
+const deckList = {
     definition: {
-        name: 'deck_buylist_list',
-        description: 'List top buylist prices for a specific store, ordered by NM price descending.',
+        name: 'deck_list',
+        description: 'List top price movers for a given period. Returns cards with the biggest price changes (gainers and losers).',
         annotations: {
-            title: 'List Store Buylist',
+            title: 'Top Movers',
             readOnlyHint: true,
             destructiveHint: false,
             openWorldHint: true,
@@ -100,34 +175,66 @@ const deckBuylistList = {
         inputSchema: {
             type: 'object',
             properties: {
-                store: {
+                period: {
                     type: 'string',
-                    description: 'Store name to list cards for',
+                    description: 'Time period for price changes (default: "7d"). E.g. "1d", "7d", "30d"',
                 },
                 limit: {
                     type: 'number',
-                    description: 'Max cards to return (default: 50)',
+                    description: 'Max results (default: 50)',
                 },
             },
-            required: ['store'],
+            required: [],
         },
     },
     handler: async (args) => {
         try {
-            const db = getPool();
+            const db = getClient();
+            const period = args.period || '7d';
             const limit = args.limit || 50;
-            const query = `
-        SELECT card_name, set_code, set_name, is_foil, nm_price, lp_price, store
-        FROM buylist_prices
-        WHERE store = $1
-        ORDER BY nm_price DESC NULLS LAST
-        LIMIT $2
-      `;
-            const result = await db.query(query, [args.store, limit]);
+            // Fetch movers — grab extra to cover abs() sorting
+            const { data: movers, error: moversErr } = await db
+                .from('price_movers')
+                .select('scryfall_id, period, price_from, price_to, change_pct, computed_at')
+                .eq('period', period)
+                .order('change_pct', { ascending: false })
+                .limit(limit * 2);
+            if (moversErr)
+                throw new Error(moversErr.message);
+            if (!movers || movers.length === 0) {
+                return jsonResult({ success: true, movers: [], count: 0, period });
+            }
+            // Sort by abs(change_pct), take top N
+            movers.sort((a, b) => Math.abs(b.change_pct) - Math.abs(a.change_pct));
+            const topMovers = movers.slice(0, limit);
+            // Batch-lookup card names
+            const ids = topMovers.map((m) => m.scryfall_id);
+            const { data: cards, error: cardsErr } = await db
+                .from('cards')
+                .select('scryfall_id, name, set_code')
+                .in('scryfall_id', ids);
+            if (cardsErr)
+                throw new Error(cardsErr.message);
+            const cardMap = new Map((cards || []).map((c) => [
+                c.scryfall_id,
+                c,
+            ]));
+            const results = topMovers.map((m) => {
+                const card = cardMap.get(m.scryfall_id);
+                return {
+                    name: card?.name || 'Unknown',
+                    set_code: card?.set_code || '',
+                    price_from: m.price_from,
+                    price_to: m.price_to,
+                    change_pct: m.change_pct,
+                    computed_at: m.computed_at,
+                };
+            });
             return jsonResult({
                 success: true,
-                cards: result.rows,
-                count: result.rows.length,
+                movers: results,
+                count: results.length,
+                period,
             });
         }
         catch (error) {
@@ -136,12 +243,12 @@ const deckBuylistList = {
         }
     },
 };
-const deckBuylistStores = {
+const deckSummary = {
     definition: {
-        name: 'deck_buylist_stores',
-        description: 'List all stores in the buylist database with card counts and last update time.',
+        name: 'deck_summary',
+        description: 'Get a summary of the card database: card count, price sources, last update time, available mover periods.',
         annotations: {
-            title: 'List Stores',
+            title: 'Data Summary',
             readOnlyHint: true,
             destructiveHint: false,
             openWorldHint: true,
@@ -154,20 +261,692 @@ const deckBuylistStores = {
     },
     handler: async () => {
         try {
-            const db = getPool();
-            const query = `
-        SELECT store, COUNT(*) as card_count, MAX(updated_at) as last_updated
-        FROM buylist_prices
-        GROUP BY store
-        ORDER BY card_count DESC
-      `;
-            const result = await db.query(query);
+            const db = getClient();
+            const [cardCount, sources, latestUpdate, periods] = await Promise.all([
+                db.from('cards').select('*', { count: 'exact', head: true }),
+                db.from('price_history').select('source').limit(1000),
+                db
+                    .from('cards')
+                    .select('price_updated_at')
+                    .order('price_updated_at', { ascending: false })
+                    .limit(1),
+                db.from('price_movers').select('period').limit(1000),
+            ]);
+            const distinctSources = [
+                ...new Set((sources.data || []).map((r) => r.source)),
+            ];
+            const distinctPeriods = [
+                ...new Set((periods.data || []).map((r) => r.period)),
+            ];
+            return jsonResult({
+                success: true,
+                summary: {
+                    card_count: cardCount.count || 0,
+                    price_sources: distinctSources,
+                    latest_price_update: latestUpdate.data?.[0]?.price_updated_at || null,
+                    available_periods: distinctPeriods,
+                },
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+const deckHistory = {
+    definition: {
+        name: 'deck_history',
+        description: 'Get price history for a specific card. Accepts scryfall_id or card name. Returns up to 90 days of price data.',
+        annotations: {
+            title: 'Price History',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                scryfall_id: {
+                    type: 'string',
+                    description: 'Scryfall UUID of the card',
+                },
+                name: {
+                    type: 'string',
+                    description: 'Card name (exact match preferred; used if scryfall_id not provided)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max rows (default: 90 — ~3 months)',
+                },
+            },
+            required: [],
+        },
+    },
+    handler: async (args) => {
+        try {
+            if (!args.scryfall_id && !args.name) {
+                return jsonResult({ success: false, error: 'Provide either scryfall_id or name' }, true);
+            }
+            const db = getClient();
+            const limit = args.limit || 90;
+            let scryfallId = args.scryfall_id;
+            // Resolve name → scryfall_id if needed
+            if (!scryfallId && args.name) {
+                const { data: cards, error: cardErr } = await db
+                    .from('cards')
+                    .select('scryfall_id, name')
+                    .ilike('name', args.name)
+                    .limit(1);
+                if (cardErr)
+                    throw new Error(cardErr.message);
+                if (!cards || cards.length === 0) {
+                    return jsonResult({ success: false, error: `Card not found: ${args.name}` }, true);
+                }
+                scryfallId = cards[0]
+                    .scryfall_id;
+            }
+            const { data, error } = await db
+                .from('price_history')
+                .select('date, price_usd, price_usd_foil, source')
+                .eq('scryfall_id', scryfallId)
+                .order('date', { ascending: false })
+                .limit(limit);
+            if (error)
+                throw new Error(error.message);
+            return jsonResult({
+                success: true,
+                scryfall_id: scryfallId,
+                history: data,
+                count: data?.length || 0,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+// =============================================================================
+// Tool 5: Format Deals
+// =============================================================================
+const deckFormatDeals = {
+    definition: {
+        name: 'deck_format_deals',
+        description: 'Find underpriced cards legal in a specific format. Great for budget deck building.',
+        annotations: {
+            title: 'Format Deals',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                format: {
+                    type: 'string',
+                    description: `Format to check legality (${VALID_FORMATS.join(', ')})`,
+                },
+                max_price: {
+                    type: 'number',
+                    description: 'Maximum price in USD (default: no limit)',
+                },
+                min_price: {
+                    type: 'number',
+                    description: 'Minimum price in USD (default: 0.01 to skip bulk)',
+                },
+                rarity: {
+                    type: 'string',
+                    description: 'Filter by rarity (common, uncommon, rare, mythic)',
+                },
+                sort_by: {
+                    type: 'string',
+                    description: 'Sort order: price_asc (default) or price_desc',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max results (default: 50, max: 200)',
+                },
+            },
+            required: ['format'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const format = validateFormat(args.format);
+            const minPrice = args.min_price ?? 0.01;
+            const limit = Math.min(args.limit || 50, 200);
+            const ascending = (args.sort_by || 'price_asc') === 'price_asc';
+            const db = getClient();
+            let query = db
+                .from('cards')
+                .select('name, set_code, set_name, rarity, price_usd, type_line, mana_cost, scryfall_id')
+                .filter(`legalities->>${format}`, 'eq', 'legal')
+                .gte('price_usd', minPrice)
+                .order('price_usd', { ascending, nullsFirst: false })
+                .limit(limit);
+            if (args.max_price != null) {
+                query = query.lte('price_usd', args.max_price);
+            }
+            if (args.rarity) {
+                query = query.eq('rarity', validateRarity(args.rarity));
+            }
+            const { data, error } = await query;
+            if (error)
+                throw new Error(error.message);
+            return jsonResult({
+                success: true,
+                format,
+                cards: data,
+                count: data?.length || 0,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+// =============================================================================
+// Tool 6: Type Search
+// =============================================================================
+const deckTypeSearch = {
+    definition: {
+        name: 'deck_type_search',
+        description: 'Search cards by type line for tribal/archetype building (e.g. Elf, Planeswalker, Equipment).',
+        annotations: {
+            title: 'Type Search',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                type: {
+                    type: 'string',
+                    description: 'Type to search for (e.g. "Elf", "Planeswalker", "Equipment")',
+                },
+                format: {
+                    type: 'string',
+                    description: 'Filter by format legality',
+                },
+                max_price: {
+                    type: 'number',
+                    description: 'Maximum price in USD',
+                },
+                min_price: {
+                    type: 'number',
+                    description: 'Minimum price in USD',
+                },
+                set_code: {
+                    type: 'string',
+                    description: 'Filter by set code (e.g. "MH3")',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max results (default: 50, max: 200)',
+                },
+            },
+            required: ['type'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const limit = Math.min(args.limit || 50, 200);
+            const db = getClient();
+            let query = db
+                .from('cards')
+                .select('name, set_code, set_name, rarity, price_usd, type_line, mana_cost, scryfall_id')
+                .ilike('type_line', `%${args.type}%`)
+                .order('price_usd', { ascending: false, nullsFirst: false })
+                .limit(limit);
+            if (args.format) {
+                const format = validateFormat(args.format);
+                query = query.filter(`legalities->>${format}`, 'eq', 'legal');
+            }
+            if (args.max_price != null) {
+                query = query.lte('price_usd', args.max_price);
+            }
+            if (args.min_price != null) {
+                query = query.gte('price_usd', args.min_price);
+            }
+            if (args.set_code) {
+                query = query.eq('set_code', args.set_code.toLowerCase());
+            }
+            const { data, error } = await query;
+            if (error)
+                throw new Error(error.message);
+            return jsonResult({
+                success: true,
+                type: args.type,
+                cards: data,
+                count: data?.length || 0,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+// =============================================================================
+// Tool 7: Price Bracket
+// =============================================================================
+const deckPriceBracket = {
+    definition: {
+        name: 'deck_price_bracket',
+        description: 'Multi-filter power search: combine price range, rarity, format, set, and type filters.',
+        annotations: {
+            title: 'Price Bracket',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                min_price: { type: 'number', description: 'Minimum price in USD' },
+                max_price: { type: 'number', description: 'Maximum price in USD' },
+                rarity: { type: 'string', description: 'Card rarity filter' },
+                format: { type: 'string', description: 'Format legality filter' },
+                set_code: { type: 'string', description: 'Set code filter' },
+                type_line: { type: 'string', description: 'Type line filter (partial match)' },
+                sort_by: {
+                    type: 'string',
+                    description: 'Sort: price_desc (default), price_asc, name',
+                },
+                limit: { type: 'number', description: 'Max results (default: 50, max: 200)' },
+            },
+            required: [],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const hasFilter = args.min_price != null ||
+                args.max_price != null ||
+                args.rarity ||
+                args.format ||
+                args.set_code ||
+                args.type_line;
+            if (!hasFilter) {
+                return jsonResult({ success: false, error: 'Provide at least one filter (min_price, max_price, rarity, format, set_code, type_line)' }, true);
+            }
+            const limit = Math.min(args.limit || 50, 200);
+            const db = getClient();
+            const filtersApplied = [];
+            let query = db
+                .from('cards')
+                .select('name, set_code, set_name, rarity, price_usd, type_line, mana_cost, scryfall_id')
+                .limit(limit);
+            if (args.min_price != null) {
+                query = query.gte('price_usd', args.min_price);
+                filtersApplied.push(`min_price=${args.min_price}`);
+            }
+            if (args.max_price != null) {
+                query = query.lte('price_usd', args.max_price);
+                filtersApplied.push(`max_price=${args.max_price}`);
+            }
+            if (args.rarity) {
+                query = query.eq('rarity', validateRarity(args.rarity));
+                filtersApplied.push(`rarity=${args.rarity}`);
+            }
+            if (args.format) {
+                const format = validateFormat(args.format);
+                query = query.filter(`legalities->>${format}`, 'eq', 'legal');
+                filtersApplied.push(`format=${format}`);
+            }
+            if (args.set_code) {
+                query = query.eq('set_code', args.set_code.toLowerCase());
+                filtersApplied.push(`set_code=${args.set_code}`);
+            }
+            if (args.type_line) {
+                query = query.ilike('type_line', `%${args.type_line}%`);
+                filtersApplied.push(`type_line~${args.type_line}`);
+            }
+            // Sort
+            const sortBy = args.sort_by || 'price_desc';
+            if (sortBy === 'price_asc') {
+                query = query.order('price_usd', { ascending: true, nullsFirst: false });
+            }
+            else if (sortBy === 'name') {
+                query = query.order('name', { ascending: true });
+            }
+            else {
+                query = query.order('price_usd', { ascending: false, nullsFirst: false });
+            }
+            const { data, error } = await query;
+            if (error)
+                throw new Error(error.message);
+            return jsonResult({
+                success: true,
+                filters_applied: filtersApplied,
+                cards: data,
+                count: data?.length || 0,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+// =============================================================================
+// Tool 8: Set Analysis
+// =============================================================================
+const deckSetAnalysis = {
+    definition: {
+        name: 'deck_set_analysis',
+        description: 'Aggregate price stats for a set: EV breakdown by rarity, top cards, cheapest mythics.',
+        annotations: {
+            title: 'Set Analysis',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                set_code: {
+                    type: 'string',
+                    description: 'Set code (e.g. "MH3", "LCI", "ONE")',
+                },
+            },
+            required: ['set_code'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const db = getClient();
+            const setCode = args.set_code.toLowerCase();
+            // Use the deck_set_stats SQL function for efficient server-side aggregation
+            const { data: stats, error: statsErr } = await db.rpc('deck_set_stats', {
+                p_set_code: setCode,
+            });
+            if (statsErr)
+                throw new Error(statsErr.message);
+            if (!stats || stats.length === 0) {
+                return jsonResult({ success: false, error: `No cards found for set "${args.set_code}"` }, true);
+            }
+            const row = stats[0];
+            // Also fetch top 10 most expensive for detail
+            const { data: topCards, error: topErr } = await db
+                .from('cards')
+                .select('name, rarity, price_usd')
+                .eq('set_code', setCode)
+                .not('price_usd', 'is', null)
+                .gt('price_usd', 0)
+                .order('price_usd', { ascending: false, nullsFirst: false })
+                .limit(10);
+            if (topErr)
+                throw new Error(topErr.message);
+            return jsonResult({
+                success: true,
+                set_code: row.set_code,
+                set_name: row.set_name,
+                total_cards: row.total_cards,
+                cards_with_price: row.cards_with_price,
+                total_value: row.total_value,
+                avg_price: row.avg_price,
+                median_price: row.median_price,
+                max_price: row.max_price,
+                max_price_card: row.max_price_card,
+                rarity_averages: {
+                    mythic: row.mythic_avg,
+                    rare: row.rare_avg,
+                    uncommon: row.uncommon_avg,
+                    common: row.common_avg,
+                },
+                cheapest_mythic: row.cheapest_mythic_name
+                    ? { name: row.cheapest_mythic_name, price: row.cheapest_mythic_price }
+                    : null,
+                top_10_expensive: topCards || [],
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+// =============================================================================
+// Tool 9: Volatility
+// =============================================================================
+const deckVolatility = {
+    definition: {
+        name: 'deck_volatility',
+        description: 'Price volatility scoring. Broad scan (no name) finds most volatile cards. Single card mode (with name/scryfall_id) gives detailed stability analysis with A-F grade.',
+        annotations: {
+            title: 'Volatility',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Card name for single-card analysis (omit for broad scan)',
+                },
+                scryfall_id: {
+                    type: 'string',
+                    description: 'Scryfall UUID for single-card analysis',
+                },
+                min_price: {
+                    type: 'number',
+                    description: 'Minimum price filter for broad scan (default: 1.00)',
+                },
+                days: {
+                    type: 'number',
+                    description: 'History window for single-card mode (default: 90)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max results for broad scan (default: 25, max: 100)',
+                },
+            },
+            required: [],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const db = getClient();
+            // ── Single card mode ──
+            if (args.name || args.scryfall_id) {
+                let scryfallId = args.scryfall_id;
+                // Resolve name → scryfall_id
+                if (!scryfallId && args.name) {
+                    const { data: cards, error: cardErr } = await db
+                        .from('cards')
+                        .select('scryfall_id, name, price_usd')
+                        .ilike('name', args.name)
+                        .limit(1);
+                    if (cardErr)
+                        throw new Error(cardErr.message);
+                    if (!cards || cards.length === 0) {
+                        return jsonResult({ success: false, error: `Card not found: ${args.name}` }, true);
+                    }
+                    scryfallId = cards[0].scryfall_id;
+                }
+                const days = args.days || 90;
+                // Fetch price history and movers in parallel
+                const [historyRes, moversRes] = await Promise.all([
+                    db
+                        .from('price_history')
+                        .select('date, price_usd')
+                        .eq('scryfall_id', scryfallId)
+                        .order('date', { ascending: false })
+                        .limit(days),
+                    db
+                        .from('price_movers')
+                        .select('period, price_from, price_to, change_pct')
+                        .eq('scryfall_id', scryfallId),
+                ]);
+                if (historyRes.error)
+                    throw new Error(historyRes.error.message);
+                const prices = (historyRes.data || [])
+                    .map((r) => r.price_usd)
+                    .filter((p) => p != null && p > 0);
+                if (prices.length < 2) {
+                    return jsonResult({
+                        success: true,
+                        mode: 'single',
+                        scryfall_id: scryfallId,
+                        message: 'Not enough price history for volatility analysis',
+                        data_points: prices.length,
+                    });
+                }
+                const mean = prices.reduce((s, p) => s + p, 0) / prices.length;
+                const variance = prices.reduce((s, p) => s + (p - mean) ** 2, 0) / prices.length;
+                const stddev = Math.sqrt(variance);
+                const cv = (stddev / mean) * 100; // coefficient of variation as %
+                const stability = gradeStability(cv);
+                const trend = prices.length >= 2
+                    ? prices[0] > prices[prices.length - 1]
+                        ? 'rising'
+                        : prices[0] < prices[prices.length - 1]
+                            ? 'falling'
+                            : 'flat'
+                    : 'unknown';
+                return jsonResult({
+                    success: true,
+                    mode: 'single',
+                    scryfall_id: scryfallId,
+                    data_points: prices.length,
+                    stats: {
+                        mean: Math.round(mean * 100) / 100,
+                        stddev: Math.round(stddev * 100) / 100,
+                        coefficient_of_variation: Math.round(cv * 100) / 100,
+                        min: Math.min(...prices),
+                        max: Math.max(...prices),
+                        range: Math.round((Math.max(...prices) - Math.min(...prices)) * 100) / 100,
+                        trend,
+                    },
+                    stability_grade: stability.grade,
+                    stability_label: stability.label,
+                    recent_movers: moversRes.data || [],
+                });
+            }
+            // ── Broad scan mode — use SQL function for real CV-based volatility ──
+            const minPrice = args.min_price ?? 1.0;
+            const limit = Math.min(args.limit || 25, 100);
+            const days = args.days || 30;
+            const { data: volData, error: volErr } = await db.rpc('deck_volatility_scores', { p_days: days, p_min_price: minPrice, p_limit: limit });
+            if (volErr)
+                throw new Error(volErr.message);
+            const results = (volData || []).map((r) => ({
+                name: r.name,
+                set_code: r.set_code,
+                rarity: r.rarity,
+                scryfall_id: r.scryfall_id,
+                current_price: r.current_price,
+                avg_price: r.avg_price,
+                stddev: r.stddev_price,
+                price_range: { min: r.min_price, max: r.max_price },
+                cv_pct: r.cv_pct,
+                stability: gradeStability(Number(r.cv_pct) || 0),
+                data_points: r.data_points,
+            }));
+            return jsonResult({
+                success: true,
+                mode: 'broad',
+                days,
+                min_price_filter: minPrice,
+                cards: results,
+                count: results.length,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+// =============================================================================
+// Tool 10: Reprints
+// =============================================================================
+const deckReprints = {
+    definition: {
+        name: 'deck_reprints',
+        description: 'Cross-printing price comparison and arbitrage finder. Shows all printings of a card sorted by price.',
+        annotations: {
+            title: 'Reprints',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Card name (exact match, case-insensitive)',
+                },
+            },
+            required: ['name'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const db = getClient();
+            // Exact match (case-insensitive, no wildcards)
+            const { data, error } = await db
+                .from('cards')
+                .select('name, set_code, set_name, rarity, price_usd, price_usd_foil, scryfall_id, image_uri')
+                .ilike('name', args.name)
+                .order('price_usd', { ascending: true, nullsFirst: false })
+                .limit(100);
+            if (error)
+                throw new Error(error.message);
+            // No exact match — try partial for suggestions
+            if (!data || data.length === 0) {
+                const { data: suggestions, error: sugErr } = await db
+                    .from('cards')
+                    .select('name')
+                    .ilike('name', `%${args.name}%`)
+                    .limit(20);
+                if (sugErr)
+                    throw new Error(sugErr.message);
+                const uniqueNames = [...new Set((suggestions || []).map((s) => s.name))].slice(0, 5);
+                return jsonResult({
+                    success: false,
+                    error: `No exact match for "${args.name}"`,
+                    suggestions: uniqueNames.length > 0 ? uniqueNames : undefined,
+                }, true);
+            }
+            const printings = data;
+            // Compute summary stats
+            const priced = printings.filter((c) => c.price_usd != null && c.price_usd > 0);
+            const prices = priced.map((c) => c.price_usd);
+            const summary = prices.length > 0
+                ? {
+                    total_printings: printings.length,
+                    priced_printings: prices.length,
+                    cheapest: Math.min(...prices),
+                    most_expensive: Math.max(...prices),
+                    price_spread: Math.round((Math.max(...prices) - Math.min(...prices)) * 100) / 100,
+                    average_price: Math.round((prices.reduce((s, p) => s + p, 0) / prices.length) * 100) / 100,
+                }
+                : {
+                    total_printings: printings.length,
+                    priced_printings: 0,
+                    cheapest: null,
+                    most_expensive: null,
+                    price_spread: null,
+                    average_price: null,
+                };
             return jsonResult({
                 success: true,
-                stores: result.rows.map(row => ({
-                    store: row.store,
-                    card_count: parseInt(row.card_count, 10),
-                    last_updated: row.last_updated?.toISOString() || null,
+                name: printings[0].name,
+                summary,
+                printings: printings.map((c) => ({
+                    set_code: c.set_code,
+                    set_name: c.set_name,
+                    rarity: c.rarity,
+                    price_usd: c.price_usd,
+                    price_usd_foil: c.price_usd_foil,
+                    scryfall_id: c.scryfall_id,
                 })),
             });
         }
@@ -178,11 +957,700 @@ const deckBuylistStores = {
     },
 };
 // =============================================================================
+// Tool 11: Match History
+// =============================================================================
+const deckMatchHistory = {
+    definition: {
+        name: 'deck_match_history',
+        description: 'Recent MTG Arena match history. Returns opponent, format, result, deck, duration.',
+        annotations: {
+            title: 'Match History',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Max results (default: 20, max: 100)',
+                },
+                format: {
+                    type: 'string',
+                    description: 'Optional: filter by format (e.g. "Standard", "Historic")',
+                },
+            },
+            required: [],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const db = getClient();
+            const limit = Math.min(args.limit || 20, 100);
+            let query = db
+                .from('match_summary')
+                .select('match_id, opponent, format, result, deck_name, duration_seconds, started_at')
+                .order('started_at_ms', { ascending: false })
+                .limit(limit);
+            if (args.format) {
+                query = query.ilike('format', args.format);
+            }
+            const { data, error } = await query;
+            if (error)
+                throw new Error(error.message);
+            return jsonResult({
+                success: true,
+                matches: data || [],
+                count: (data || []).length,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+// =============================================================================
+// Tool 12: Win Rate
+// =============================================================================
+const deckWinRate = {
+    definition: {
+        name: 'deck_win_rate',
+        description: 'Win rate statistics grouped by format. Includes overall stats and current streak.',
+        annotations: {
+            title: 'Win Rate',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                format: {
+                    type: 'string',
+                    description: 'Optional: filter to a specific format',
+                },
+            },
+            required: [],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const db = getClient();
+            let query = db
+                .from('match_summary')
+                .select('format, result, started_at_ms')
+                .order('started_at_ms', { ascending: false });
+            if (args.format) {
+                query = query.ilike('format', args.format);
+            }
+            const { data, error } = await query;
+            if (error)
+                throw new Error(error.message);
+            const matches = (data || []);
+            // Group by format
+            const byFormat = new Map();
+            for (const m of matches) {
+                const fmt = m.format || 'Unknown';
+                if (!byFormat.has(fmt))
+                    byFormat.set(fmt, { wins: 0, losses: 0, draws: 0, results: [] });
+                const bucket = byFormat.get(fmt);
+                const result = m.result || '';
+                if (result === 'win')
+                    bucket.wins++;
+                else if (result === 'loss' || result === 'concede')
+                    bucket.losses++;
+                else
+                    bucket.draws++;
+                bucket.results.push(result);
+            }
+            // Compute current streak from all matches (chronological, most recent first)
+            const allResults = matches.map((m) => m.result);
+            let streak = 0;
+            const streakType = allResults[0] === 'win' ? 'W' : allResults[0] === 'loss' || allResults[0] === 'concede' ? 'L' : 'D';
+            for (const r of allResults) {
+                const rType = r === 'win' ? 'W' : r === 'loss' || r === 'concede' ? 'L' : 'D';
+                if (rType === streakType)
+                    streak++;
+                else
+                    break;
+            }
+            const formatStats = Array.from(byFormat.entries()).map(([fmt, b]) => {
+                const total = b.wins + b.losses + b.draws;
+                return {
+                    format: fmt,
+                    total,
+                    wins: b.wins,
+                    losses: b.losses,
+                    draws: b.draws,
+                    win_rate: total > 0 ? Math.round((b.wins / total) * 10000) / 100 : 0,
+                };
+            });
+            // Overall
+            const totalWins = formatStats.reduce((s, f) => s + f.wins, 0);
+            const totalLosses = formatStats.reduce((s, f) => s + f.losses, 0);
+            const totalDraws = formatStats.reduce((s, f) => s + f.draws, 0);
+            const totalAll = totalWins + totalLosses + totalDraws;
+            return jsonResult({
+                success: true,
+                overall: {
+                    total: totalAll,
+                    wins: totalWins,
+                    losses: totalLosses,
+                    draws: totalDraws,
+                    win_rate: totalAll > 0 ? Math.round((totalWins / totalAll) * 10000) / 100 : 0,
+                    current_streak: `${streak}${streakType}`,
+                },
+                by_format: formatStats,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+// =============================================================================
+// Tool 13: Card Performance
+// =============================================================================
+const deckCardPerformance = {
+    definition: {
+        name: 'deck_card_performance',
+        description: 'Best and worst cards by win rate. Requires minimum match threshold to filter noise.',
+        annotations: {
+            title: 'Card Performance',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                format: {
+                    type: 'string',
+                    description: 'Optional: filter by format',
+                },
+                min_matches: {
+                    type: 'number',
+                    description: 'Minimum matches to include (default: 3)',
+                },
+                sort: {
+                    type: 'string',
+                    description: 'Sort order: "win_rate desc" (default), "win_rate asc", "matches desc"',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max results (default: 20, max: 100)',
+                },
+            },
+            required: [],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const db = getClient();
+            const minMatches = args.min_matches || 3;
+            const limit = Math.min(args.limit || 20, 100);
+            let query = db
+                .from('card_win_rates')
+                .select('name, format, matches, wins, losses, win_rate, set_code')
+                .gte('matches', minMatches);
+            if (args.format) {
+                query = query.ilike('format', args.format);
+            }
+            // Sort
+            const sort = (args.sort || 'win_rate desc').toLowerCase();
+            if (sort === 'win_rate asc') {
+                query = query.order('win_rate', { ascending: true }).order('matches', { ascending: false });
+            }
+            else if (sort === 'matches desc') {
+                query = query.order('matches', { ascending: false });
+            }
+            else {
+                query = query.order('win_rate', { ascending: false }).order('matches', { ascending: false });
+            }
+            query = query.limit(limit);
+            const { data, error } = await query;
+            if (error)
+                throw new Error(error.message);
+            return jsonResult({
+                success: true,
+                cards: data || [],
+                count: (data || []).length,
+                min_matches_filter: minMatches,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+// =============================================================================
+// Tool 14: Deck Record
+// =============================================================================
+const deckRecord = {
+    definition: {
+        name: 'deck_record',
+        description: 'Deck-level win/loss records from deck_stats. Search by name or list all.',
+        annotations: {
+            title: 'Deck Record',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                deck_name: {
+                    type: 'string',
+                    description: 'Optional: search by deck name (partial match)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max results (default: 20)',
+                },
+            },
+            required: [],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const db = getClient();
+            const limit = Math.min(args.limit || 20, 100);
+            let query = db
+                .from('deck_stats')
+                .select('deck_name, total_matches, wins, losses, last_played_ms')
+                .order('total_matches', { ascending: false })
+                .limit(limit);
+            if (args.deck_name) {
+                query = query.ilike('deck_name', `%${args.deck_name}%`);
+            }
+            const { data, error } = await query;
+            if (error)
+                throw new Error(error.message);
+            const decks = (data || []).map((d) => {
+                const total = d.total_matches || 0;
+                const wins = d.wins || 0;
+                const losses = d.losses || 0;
+                return {
+                    deck_name: d.deck_name,
+                    total_matches: total,
+                    wins,
+                    losses,
+                    win_rate: total > 0 ? Math.round((wins / total) * 10000) / 100 : 0,
+                    last_played: d.last_played_ms
+                        ? new Date(Number(d.last_played_ms)).toISOString()
+                        : null,
+                };
+            });
+            return jsonResult({
+                success: true,
+                decks,
+                count: decks.length,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+// =============================================================================
+// Tool 15: Player Summary
+// =============================================================================
+const deckPlayerSummary = {
+    definition: {
+        name: 'deck_player_summary',
+        description: 'Combined gameplay dashboard: total matches, overall win rate, best format, best deck, longest streak, recent form (last 10).',
+        annotations: {
+            title: 'Player Summary',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+    handler: async () => {
+        try {
+            const db = getClient();
+            // Fetch matches and deck stats in parallel
+            const [matchRes, deckRes] = await Promise.all([
+                db
+                    .from('match_summary')
+                    .select('format, result, deck_name, started_at_ms')
+                    .order('started_at_ms', { ascending: false }),
+                db
+                    .from('deck_stats')
+                    .select('deck_name, total_matches, wins, losses')
+                    .order('total_matches', { ascending: false }),
+            ]);
+            if (matchRes.error)
+                throw new Error(matchRes.error.message);
+            if (deckRes.error)
+                throw new Error(deckRes.error.message);
+            const matches = (matchRes.data || []);
+            const decks = (deckRes.data || []);
+            // Overall stats
+            const totalMatches = matches.length;
+            const wins = matches.filter((m) => m.result === 'win').length;
+            const losses = matches.filter((m) => m.result === 'loss' || m.result === 'concede').length;
+            const overallWinRate = totalMatches > 0 ? Math.round((wins / totalMatches) * 10000) / 100 : 0;
+            // Best format (by win rate, min 5 matches)
+            const fmtMap = new Map();
+            for (const m of matches) {
+                const fmt = m.format || 'Unknown';
+                if (!fmtMap.has(fmt))
+                    fmtMap.set(fmt, { w: 0, t: 0 });
+                const b = fmtMap.get(fmt);
+                b.t++;
+                if (m.result === 'win')
+                    b.w++;
+            }
+            let bestFormat = null;
+            for (const [fmt, b] of fmtMap) {
+                if (b.t >= 5) {
+                    const wr = b.w / b.t;
+                    if (!bestFormat || wr > bestFormat.win_rate) {
+                        bestFormat = { format: fmt, win_rate: Math.round(wr * 10000) / 100, matches: b.t };
+                    }
+                }
+            }
+            // Best deck (from deck_stats, min 3 matches)
+            let bestDeck = null;
+            for (const d of decks) {
+                const total = d.total_matches || 0;
+                const w = d.wins || 0;
+                if (total >= 3) {
+                    const wr = w / total;
+                    if (!bestDeck || wr > bestDeck.win_rate) {
+                        bestDeck = {
+                            deck_name: d.deck_name,
+                            win_rate: Math.round(wr * 10000) / 100,
+                            matches: total,
+                        };
+                    }
+                }
+            }
+            // Longest streak (all-time)
+            let longestStreak = 0;
+            let longestStreakType = '';
+            let currentRun = 0;
+            let currentType = '';
+            for (const m of matches) {
+                const r = m.result === 'win' ? 'W' : 'L';
+                if (r === currentType) {
+                    currentRun++;
+                }
+                else {
+                    currentType = r;
+                    currentRun = 1;
+                }
+                if (currentRun > longestStreak) {
+                    longestStreak = currentRun;
+                    longestStreakType = currentType;
+                }
+            }
+            // Recent form (last 10)
+            const recentForm = matches.slice(0, 10).map((m) => {
+                const r = m.result;
+                return r === 'win' ? 'W' : r === 'loss' || r === 'concede' ? 'L' : 'D';
+            });
+            return jsonResult({
+                success: true,
+                total_matches: totalMatches,
+                overall_win_rate: overallWinRate,
+                wins,
+                losses,
+                best_format: bestFormat,
+                best_deck: bestDeck,
+                longest_streak: `${longestStreak}${longestStreakType}`,
+                recent_form: recentForm.join(''),
+                total_decks: decks.length,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+// =============================================================================
+// Tool 16: Draft Stats
+// =============================================================================
+const deckDraftStats = {
+    definition: {
+        name: 'deck_draft_stats',
+        description: 'Draft history and performance from MTG Arena. Returns event, set, record, trophy status per draft.',
+        annotations: {
+            title: 'Draft Stats',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                set_code: {
+                    type: 'string',
+                    description: 'Optional: filter by set code (e.g. "OTJ", "MKM")',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max results (default: 20, max: 100)',
+                },
+            },
+            required: [],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const db = getClient();
+            const limit = Math.min(args.limit || 20, 100);
+            let query = db
+                .from('draft_summary')
+                .select('event_name, set_code, completed_at, total_picks, wins, losses')
+                .order('completed_at', { ascending: false })
+                .limit(limit);
+            if (args.set_code) {
+                query = query.ilike('set_code', args.set_code);
+            }
+            const { data, error } = await query;
+            if (error)
+                throw new Error(error.message);
+            const drafts = (data || []).map((d) => {
+                const wins = d.wins || 0;
+                const losses = d.losses || 0;
+                return {
+                    event_name: d.event_name,
+                    set_code: d.set_code,
+                    completed_at: d.completed_at,
+                    total_picks: d.total_picks,
+                    wins,
+                    losses,
+                    record: `${wins}-${losses}`,
+                    trophy: wins >= 7,
+                };
+            });
+            return jsonResult({
+                success: true,
+                drafts,
+                count: drafts.length,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+// =============================================================================
+// Intel Reports
+// =============================================================================
+const INTEL_TYPES = [
+    'price_spike', 'price_crash', 'format_shakeup', 'sleeper_pick',
+    'deck_tech', 'meta_shift', 'budget_alert', 'spec_target',
+    'correlation', 'event_impact', 'reprint_arb', 'supply_signal',
+];
+const INTEL_URGENCIES = ['breaking', 'daily', 'weekly', 'background'];
+const deckIntelWrite = {
+    definition: {
+        name: 'deck_intel_write',
+        description: 'Write an intel report to the intel_reports table. Used by the deckscry-intel agent to publish analysis results.',
+        annotations: {
+            title: 'Write Intel Report',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                type: {
+                    type: 'string',
+                    enum: [...INTEL_TYPES],
+                    description: 'Intel report type',
+                },
+                format: {
+                    type: 'string',
+                    description: 'MTG format (standard, pioneer, modern, etc.) or null for cross-format',
+                },
+                urgency: {
+                    type: 'string',
+                    enum: [...INTEL_URGENCIES],
+                    description: 'Report urgency (default: daily)',
+                },
+                title: {
+                    type: 'string',
+                    description: 'Report title — e.g. "Sheoldred spikes 40% after Pioneer RCQ results"',
+                },
+                summary: {
+                    type: 'string',
+                    description: '2-3 sentence analysis with evidence and reasoning',
+                },
+                cards: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Scryfall UUIDs of cards involved',
+                },
+                data: {
+                    type: 'object',
+                    description: 'Structured payload — analyzer name, confidence, evidence, involved_cards details',
+                },
+                social_hook: {
+                    type: 'string',
+                    description: 'Pre-written social media hook with specific numbers, timeframe, and why. Under 200 chars.',
+                },
+            },
+            required: ['type', 'title', 'summary'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const db = getClient();
+            const { data, error } = await db
+                .from('intel_reports')
+                .insert({
+                type: args.type,
+                format: args.format || null,
+                urgency: args.urgency || 'daily',
+                title: args.title,
+                summary: args.summary,
+                cards: args.cards || [],
+                data: args.data || {},
+                social_hook: args.social_hook || null,
+            })
+                .select('id, type, format, urgency, title, created_at')
+                .single();
+            if (error)
+                throw new Error(error.message);
+            return jsonResult({ success: true, report: data });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+const deckIntelReports = {
+    definition: {
+        name: 'deck_intel_reports',
+        description: 'Read intel reports. Filter by type, format, urgency, or unpublished status. Used by marketer and other consumers.',
+        annotations: {
+            title: 'Read Intel Reports',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                type: { type: 'string', description: 'Filter by intel type' },
+                format: { type: 'string', description: 'Filter by MTG format' },
+                urgency: { type: 'string', description: 'Filter by urgency level' },
+                unpublished: { type: 'boolean', description: 'If true, only return reports not yet consumed by marketer' },
+                limit: { type: 'number', description: 'Max reports to return (default: 20)' },
+            },
+            required: [],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const db = getClient();
+            let query = db
+                .from('intel_reports')
+                .select('*')
+                .order('created_at', { ascending: false })
+                .limit(args.limit || 20);
+            if (args.type)
+                query = query.eq('type', args.type);
+            if (args.format)
+                query = query.eq('format', args.format);
+            if (args.urgency)
+                query = query.eq('urgency', args.urgency);
+            if (args.unpublished)
+                query = query.eq('published', false);
+            const { data, error } = await query;
+            if (error)
+                throw new Error(error.message);
+            return jsonResult({
+                success: true,
+                reports: data,
+                count: data?.length || 0,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+const deckIntelPublish = {
+    definition: {
+        name: 'deck_intel_publish',
+        description: 'Mark intel reports as published (consumed by marketer). Accepts one or more report IDs.',
+        annotations: {
+            title: 'Mark Intel Published',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                report_ids: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'UUIDs of reports to mark as published',
+                },
+            },
+            required: ['report_ids'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const db = getClient();
+            const { error } = await db
+                .from('intel_reports')
+                .update({ published: true })
+                .in('id', args.report_ids);
+            if (error)
+                throw new Error(error.message);
+            return jsonResult({ success: true, published: args.report_ids.length });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return jsonResult({ success: false, error: msg }, true);
+        }
+    },
+};
+// =============================================================================
 // Export
 // =============================================================================
 export const deckTools = [
-    deckBuylistSearch,
-    deckBuylistList,
-    deckBuylistStores,
+    deckSearch,
+    deckList,
+    deckSummary,
+    deckHistory,
+    deckFormatDeals,
+    deckTypeSearch,
+    deckPriceBracket,
+    deckSetAnalysis,
+    deckVolatility,
+    deckReprints,
+    deckMatchHistory,
+    deckWinRate,
+    deckCardPerformance,
+    deckRecord,
+    deckPlayerSummary,
+    deckDraftStats,
+    deckIntelWrite,
+    deckIntelReports,
+    deckIntelPublish,
 ];
 //# sourceMappingURL=deck.js.map