@spfunctions/cli 1.4.4 → 1.4.5

package/dist/tui/dashboard.js

@@ -0,0 +1,779 @@
+"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");
+// 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;
+    }
+    // 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 {
+        // Fetch markets for each series in the topic
+        const allMarkets = [];
+        for (const series of seriesList) {
+            const markets = await (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 || [];
+            });
+            // Enrich with orderbook data
+            for (const mkt of markets) {
+                const ob = await (0, cache_js_1.cached)(`ob:${mkt.ticker}`, 30_000, () => (0, kalshi_js_1.getPublicOrderbook)(mkt.ticker));
+                if (ob) {
+                    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);
+                }
+                allMarkets.push(mkt);
+            }
+        }
+        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();
+    });
+}