@spfunctions/cli 1.7.17 → 1.7.20

package/dist/tui/dashboard.js

@@ -1,814 +0,0 @@
-"use strict";
-/**
- * TUI Dashboard Engine — main loop
- *
- * Manages the render loop, data loading, keypress handling, and mode transitions.
- * This is NOT the commander entry point — see commands/dashboard.ts for that.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadAllData = loadAllData;
-exports.startDashboard = startDashboard;
-const screen_js_1 = require("./screen.js");
-const layout_js_1 = require("./layout.js");
-const state_js_1 = require("./state.js");
-const border_js_1 = require("./border.js");
-const cache_js_1 = require("../cache.js");
-const config_js_1 = require("../config.js");
-const client_js_1 = require("../client.js");
-const kalshi_js_1 = require("../kalshi.js");
-const topics_js_1 = require("../topics.js");
-const polymarket_js_1 = require("../polymarket.js");
-// Widget renderers
-const portfolio_js_1 = require("./widgets/portfolio.js");
-const thesis_js_1 = require("./widgets/thesis.js");
-const edges_js_1 = require("./widgets/edges.js");
-const upcoming_js_1 = require("./widgets/upcoming.js");
-const orders_js_1 = require("./widgets/orders.js");
-const signals_js_1 = require("./widgets/signals.js");
-const statusbar_js_1 = require("./widgets/statusbar.js");
-const commandbar_js_1 = require("./widgets/commandbar.js");
-const detail_js_1 = require("./widgets/detail.js");
-const liquidity_js_1 = require("./widgets/liquidity.js");
-const whatif_js_1 = require("./widgets/whatif.js");
-const trade_js_1 = require("./widgets/trade.js");
-// Refresh intervals (ms)
-const REFRESH_POSITIONS = 15_000;
-const REFRESH_THESES = 30_000;
-const REFRESH_ORDERS = 10_000;
-const REFRESH_BALANCE = 30_000;
-const REFRESH_FEED = 60_000;
-const REFRESH_CANDLES = 60_000;
-let sfClient = null;
-function getClient() {
-    if (sfClient)
-        return sfClient;
-    try {
-        const config = (0, config_js_1.loadConfig)();
-        if (!config.apiKey)
-            return null;
-        sfClient = new client_js_1.SFClient(config.apiKey, config.apiUrl);
-        return sfClient;
-    }
-    catch {
-        return null;
-    }
-}
-// ============================================================================
-// DATA LOADING
-// ============================================================================
-async function loadAllData(state) {
-    const client = getClient();
-    // Parallel fetch of primary data
-    const [positionsResult, thesesResult, ordersResult, balanceResult] = await Promise.allSettled([
-        (0, cache_js_1.cached)('positions', REFRESH_POSITIONS, () => (0, kalshi_js_1.getPositions)()),
-        client ? (0, cache_js_1.cached)('theses', REFRESH_THESES, () => client.listTheses()) : Promise.resolve(null),
-        (0, cache_js_1.cached)('orders', REFRESH_ORDERS, () => (0, kalshi_js_1.getOrders)({ status: 'resting' })),
-        (0, cache_js_1.cached)('balance', REFRESH_BALANCE, () => (0, kalshi_js_1.getBalance)()),
-    ]);
-    // Positions
-    if (positionsResult.status === 'fulfilled' && positionsResult.value) {
-        const positions = positionsResult.value;
-        // Enrich with live prices
-        const priceResults = await Promise.allSettled(positions.map(p => (0, cache_js_1.cached)(`price:${p.ticker}`, 10_000, () => (0, kalshi_js_1.getMarketPrice)(p.ticker))));
-        for (let i = 0; i < positions.length; i++) {
-            const pr = priceResults[i];
-            if (pr.status === 'fulfilled' && pr.value != null) {
-                positions[i].current_value = pr.value;
-                positions[i].unrealized_pnl = Math.round((pr.value - positions[i].average_price_paid) * positions[i].quantity);
-            }
-        }
-        state.positions = positions;
-    }
-    // Polymarket positions (merge into state.positions with venue tag)
-    const config = (0, config_js_1.loadConfig)();
-    if (config.polymarketWalletAddress) {
-        try {
-            const polyPos = await (0, cache_js_1.cached)('poly-positions', REFRESH_POSITIONS, () => (0, polymarket_js_1.polymarketGetPositions)(config.polymarketWalletAddress));
-            if (polyPos && Array.isArray(polyPos) && polyPos.length > 0) {
-                for (const p of polyPos) {
-                    state.positions.push({
-                        ticker: (p.title || p.slug || p.asset || '').slice(0, 25),
-                        quantity: p.size || 0,
-                        average_price_paid: Math.round((p.avgPrice || 0) * 100),
-                        current_value: Math.round((p.curPrice || p.currentPrice || 0) * 100),
-                        unrealized_pnl: Math.round((p.cashPnl || 0) * 100),
-                        side: (p.outcome || 'yes').toLowerCase(),
-                        venue: 'polymarket',
-                    });
-                }
-            }
-        }
-        catch {
-            // skip
-        }
-    }
-    // Theses
-    if (thesesResult.status === 'fulfilled' && thesesResult.value) {
-        const raw = thesesResult.value;
-        state.theses = raw.theses || raw || [];
-    }
-    // Orders
-    if (ordersResult.status === 'fulfilled' && ordersResult.value) {
-        state.orders = ordersResult.value.orders || [];
-    }
-    // Balance
-    if (balanceResult.status === 'fulfilled' && balanceResult.value) {
-        state.balance = balanceResult.value.balance ?? 0;
-    }
-    // Fetch contexts for each thesis (parallel)
-    if (client && state.theses.length > 0) {
-        const ctxResults = await Promise.allSettled(state.theses.map(t => (0, cache_js_1.cached)(`ctx:${t.id}`, REFRESH_THESES, () => client.getContext(t.id))));
-        for (let i = 0; i < state.theses.length; i++) {
-            const cr = ctxResults[i];
-            if (cr.status === 'fulfilled' && cr.value) {
-                state.contexts.set(state.theses[i].id, cr.value);
-            }
-        }
-    }
-    // Compute edges from all contexts
-    computeEdges(state);
-    // Fetch candlesticks for position tickers
-    await loadCandles(state);
-    // Fetch feed for signals
-    if (client) {
-        try {
-            const feed = await (0, cache_js_1.cached)('feed', REFRESH_FEED, () => client.getFeed(48));
-            const entries = feed.entries || feed.feed || feed;
-            if (Array.isArray(entries)) {
-                state.signals = entries;
-            }
-        }
-        catch { /* ignore */ }
-    }
-    // Collect upcoming events from contexts
-    collectEvents(state);
-    // Check exchange status
-    checkExchangeStatus(state);
-    state.lastRefresh.all = Date.now();
-}
-function computeEdges(state) {
-    const allEdges = [];
-    for (const [, ctx] of state.contexts) {
-        if (!ctx?.edges)
-            continue;
-        for (const e of ctx.edges) {
-            allEdges.push(e);
-        }
-    }
-    // Dedup by marketId, keep highest |edge|
-    const edgeMap = new Map();
-    for (const e of allEdges) {
-        const key = e.marketId || e.ticker || e.market;
-        const existing = edgeMap.get(key);
-        if (!existing || Math.abs(e.edge ?? 0) > Math.abs(existing.edge ?? 0)) {
-            edgeMap.set(key, e);
-        }
-    }
-    // Filter out held positions, sort by |edge|
-    const heldTickers = new Set(state.positions.map(p => p.ticker_symbol || p.ticker));
-    state.edges = [...edgeMap.values()]
-        .filter(e => !heldTickers.has(e.marketId || e.ticker))
-        .sort((a, b) => Math.abs(b.edge ?? 0) - Math.abs(a.edge ?? 0));
-}
-async function loadCandles(state) {
-    const tickers = state.positions.map(p => p.ticker).filter(Boolean);
-    if (tickers.length === 0)
-        return;
-    try {
-        const now = Math.floor(Date.now() / 1000);
-        const sevenDaysAgo = now - 7 * 86400;
-        const result = await (0, cache_js_1.cached)('candles', REFRESH_CANDLES, () => (0, kalshi_js_1.getBatchCandlesticks)({ tickers, startTs: sevenDaysAgo, endTs: now }));
-        for (const item of result) {
-            if (item.market_ticker && item.candlesticks) {
-                // Parse candles to extract close price in cents
-                const parsed = item.candlesticks.map((c) => {
-                    const bidClose = parseFloat(c.yes_bid?.close_dollars || '0');
-                    const askClose = parseFloat(c.yes_ask?.close_dollars || '0');
-                    const mid = bidClose > 0 && askClose > 0 ? (bidClose + askClose) / 2 : bidClose || askClose;
-                    const closeDollars = parseFloat(c.price?.close_dollars || '0') || mid;
-                    return {
-                        close: Math.round(closeDollars * 100), // cents
-                        date: c.end_period_ts ? new Date(c.end_period_ts * 1000).toISOString().slice(0, 10) : '',
-                        end_period_ts: c.end_period_ts,
-                    };
-                }).filter((c) => c.close > 0);
-                state.candleCache.set(item.market_ticker, parsed);
-            }
-        }
-    }
-    catch { /* ignore */ }
-}
-function collectEvents(state) {
-    const events = [];
-    for (const [, ctx] of state.contexts) {
-        if (ctx?.milestones) {
-            for (const m of ctx.milestones) {
-                events.push(m);
-            }
-        }
-        if (ctx?.upcomingEvents) {
-            for (const e of ctx.upcomingEvents) {
-                events.push(e);
-            }
-        }
-    }
-    // Sort by timestamp ascending (soonest first)
-    events.sort((a, b) => {
-        const ta = new Date(a.timestamp || a.date || a.time || 0).getTime();
-        const tb = new Date(b.timestamp || b.date || b.time || 0).getTime();
-        return ta - tb;
-    });
-    state.events = events.filter(e => {
-        const t = new Date(e.timestamp || e.date || e.time || 0).getTime();
-        return t > Date.now();
-    });
-}
-function checkExchangeStatus(state) {
-    // Kalshi exchange hours: Mon-Fri, no federal holidays
-    // Simplified heuristic
-    const now = new Date();
-    const day = now.getUTCDay();
-    state.exchangeOpen = day >= 1 && day <= 5;
-}
-// ============================================================================
-// RENDERING
-// ============================================================================
-function renderFrame(screen, state) {
-    // Clear back buffer (it's already cleared by ScreenBuffer)
-    // Status bar (row 0)
-    (0, statusbar_js_1.renderStatusBar)(screen, 0, state);
-    // Command bar (last row)
-    (0, commandbar_js_1.renderCommandBar)(screen, screen.rows - 1, state);
-    // Mode-specific content
-    switch (state.mode) {
-        case 'overview':
-            renderOverview(screen, state);
-            break;
-        case 'detail':
-            (0, detail_js_1.renderDetail)(screen, (0, layout_js_1.fullLayout)(screen.cols, screen.rows), state);
-            break;
-        case 'liquidity':
-            (0, liquidity_js_1.renderLiquidity)(screen, (0, layout_js_1.fullLayout)(screen.cols, screen.rows), state);
-            break;
-        case 'whatif':
-            (0, whatif_js_1.renderWhatif)(screen, (0, layout_js_1.fullLayout)(screen.cols, screen.rows), state);
-            break;
-        case 'trade':
-            // Render overview or detail behind the trade overlay
-            if (state.prevMode === 'detail') {
-                (0, detail_js_1.renderDetail)(screen, (0, layout_js_1.fullLayout)(screen.cols, screen.rows), state);
-            }
-            else {
-                renderOverview(screen, state);
-            }
-            (0, trade_js_1.renderTrade)(screen, (0, layout_js_1.fullLayout)(screen.cols, screen.rows), state);
-            break;
-    }
-    screen.flush();
-}
-function renderOverview(screen, state) {
-    const isNarrow = screen.cols < 80;
-    const regions = isNarrow
-        ? (0, layout_js_1.narrowLayout)(screen.cols, screen.rows)
-        : (0, layout_js_1.overviewLayout)(screen.cols, screen.rows);
-    // Render vertical divider for wide layout
-    if (!isNarrow) {
-        const leftWidth = Math.floor(screen.cols * 0.55);
-        for (let r = 1; r < screen.rows - 1; r++) {
-            screen.write(r, leftWidth, '│', border_js_1.CLR.borderDim);
-        }
-    }
-    for (const region of regions) {
-        switch (region.name) {
-            case 'positions':
-                (0, portfolio_js_1.renderPortfolio)(screen, region, state);
-                break;
-            case 'thesis':
-                (0, thesis_js_1.renderThesis)(screen, region, state);
-                break;
-            case 'edges':
-                (0, edges_js_1.renderEdges)(screen, region, state);
-                break;
-            case 'upcoming':
-                (0, upcoming_js_1.renderUpcoming)(screen, region, state);
-                break;
-            case 'orders':
-                (0, orders_js_1.renderOrders)(screen, region, state);
-                break;
-            case 'signals':
-                (0, signals_js_1.renderSignals)(screen, region, state);
-                break;
-        }
-    }
-}
-// ============================================================================
-// KEYPRESS HANDLING
-// ============================================================================
-function handleKeypress(state, key, screen, scheduleRender, cleanup) {
-    const ch = key.toString('utf-8');
-    const isEsc = key[0] === 0x1b && key.length === 1;
-    const isUp = key[0] === 0x1b && key[1] === 0x5b && key[2] === 0x41;
-    const isDown = key[0] === 0x1b && key[1] === 0x5b && key[2] === 0x42;
-    const isEnter = ch === '\r' || ch === '\n';
-    const isCtrlC = key[0] === 0x03;
-    if (isCtrlC || (ch === 'q' && state.mode !== 'trade')) {
-        cleanup();
-        return;
-    }
-    state.error = null;
-    switch (state.mode) {
-        case 'overview':
-            handleOverviewKey(ch, isUp, isDown, isEnter, state, screen, scheduleRender, cleanup);
-            break;
-        case 'detail':
-            handleDetailKey(ch, isEsc, state, screen, scheduleRender);
-            break;
-        case 'liquidity':
-            handleLiquidityKey(ch, isUp, isDown, isEsc, state, screen, scheduleRender);
-            break;
-        case 'whatif':
-            handleWhatifKey(ch, isUp, isDown, isEnter, isEsc, state, screen, scheduleRender);
-            break;
-        case 'trade':
-            handleTradeKey(ch, isUp, isDown, isEnter, isEsc, state, screen, scheduleRender);
-            break;
-    }
-}
-function handleOverviewKey(ch, isUp, isDown, isEnter, state, screen, scheduleRender, cleanup) {
-    const list = state.focusArea === 'positions' ? state.positions : state.edges;
-    const maxIdx = Math.max(0, list.length - 1);
-    if (ch === 'j' || isDown) {
-        state.selectedIndex = Math.min(state.selectedIndex + 1, maxIdx);
-        scheduleRender();
-    }
-    else if (ch === 'k' || isUp) {
-        state.selectedIndex = Math.max(state.selectedIndex - 1, 0);
-        scheduleRender();
-    }
-    else if (ch === '\t') {
-        state.focusArea = state.focusArea === 'positions' ? 'edges' : 'positions';
-        state.selectedIndex = 0;
-        scheduleRender();
-    }
-    else if (isEnter) {
-        if (state.focusArea === 'positions' && state.positions.length > 0) {
-            const pos = state.positions[state.selectedIndex];
-            state.detailTicker = pos?.ticker || null;
-            state.prevMode = 'overview';
-            state.mode = 'detail';
-            scheduleRender();
-        }
-    }
-    else if (ch === 'l') {
-        state.prevMode = 'overview';
-        state.mode = 'liquidity';
-        state.liquiditySelectedIndex = 0;
-        loadLiquidityData(state).then(scheduleRender);
-    }
-    else if (ch === 'w') {
-        if (state.theses.length > 0) {
-            state.prevMode = 'overview';
-            state.mode = 'whatif';
-            state.whatifThesisId = state.theses[0].id;
-            loadWhatifData(state).then(scheduleRender);
-        }
-    }
-    else if (ch === 'b') {
-        openTrade(state, 'buy');
-        scheduleRender();
-    }
-    else if (ch === 's') {
-        openTrade(state, 'sell');
-        scheduleRender();
-    }
-    else if (ch === 'e') {
-        triggerEvaluate(state).then(scheduleRender);
-    }
-    else if (ch === 'r') {
-        (0, cache_js_1.invalidateAll)();
-        loadAllData(state).then(scheduleRender);
-    }
-}
-function handleDetailKey(ch, isEsc, state, screen, scheduleRender) {
-    if (isEsc) {
-        state.mode = 'overview';
-        scheduleRender();
-    }
-    else if (ch === 'b') {
-        openTrade(state, 'buy');
-        scheduleRender();
-    }
-    else if (ch === 's') {
-        openTrade(state, 'sell');
-        scheduleRender();
-    }
-    else if (ch === 'w') {
-        if (state.theses.length > 0) {
-            state.prevMode = 'detail';
-            state.mode = 'whatif';
-            state.whatifThesisId = state.theses[0].id;
-            loadWhatifData(state).then(scheduleRender);
-        }
-    }
-}
-function handleLiquidityKey(ch, isUp, isDown, isEsc, state, screen, scheduleRender) {
-    if (isEsc) {
-        state.mode = state.prevMode;
-        scheduleRender();
-    }
-    else if (ch === 'j' || isDown) {
-        state.liquiditySelectedIndex++;
-        scheduleRender();
-    }
-    else if (ch === 'k' || isUp) {
-        state.liquiditySelectedIndex = Math.max(0, state.liquiditySelectedIndex - 1);
-        scheduleRender();
-    }
-    else if (ch === '\t') {
-        // Cycle to next topic
-        const topics = Object.keys(topics_js_1.TOPIC_SERIES);
-        const idx = topics.indexOf(state.liquidityTopic);
-        state.liquidityTopic = topics[(idx + 1) % topics.length];
-        state.liquiditySelectedIndex = 0;
-        loadLiquidityData(state).then(scheduleRender);
-    }
-    else if (ch === 'b') {
-        openTradeFromLiquidity(state);
-        scheduleRender();
-    }
-    else if (ch === 'r') {
-        loadLiquidityData(state).then(scheduleRender);
-    }
-}
-function handleWhatifKey(ch, isUp, isDown, isEnter, isEsc, state, screen, scheduleRender) {
-    if (isEsc) {
-        state.mode = state.prevMode;
-        scheduleRender();
-    }
-    else if (ch === 'j' || isDown) {
-        const max = (state.whatifResult?.scenarios?.length || 1) - 1;
-        state.whatifScenarioIndex = Math.min(state.whatifScenarioIndex + 1, max);
-        scheduleRender();
-    }
-    else if (ch === 'k' || isUp) {
-        state.whatifScenarioIndex = Math.max(0, state.whatifScenarioIndex - 1);
-        scheduleRender();
-    }
-    else if (isEnter) {
-        // Apply scenario — could trigger re-evaluation
-        scheduleRender();
-    }
-}
-function handleTradeKey(ch, isUp, isDown, isEnter, isEsc, state, screen, scheduleRender) {
-    if (isEsc) {
-        state.mode = state.prevMode;
-        state.tradeParams = null;
-        state.tradeCountdown = -1;
-        scheduleRender();
-        return;
-    }
-    if (!state.tradeParams)
-        return;
-    if (ch === '\t') {
-        state.tradeField = state.tradeField === 'qty' ? 'price' : 'qty';
-        scheduleRender();
-    }
-    else if (isUp) {
-        if (state.tradeField === 'qty') {
-            state.tradeParams.qty = Math.min(state.tradeParams.qty + 1, 9999);
-        }
-        else {
-            state.tradeParams.price = Math.min(state.tradeParams.price + 1, 99);
-        }
-        scheduleRender();
-    }
-    else if (isDown) {
-        if (state.tradeField === 'qty') {
-            state.tradeParams.qty = Math.max(state.tradeParams.qty - 1, 1);
-        }
-        else {
-            state.tradeParams.price = Math.max(state.tradeParams.price - 1, 1);
-        }
-        scheduleRender();
-    }
-    else if (isEnter) {
-        if (state.tradeCountdown < 0) {
-            // Start countdown
-            state.tradeCountdown = 3;
-            scheduleRender();
-            startCountdown(state, screen, scheduleRender);
-        }
-    }
-}
-function startCountdown(state, screen, scheduleRender) {
-    const tick = () => {
-        if (state.tradeCountdown <= 0 || state.mode !== 'trade')
-            return;
-        state.tradeCountdown--;
-        scheduleRender();
-        if (state.tradeCountdown === 0) {
-            // Execute trade
-            executeTrade(state, scheduleRender);
-        }
-        else {
-            setTimeout(tick, 1000);
-        }
-    };
-    setTimeout(tick, 1000);
-}
-// ============================================================================
-// TRADE HELPERS
-// ============================================================================
-function openTrade(state, action) {
-    let ticker = '';
-    if (state.focusArea === 'positions' && state.positions.length > 0) {
-        const pos = state.positions[state.selectedIndex];
-        ticker = pos?.ticker_symbol || pos?.ticker || '';
-    }
-    else if (state.focusArea === 'edges' && state.edges.length > 0) {
-        const edge = state.edges[state.selectedIndex];
-        ticker = edge?.ticker || edge?.marketId || '';
-    }
-    else if (state.detailTicker) {
-        ticker = state.detailTicker;
-    }
-    if (!ticker) {
-        state.error = 'No market selected';
-        return;
-    }
-    state.prevMode = state.mode;
-    state.mode = 'trade';
-    state.tradeParams = {
-        ticker,
-        side: 'yes',
-        action,
-        qty: 10,
-        price: 50,
-    };
-    state.tradeCountdown = -1;
-    state.tradeField = 'qty';
-}
-function openTradeFromLiquidity(state) {
-    const markets = state.liquidityData.get(state.liquidityTopic) || [];
-    if (markets.length === 0)
-        return;
-    const sel = markets[Math.min(state.liquiditySelectedIndex, markets.length - 1)];
-    if (!sel)
-        return;
-    state.prevMode = state.mode;
-    state.mode = 'trade';
-    state.tradeParams = {
-        ticker: sel.ticker || '',
-        side: 'yes',
-        action: 'buy',
-        qty: 10,
-        price: sel.bestAsk ?? sel.yes_ask ?? 50,
-    };
-    state.tradeCountdown = -1;
-    state.tradeField = 'qty';
-}
-async function executeTrade(state, scheduleRender) {
-    if (!state.tradeParams)
-        return;
-    try {
-        const config = (0, config_js_1.loadConfig)();
-        if (!config.tradingEnabled) {
-            state.error = 'Trading disabled. Run: sf setup --enable-trading';
-            state.tradeCountdown = -1;
-            scheduleRender();
-            return;
-        }
-        await (0, kalshi_js_1.createOrder)({
-            ticker: state.tradeParams.ticker,
-            side: state.tradeParams.side,
-            action: state.tradeParams.action,
-            type: 'limit',
-            count: state.tradeParams.qty,
-            yes_price: state.tradeParams.price,
-        });
-        state.error = null;
-        state.mode = state.prevMode;
-        state.tradeParams = null;
-        state.tradeCountdown = -1;
-        // Refresh orders
-        (0, cache_js_1.invalidateAll)();
-        await loadAllData(state);
-    }
-    catch (err) {
-        state.error = err instanceof Error ? err.message.slice(0, 40) : 'Trade failed';
-        state.tradeCountdown = -1;
-    }
-    scheduleRender();
-}
-// ============================================================================
-// SECONDARY DATA LOADING
-// ============================================================================
-async function loadLiquidityData(state) {
-    const topic = state.liquidityTopic;
-    const seriesList = topics_js_1.TOPIC_SERIES[topic];
-    if (!seriesList)
-        return;
-    try {
-        // Phase 1: Fetch market lists in parallel (fast — just metadata)
-        const seriesResults = await Promise.allSettled(seriesList.map(series => (0, cache_js_1.cached)(`liq:${series}`, 30_000, async () => {
-            const url = `https://api.elections.kalshi.com/trade-api/v2/markets?series_ticker=${series}&status=open&limit=200`;
-            const res = await fetch(url, { headers: { Accept: 'application/json' } });
-            if (!res.ok)
-                return [];
-            const data = await res.json();
-            return data.markets || [];
-        })));
-        const allMarkets = [];
-        for (const r of seriesResults) {
-            if (r.status === 'fulfilled' && Array.isArray(r.value)) {
-                allMarkets.push(...r.value);
-            }
-        }
-        // Show markets immediately (before orderbooks load)
-        state.liquidityData.set(topic, [...allMarkets]);
-        // Phase 2: Fetch orderbooks in parallel batches of 8
-        const BATCH = 8;
-        for (let i = 0; i < allMarkets.length; i += BATCH) {
-            const batch = allMarkets.slice(i, i + BATCH);
-            const obResults = await Promise.allSettled(batch.map(mkt => (0, cache_js_1.cached)(`ob:${mkt.ticker}`, 30_000, () => (0, kalshi_js_1.getPublicOrderbook)(mkt.ticker))
-                .then(ob => ({ mkt, ob }))));
-            for (const r of obResults) {
-                if (r.status !== 'fulfilled' || !r.value.ob)
-                    continue;
-                const { mkt, ob } = r.value;
-                const yes = (ob.yes_dollars || []).map((l) => ({
-                    price: Math.round(parseFloat(l[0]) * 100),
-                    qty: parseFloat(l[1]),
-                })).filter((l) => l.price > 0).sort((a, b) => b.price - a.price);
-                const no = (ob.no_dollars || []).map((l) => ({
-                    price: Math.round(parseFloat(l[0]) * 100),
-                    qty: parseFloat(l[1]),
-                })).filter((l) => l.price > 0).sort((a, b) => b.price - a.price);
-                mkt.bestBid = yes.length > 0 ? yes[0].price : 0;
-                mkt.bestAsk = no.length > 0 ? (100 - no[0].price) : 100;
-                mkt.spread = mkt.bestAsk - mkt.bestBid;
-                mkt.totalDepth = yes.slice(0, 3).reduce((s, l) => s + l.qty, 0)
-                    + no.slice(0, 3).reduce((s, l) => s + l.qty, 0);
-            }
-            // Progressive update: refresh display after each batch
-            state.liquidityData.set(topic, [...allMarkets]);
-        }
-    }
-    catch (err) {
-        state.error = 'Failed to load liquidity data';
-    }
-}
-async function loadWhatifData(state) {
-    const client = getClient();
-    if (!client || !state.whatifThesisId)
-        return;
-    try {
-        const ctx = state.contexts.get(state.whatifThesisId);
-        if (!ctx)
-            return;
-        // Build scenario list from causal tree nodes
-        const nodes = ctx.causalTree?.nodes || ctx.nodes || [];
-        const scenarios = nodes.slice(0, 10).map((n) => ({
-            name: n.name || n.title || n.id,
-            nodeId: n.id,
-            description: `Set ${n.name || n.id} to low probability`,
-        }));
-        state.whatifResult = {
-            scenarios,
-            before: {
-                confidence: state.theses[0]?.confidence,
-                edges: state.edges.slice(0, 5),
-            },
-            after: null,
-        };
-    }
-    catch {
-        state.error = 'Failed to load what-if data';
-    }
-}
-async function triggerEvaluate(state) {
-    const client = getClient();
-    if (!client || state.theses.length === 0)
-        return;
-    try {
-        state.error = null;
-        const thesis = state.theses[0];
-        await client.evaluate(thesis.id);
-        // Refresh after evaluation
-        (0, cache_js_1.invalidateAll)();
-        await loadAllData(state);
-    }
-    catch (err) {
-        state.error = err instanceof Error ? err.message.slice(0, 40) : 'Evaluation failed';
-    }
-}
-// ============================================================================
-// MAIN LOOP
-// ============================================================================
-async function startDashboard() {
-    const screen = new screen_js_1.ScreenBuffer();
-    const state = (0, state_js_1.initialState)();
-    // Enter alternate screen, hide cursor
-    process.stdout.write('\x1b[?1049h');
-    process.stdout.write('\x1b[?25l');
-    // Enable raw mode
-    if (process.stdin.isTTY) {
-        process.stdin.setRawMode(true);
-    }
-    process.stdin.resume();
-    let renderQueued = false;
-    const scheduleRender = () => {
-        if (renderQueued)
-            return;
-        renderQueued = true;
-        setImmediate(() => {
-            renderQueued = false;
-            renderFrame(screen, state);
-        });
-    };
-    // Cleanup function
-    const intervals = [];
-    let cleaned = false;
-    const cleanup = () => {
-        if (cleaned)
-            return;
-        cleaned = true;
-        for (const iv of intervals)
-            clearInterval(iv);
-        // Restore terminal
-        process.stdout.write('\x1b[?1049l'); // Exit alternate screen
-        process.stdout.write('\x1b[?25h'); // Show cursor
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(false);
-        }
-        process.stdin.pause();
-        process.exit(0);
-    };
-    // Handle signals
-    process.on('SIGINT', cleanup);
-    process.on('SIGTERM', cleanup);
-    // Load initial data
-    try {
-        await loadAllData(state);
-    }
-    catch (err) {
-        state.error = err instanceof Error ? err.message.slice(0, 50) : 'Failed to load data';
-    }
-    // First render
-    renderFrame(screen, state);
-    // Set up refresh intervals
-    intervals.push(setInterval(async () => {
-        try {
-            const positions = await (0, cache_js_1.cached)('positions', REFRESH_POSITIONS, () => (0, kalshi_js_1.getPositions)());
-            if (positions) {
-                const priceResults = await Promise.allSettled(positions.map(p => (0, cache_js_1.cached)(`price:${p.ticker}`, 10_000, () => (0, kalshi_js_1.getMarketPrice)(p.ticker))));
-                for (let i = 0; i < positions.length; i++) {
-                    const pr = priceResults[i];
-                    if (pr.status === 'fulfilled' && pr.value != null) {
-                        positions[i].current_value = pr.value;
-                    }
-                }
-                state.positions = positions;
-                computeEdges(state);
-            }
-            scheduleRender();
-        }
-        catch { /* ignore */ }
-    }, REFRESH_POSITIONS));
-    intervals.push(setInterval(async () => {
-        try {
-            const ordersResult = await (0, cache_js_1.cached)('orders', REFRESH_ORDERS, () => (0, kalshi_js_1.getOrders)({ status: 'resting' }));
-            if (ordersResult) {
-                state.orders = ordersResult.orders || [];
-            }
-            scheduleRender();
-        }
-        catch { /* ignore */ }
-    }, REFRESH_ORDERS));
-    intervals.push(setInterval(async () => {
-        try {
-            const balanceResult = await (0, cache_js_1.cached)('balance', REFRESH_BALANCE, () => (0, kalshi_js_1.getBalance)());
-            if (balanceResult) {
-                state.balance = balanceResult.balance ?? 0;
-            }
-            scheduleRender();
-        }
-        catch { /* ignore */ }
-    }, REFRESH_BALANCE));
-    intervals.push(setInterval(async () => {
-        try {
-            await loadCandles(state);
-            scheduleRender();
-        }
-        catch { /* ignore */ }
-    }, REFRESH_CANDLES));
-    // Keypress handler
-    process.stdin.on('data', (key) => {
-        handleKeypress(state, key, screen, scheduleRender, cleanup);
-    });
-    // Resize handler
-    process.stdout.on('resize', () => {
-        screen.resize();
-        scheduleRender();
-    });
-}