@spfunctions/cli 1.1.2 → 1.1.4

package/dist/commands/agent.js

@@ -405,6 +405,7 @@ async function agentCommand(thesisId, opts) {
         { name: 'compact', description: 'Compress conversation history' },
         { name: 'new', description: 'Start fresh session' },
         { name: 'model', description: 'Switch model (e.g. /model anthropic/claude-sonnet-4)' },
+        { name: 'env', description: 'Show environment variable status' },
         { name: 'clear', description: 'Clear screen (keeps history)' },
         { name: 'exit', description: 'Exit agent (auto-saves)' },
     ], process.cwd());
@@ -451,6 +452,9 @@ async function agentCommand(thesisId, opts) {
         series: Type.Optional(Type.String({ description: 'Kalshi series ticker (e.g. KXWTIMAX)' })),
         market: Type.Optional(Type.String({ description: 'Specific market ticker' })),
     });
+    const webSearchParams = Type.Object({
+        query: Type.String({ description: 'Search keywords' }),
+    });
     const emptyParams = Type.Object({});
     const tools = [
         {
@@ -502,7 +506,7 @@ async function agentCommand(thesisId, opts) {
         {
             name: 'scan_markets',
             label: 'Scan Markets',
-            description: 'Search Kalshi prediction markets: by keywords, series ticker, or specific market ticker',
+            description: 'Search Kalshi prediction markets. Provide exactly one of: query (keyword search), series (series ticker), or market (specific ticker). If multiple are provided, priority is: market > series > query.',
             parameters: scanParams,
             execute: async (_toolCallId, params) => {
                 let result;
@@ -516,7 +520,7 @@ async function agentCommand(thesisId, opts) {
                     const series = await (0, client_js_1.kalshiFetchAllSeries)();
                     const keywords = params.query.toLowerCase().split(/\s+/);
                     const matched = series
-                        .filter((s) => keywords.some((kw) => (s.title || '').toLowerCase().includes(kw) ||
+                        .filter((s) => keywords.every((kw) => (s.title || '').toLowerCase().includes(kw) ||
                         (s.ticker || '').toLowerCase().includes(kw)))
                         .slice(0, 15);
                     result = matched;
@@ -570,6 +574,45 @@ async function agentCommand(thesisId, opts) {
                 };
             },
         },
+        {
+            name: 'web_search',
+            label: 'Web Search',
+            description: 'Search latest news and information. Use for real-time info not yet covered by the causal tree or heartbeat engine.',
+            parameters: webSearchParams,
+            execute: async (_toolCallId, params) => {
+                const apiKey = process.env.TAVILY_API_KEY;
+                if (!apiKey) {
+                    return {
+                        content: [{ type: 'text', text: 'Tavily not configured. Set TAVILY_API_KEY to enable web search. You can also manually inject a signal and let the heartbeat engine search.' }],
+                        details: {},
+                    };
+                }
+                const res = await fetch('https://api.tavily.com/search', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        api_key: apiKey,
+                        query: params.query,
+                        max_results: 5,
+                        search_depth: 'basic',
+                        include_answer: true,
+                    }),
+                });
+                if (!res.ok) {
+                    return {
+                        content: [{ type: 'text', text: `Search failed: ${res.status}` }],
+                        details: {},
+                    };
+                }
+                const data = await res.json();
+                const results = (data.results || []).map((r) => `[${r.title}](${r.url})\n${r.content?.slice(0, 200)}`).join('\n\n');
+                const answer = data.answer ? `Summary: ${data.answer}\n\n---\n\n` : '';
+                return {
+                    content: [{ type: 'text', text: `${answer}${results}` }],
+                    details: {},
+                };
+            },
+        },
     ];
     // ── System prompt builder ──────────────────────────────────────────────────
     function buildSystemPrompt(ctx) {
@@ -604,9 +647,11 @@ Short-term markets (weekly/monthly contracts) settle into hard data that calibra
 - If the user says "note this" or mentions a news event, inject a signal. Don't ask "should I note this?"
 - If the user says "evaluate" or "run it", trigger immediately. Don't confirm.
 - Don't end every response with "anything else?" \u2014 the user will ask when they want to.
+- If the user asks about latest news or real-time events, use web_search first, then answer based on results. If you find important information, suggest injecting it as a signal.
 - If you notice an edge narrowing or disappearing, say so proactively. Don't only report good news.
 - If a causal tree node probability seriously contradicts the market price, point it out.
 - Use Chinese if the user writes in Chinese, English if they write in English.
+- For any question about prices, positions, or P&L, ALWAYS call a tool to get fresh data first. Never answer price-related questions using the cached data in this system prompt.
 - Align tables. Be precise with numbers to the cent.
 
 ## Current thesis state
@@ -784,6 +829,7 @@ ${ctx.lastEvaluation?.summary ? `Latest evaluation summary: ${ctx.lastEvaluation
                     C.emerald('/compact   ') + C.zinc400('Compress conversation history') + '\n' +
                     C.emerald('/new       ') + C.zinc400('Start fresh session') + '\n' +
                     C.emerald('/model <m> ') + C.zinc400('Switch model') + '\n' +
+                    C.emerald('/env       ') + C.zinc400('Show environment variable status') + '\n' +
                     C.emerald('/clear     ') + C.zinc400('Clear screen (keeps history)') + '\n' +
                     C.emerald('/exit      ') + C.zinc400('Exit (auto-saves)'));
                 addSpacer();
@@ -891,6 +937,10 @@ ${ctx.lastEvaluation?.summary ? `Latest evaluation summary: ${ctx.lastEvaluation
                     const newSysPrompt = buildSystemPrompt(newContext);
                     const newConf = typeof newContext.confidence === 'number'
                         ? Math.round(newContext.confidence * 100) : 0;
+                    // CRITICAL: Always clearMessages() first to reset agent internal state.
+                    // replaceMessages() on a mid-conversation agent corrupts pi-agent-core's
+                    // state machine, causing the TUI to freeze.
+                    agent.clearMessages();
                     // Load saved session or start fresh
                     const saved = loadSession(resolvedThesisId);
                     if (saved?.messages?.length > 0) {
@@ -899,7 +949,6 @@ ${ctx.lastEvaluation?.summary ? `Latest evaluation summary: ${ctx.lastEvaluation
                         addSystemText(C.emerald(`Switched to ${resolvedThesisId.slice(0, 8)}`) + C.zinc400(` (resumed ${saved.messages.length} messages)`));
                     }
                     else {
-                        agent.clearMessages();
                         agent.setSystemPrompt(newSysPrompt);
                         addSystemText(C.emerald(`Switched to ${resolvedThesisId.slice(0, 8)}`) + C.zinc400(' (new session)'));
                     }
@@ -916,42 +965,168 @@ ${ctx.lastEvaluation?.summary ? `Latest evaluation summary: ${ctx.lastEvaluation
                     addSystemText(C.red(`Switch failed: ${err.message}`));
                 }
                 addSpacer();
+                // Force re-focus editor so input stays responsive
+                tui.setFocus(editor);
                 tui.requestRender();
                 return true;
             }
             case '/compact': {
                 addSpacer();
-                const msgs = agent.state.messages;
-                if (msgs.length <= 10) {
-                    addSystemText(C.zinc400('Conversation too short to compact'));
-                    addSpacer();
-                    return true;
-                }
-                // Keep recent 6 messages (3 turns) + create summary of the rest
-                const recentCount = 6;
-                const toCompress = msgs.slice(0, -recentCount);
-                const toKeep = msgs.slice(-recentCount);
-                // Extract text for summary (no LLM, just bullet points)
-                const bulletPoints = [];
-                for (const m of toCompress) {
-                    const content = typeof m.content === 'string' ? m.content : '';
-                    if (m.role === 'user' && content) {
-                        bulletPoints.push(`- User: ${content.slice(0, 100)}`);
+                try {
+                    const msgs = agent.state.messages;
+                    if (msgs.length <= 10) {
+                        addSystemText(C.zinc400('Conversation too short to compact'));
+                        addSpacer();
+                        tui.setFocus(editor);
+                        return true;
+                    }
+                    // ── Find clean cut point ──────────────────────────────────────
+                    // Walk backwards counting user messages as turn starts.
+                    // Keep 3 complete turns. Never split a tool_call/tool_result pair.
+                    const turnsToKeep = 3;
+                    let turnsSeen = 0;
+                    let cutIndex = msgs.length;
+                    for (let i = msgs.length - 1; i >= 0; i--) {
+                        if (msgs[i].role === 'user') {
+                            turnsSeen++;
+                            if (turnsSeen >= turnsToKeep) {
+                                cutIndex = i;
+                                break;
+                            }
+                        }
+                    }
+                    if (cutIndex <= 2) {
+                        addSystemText(C.zinc400('Not enough complete turns to compact'));
+                        addSpacer();
+                        tui.setFocus(editor);
+                        return true;
+                    }
+                    const toCompress = msgs.slice(0, cutIndex);
+                    const toKeep = msgs.slice(cutIndex);
+                    // ── Show loader ───────────────────────────────────────────────
+                    const compactLoader = new Loader(tui, (s) => C.emerald(s), (s) => C.zinc600(s), 'compacting with LLM...');
+                    compactLoader.start();
+                    chatContainer.addChild(compactLoader);
+                    tui.requestRender();
+                    // ── Serialize messages for the summarizer ─────────────────────
+                    // Strip tool results to raw text, cap total length to ~12k chars
+                    const serialized = [];
+                    let totalLen = 0;
+                    const MAX_CHARS = 12000;
+                    for (const m of toCompress) {
+                        if (totalLen >= MAX_CHARS)
+                            break;
+                        let text = '';
+                        if (typeof m.content === 'string') {
+                            text = m.content;
+                        }
+                        else if (Array.isArray(m.content)) {
+                            // OpenAI format: content blocks
+                            text = m.content
+                                .filter((b) => b.type === 'text')
+                                .map((b) => b.text)
+                                .join('\n');
+                        }
+                        if (!text)
+                            continue;
+                        const role = (m.role || 'unknown').toUpperCase();
+                        const truncated = text.slice(0, 800);
+                        const line = `[${role}]: ${truncated}`;
+                        serialized.push(line);
+                        totalLen += line.length;
+                    }
+                    const conversationDump = serialized.join('\n\n');
+                    // ── Call OpenRouter for LLM summary ───────────────────────────
+                    // Use a cheap/fast model — gemini flash
+                    const summaryModel = 'google/gemini-2.0-flash-001';
+                    const summarySystemPrompt = `You are a conversation compressor. Given a conversation between a user and a prediction-market trading assistant, produce a dense summary that preserves:
+1. All factual conclusions, numbers, prices, and probabilities mentioned
+2. Key trading decisions, positions taken or discussed
+3. Signals injected, evaluations triggered, and their outcomes
+4. Any action items or pending questions
+
+Output a structured summary. Be concise but preserve every important detail — this summary replaces the original messages for continued conversation. Do NOT add commentary or meta-text. Just the summary.`;
+                    let summaryText;
+                    try {
+                        const orRes = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                                'Authorization': `Bearer ${openrouterKey}`,
+                                'HTTP-Referer': 'https://simplefunctions.com',
+                                'X-Title': 'SF Agent Compact',
+                            },
+                            body: JSON.stringify({
+                                model: summaryModel,
+                                messages: [
+                                    { role: 'system', content: summarySystemPrompt },
+                                    { role: 'user', content: `Summarize this conversation (${toCompress.length} messages):\n\n${conversationDump}` },
+                                ],
+                                max_tokens: 2000,
+                                temperature: 0.2,
+                            }),
+                        });
+                        if (!orRes.ok) {
+                            const errText = await orRes.text().catch(() => '');
+                            throw new Error(`OpenRouter ${orRes.status}: ${errText.slice(0, 200)}`);
+                        }
+                        const orData = await orRes.json();
+                        summaryText = orData.choices?.[0]?.message?.content || '';
+                        if (!summaryText) {
+                            throw new Error('Empty summary from LLM');
+                        }
                     }
-                    else if (m.role === 'assistant' && content) {
-                        bulletPoints.push(`- Assistant: ${content.slice(0, 150)}`);
+                    catch (llmErr) {
+                        // LLM failed — fall back to bullet-point extraction
+                        const bulletPoints = [];
+                        for (const m of toCompress) {
+                            const content = typeof m.content === 'string' ? m.content : '';
+                            if (m.role === 'user' && content) {
+                                bulletPoints.push(`- User: ${content.slice(0, 100)}`);
+                            }
+                            else if (m.role === 'assistant' && content) {
+                                bulletPoints.push(`- Assistant: ${content.slice(0, 150)}`);
+                            }
+                        }
+                        summaryText = `[LLM summary failed: ${llmErr.message}. Fallback bullet points:]\n\n${bulletPoints.slice(-20).join('\n')}`;
                     }
+                    // ── Remove loader ─────────────────────────────────────────────
+                    compactLoader.stop();
+                    chatContainer.removeChild(compactLoader);
+                    // ── Build compacted message array ──────────────────────────────
+                    // user(summary) → assistant(ack) → ...toKeep
+                    // This maintains valid user→assistant alternation.
+                    // toKeep starts with a user message (guaranteed by our cut logic).
+                    const compactedMessages = [
+                        {
+                            role: 'user',
+                            content: `[Conversation summary — ${toCompress.length} messages compressed]\n\n${summaryText}`,
+                        },
+                        {
+                            role: 'assistant',
+                            content: 'Understood. I have the full conversation context from the summary above. Continuing from where we left off.',
+                        },
+                        ...toKeep,
+                    ];
+                    // ── Replace agent state ───────────────────────────────────────
+                    // Clear first to reset internal state, then load compacted messages
+                    agent.clearMessages();
+                    agent.replaceMessages(compactedMessages);
+                    agent.setSystemPrompt(systemPrompt);
+                    persistSession();
+                    addSystemText(C.emerald(`Compacted: ${toCompress.length} messages \u2192 summary + ${toKeep.length} recent`) +
+                        C.zinc600(` (via ${summaryModel.split('/').pop()})`));
+                    addSpacer();
+                    // Force re-focus and render so editor stays responsive
+                    tui.setFocus(editor);
+                    tui.requestRender();
+                }
+                catch (err) {
+                    addSystemText(C.red(`Compact failed: ${err.message || err}`));
+                    addSpacer();
+                    tui.setFocus(editor);
+                    tui.requestRender();
                 }
-                const summary = bulletPoints.slice(-20).join('\n');
-                // Replace messages: summary + recent
-                const compactedMessages = [
-                    { role: 'assistant', content: `[Conversation summary - ${toCompress.length} messages compressed]\n${summary}` },
-                    ...toKeep,
-                ];
-                agent.replaceMessages(compactedMessages);
-                persistSession();
-                addSystemText(C.emerald(`Compacted: ${toCompress.length} messages \u2192 summary + ${toKeep.length} recent`));
-                addSpacer();
                 return true;
             }
             case '/new': {
@@ -965,6 +1140,33 @@ ${ctx.lastEvaluation?.summary ? `Latest evaluation summary: ${ctx.lastEvaluation
                 tui.requestRender();
                 return true;
             }
+            case '/env': {
+                addSpacer();
+                const envVars = [
+                    { name: 'SF_API_KEY', key: 'SF_API_KEY', required: true, mask: true },
+                    { name: 'SF_API_URL', key: 'SF_API_URL', required: false, mask: false },
+                    { name: 'OPENROUTER_KEY', key: 'OPENROUTER_API_KEY', required: true, mask: true },
+                    { name: 'KALSHI_KEY_ID', key: 'KALSHI_API_KEY_ID', required: false, mask: true },
+                    { name: 'KALSHI_PEM_PATH', key: 'KALSHI_PRIVATE_KEY_PATH', required: false, mask: false },
+                    { name: 'TAVILY_API_KEY', key: 'TAVILY_API_KEY', required: false, mask: true },
+                ];
+                const lines = envVars.map(v => {
+                    const val = process.env[v.key];
+                    if (val) {
+                        const display = v.mask
+                            ? val.slice(0, Math.min(8, val.length)) + '...' + val.slice(-4)
+                            : val;
+                        return `  ${v.name.padEnd(18)} ${C.emerald('\u2713')} ${C.zinc400(display)}`;
+                    }
+                    else {
+                        const note = v.required ? '\u5FC5\u987B' : '\u53EF\u9009';
+                        return `  ${v.name.padEnd(18)} ${C.red('\u2717')} ${C.zinc600(`\u672A\u914D\u7F6E\uFF08${note}\uFF09`)}`;
+                    }
+                });
+                addSystemText(C.zinc200(bold('Environment')) + '\n' + lines.join('\n'));
+                addSpacer();
+                return true;
+            }
             case '/clear': {
                 chatContainer.clear();
                 tui.requestRender();

package/dist/commands/edges.d.ts

@@ -0,0 +1,21 @@
+/**
+ * sf edges — Top edges across all active theses
+ *
+ * The most important output of the entire system: "what to trade now."
+ *
+ * Flow:
+ * 1. GET /api/thesis → all active theses
+ * 2. For each: GET /api/thesis/:id/context → edges with orderbook
+ * 3. Optional: getPositions() → Kalshi positions with live prices
+ * 4. Merge edges, dedupe by marketId (keep highest edge, note source thesis)
+ * 5. Sort by executableEdge descending
+ * 6. Display table with position overlay + summary
+ */
+interface EdgesOpts {
+    json?: boolean;
+    limit?: string;
+    apiKey?: string;
+    apiUrl?: string;
+}
+export declare function edgesCommand(opts: EdgesOpts): Promise<void>;
+export {};

package/dist/commands/edges.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * sf edges — Top edges across all active theses
+ *
+ * The most important output of the entire system: "what to trade now."
+ *
+ * Flow:
+ * 1. GET /api/thesis → all active theses
+ * 2. For each: GET /api/thesis/:id/context → edges with orderbook
+ * 3. Optional: getPositions() → Kalshi positions with live prices
+ * 4. Merge edges, dedupe by marketId (keep highest edge, note source thesis)
+ * 5. Sort by executableEdge descending
+ * 6. Display table with position overlay + summary
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.edgesCommand = edgesCommand;
+const client_js_1 = require("../client.js");
+const kalshi_js_1 = require("../kalshi.js");
+const utils_js_1 = require("../utils.js");
+async function edgesCommand(opts) {
+    const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
+    const limit = parseInt(opts.limit || '20');
+    // ── Step 1: Fetch all active theses ────────────────────────────────────────
+    console.log(`${utils_js_1.c.dim}Fetching theses...${utils_js_1.c.reset}`);
+    const data = await client.listTheses();
+    const rawTheses = data.theses || data;
+    const theses = (Array.isArray(rawTheses) ? rawTheses : []).filter((t) => t.status === 'active');
+    if (theses.length === 0) {
+        console.log(`${utils_js_1.c.yellow}No active theses found.${utils_js_1.c.reset} Create one: sf create "your thesis"`);
+        return;
+    }
+    // ── Step 2: Fetch context for each thesis (parallel) ───────────────────────
+    console.log(`${utils_js_1.c.dim}Fetching edges from ${theses.length} theses...${utils_js_1.c.reset}`);
+    const allEdges = [];
+    const contextPromises = theses.map(async (t) => {
+        try {
+            const ctx = await client.getContext(t.id);
+            return { thesisId: t.id, edges: ctx.edges || [] };
+        }
+        catch {
+            return { thesisId: t.id, edges: [] };
+        }
+    });
+    const results = await Promise.all(contextPromises);
+    for (const { thesisId, edges } of results) {
+        for (const e of edges) {
+            allEdges.push({
+                marketId: e.marketId || '',
+                market: e.market || e.marketTitle || e.marketId || '',
+                venue: e.venue || 'kalshi',
+                direction: e.direction || 'yes',
+                marketPrice: typeof e.marketPrice === 'number' ? e.marketPrice : 0,
+                thesisPrice: typeof e.thesisPrice === 'number' ? e.thesisPrice : 0,
+                edge: typeof e.edge === 'number' ? e.edge : 0,
+                executableEdge: typeof e.executableEdge === 'number' ? e.executableEdge : null,
+                spread: e.orderbook?.spread ?? null,
+                liquidityScore: e.orderbook?.liquidityScore ?? null,
+                thesisId,
+                position: null,
+            });
+        }
+    }
+    if (allEdges.length === 0) {
+        console.log(`${utils_js_1.c.yellow}No edges found across ${theses.length} theses.${utils_js_1.c.reset}`);
+        return;
+    }
+    // ── Step 3: Dedupe by marketId — keep highest absolute edge ────────────────
+    const deduped = new Map();
+    for (const edge of allEdges) {
+        const key = edge.marketId;
+        if (!key)
+            continue;
+        const existing = deduped.get(key);
+        if (!existing || Math.abs(edge.edge) > Math.abs(existing.edge)) {
+            deduped.set(key, edge);
+        }
+    }
+    let merged = Array.from(deduped.values());
+    // ── Step 4: Fetch positions (optional) ─────────────────────────────────────
+    let positions = null;
+    if ((0, kalshi_js_1.isKalshiConfigured)()) {
+        console.log(`${utils_js_1.c.dim}Fetching Kalshi positions...${utils_js_1.c.reset}`);
+        positions = await (0, kalshi_js_1.getPositions)();
+        if (positions) {
+            // Enrich with live prices
+            for (const pos of positions) {
+                const livePrice = await (0, kalshi_js_1.getMarketPrice)(pos.ticker);
+                if (livePrice !== null) {
+                    pos.current_value = livePrice;
+                    pos.unrealized_pnl = Math.round((livePrice - pos.average_price_paid) * pos.quantity);
+                }
+            }
+            // Match positions to edges
+            for (const edge of merged) {
+                const pos = positions.find(p => p.ticker === edge.marketId ||
+                    (edge.marketId && p.ticker?.includes(edge.marketId)));
+                if (pos) {
+                    edge.position = {
+                        side: pos.side || 'yes',
+                        quantity: pos.quantity,
+                        avgPrice: pos.average_price_paid,
+                        currentValue: pos.current_value,
+                        pnl: pos.unrealized_pnl || 0,
+                        totalCost: pos.total_cost || Math.round(pos.average_price_paid * pos.quantity),
+                    };
+                }
+            }
+        }
+    }
+    // ── Step 5: Sort by executableEdge (or edge) descending ────────────────────
+    merged.sort((a, b) => {
+        const aVal = a.executableEdge !== null ? a.executableEdge : a.edge;
+        const bVal = b.executableEdge !== null ? b.executableEdge : b.edge;
+        return Math.abs(bVal) - Math.abs(aVal);
+    });
+    // Apply limit
+    const display = merged.slice(0, limit);
+    // ── Step 6: JSON output ────────────────────────────────────────────────────
+    if (opts.json) {
+        console.log(JSON.stringify({
+            totalEdges: merged.length,
+            displayed: display.length,
+            thesesScanned: theses.length,
+            edges: display,
+        }, null, 2));
+        return;
+    }
+    // ── Step 6: Pretty output ──────────────────────────────────────────────────
+    console.log();
+    (0, utils_js_1.header)(`Top Edges Across ${theses.length} Theses`);
+    console.log();
+    // Header row
+    const hdr = [
+        (0, utils_js_1.pad)('Market', 32),
+        (0, utils_js_1.rpad)('Mkt', 5),
+        (0, utils_js_1.rpad)('Thesis', 7),
+        (0, utils_js_1.rpad)('Edge', 6),
+        (0, utils_js_1.rpad)('Exec', 6),
+        (0, utils_js_1.rpad)('Sprd', 5),
+        (0, utils_js_1.pad)('Liq', 5),
+        (0, utils_js_1.pad)('Thesis', 10),
+        (0, utils_js_1.pad)('Position', 20),
+    ].join(' ');
+    console.log(`${utils_js_1.c.dim}${hdr}${utils_js_1.c.reset}`);
+    (0, utils_js_1.hr)(100);
+    for (const edge of display) {
+        const name = (0, utils_js_1.trunc)(edge.market, 31);
+        const mktStr = `${edge.marketPrice}¢`;
+        const thesisStr = `${edge.thesisPrice}¢`;
+        const edgeStr = edge.edge > 0 ? `+${edge.edge}` : `${edge.edge}`;
+        const execStr = edge.executableEdge !== null ? (edge.executableEdge > 0 ? `+${edge.executableEdge}` : `${edge.executableEdge}`) : '—';
+        const spreadStr = edge.spread !== null ? `${edge.spread}¢` : '—';
+        const liqStr = edge.liquidityScore || '—';
+        const thesisIdStr = (0, utils_js_1.shortId)(edge.thesisId);
+        // Color the edge values
+        const edgeColor = edge.edge > 0 ? utils_js_1.c.green : edge.edge < 0 ? utils_js_1.c.red : utils_js_1.c.dim;
+        const execColor = edge.executableEdge !== null ? (edge.executableEdge > 0 ? utils_js_1.c.green : utils_js_1.c.red) : utils_js_1.c.dim;
+        const liqColor = liqStr === 'high' ? utils_js_1.c.green : liqStr === 'medium' ? utils_js_1.c.yellow : utils_js_1.c.dim;
+        // Position string
+        let posStr = `${utils_js_1.c.dim}—${utils_js_1.c.reset}`;
+        if (edge.position) {
+            const p = edge.position;
+            const pnlStr = p.pnl >= 0 ? `${utils_js_1.c.green}+$${(p.pnl / 100).toFixed(0)}${utils_js_1.c.reset}` : `${utils_js_1.c.red}-$${(Math.abs(p.pnl) / 100).toFixed(0)}${utils_js_1.c.reset}`;
+            posStr = `${utils_js_1.c.green}${p.quantity}@${p.avgPrice}¢${utils_js_1.c.reset} ${pnlStr}`;
+        }
+        const row = [
+            edge.position ? `${utils_js_1.c.green}${(0, utils_js_1.pad)(name, 32)}${utils_js_1.c.reset}` : (0, utils_js_1.pad)(name, 32),
+            (0, utils_js_1.rpad)(mktStr, 5),
+            (0, utils_js_1.rpad)(thesisStr, 7),
+            `${edgeColor}${(0, utils_js_1.rpad)(edgeStr, 6)}${utils_js_1.c.reset}`,
+            `${execColor}${(0, utils_js_1.rpad)(execStr, 6)}${utils_js_1.c.reset}`,
+            (0, utils_js_1.rpad)(spreadStr, 5),
+            `${liqColor}${(0, utils_js_1.pad)(liqStr, 5)}${utils_js_1.c.reset}`,
+            `${utils_js_1.c.dim}${(0, utils_js_1.pad)(thesisIdStr, 10)}${utils_js_1.c.reset}`,
+            posStr,
+        ].join(' ');
+        console.log(row);
+    }
+    // ── Summary ────────────────────────────────────────────────────────────────
+    (0, utils_js_1.hr)(100);
+    // Positioned summary
+    const positioned = display.filter(e => e.position);
+    if (positioned.length > 0) {
+        let totalCost = 0;
+        let totalPnl = 0;
+        for (const e of positioned) {
+            totalCost += e.position.totalCost;
+            totalPnl += e.position.pnl;
+        }
+        const costStr = `$${(totalCost / 100).toFixed(0)}`;
+        const pnlColor = totalPnl >= 0 ? utils_js_1.c.green : utils_js_1.c.red;
+        const pnlSign = totalPnl >= 0 ? '+' : '-';
+        const pnlStr = `${pnlColor}${pnlSign}$${(Math.abs(totalPnl) / 100).toFixed(0)}${utils_js_1.c.reset}`;
+        console.log(`${utils_js_1.c.bold}Total positioned:${utils_js_1.c.reset} ${costStr} cost | P&L: ${pnlStr}`);
+    }
+    // Top unpositioned
+    const unpositioned = display.filter(e => !e.position && e.edge > 0);
+    if (unpositioned.length > 0) {
+        const top = unpositioned[0];
+        const execLabel = top.executableEdge !== null ? `exec +${top.executableEdge}` : `edge +${top.edge}`;
+        const liq = top.liquidityScore ? `, ${top.liquidityScore} liq` : '';
+        console.log(`${utils_js_1.c.bold}Top unpositioned:${utils_js_1.c.reset} ${(0, utils_js_1.trunc)(top.market, 30)} @ ${top.marketPrice}¢ (${execLabel}${liq})`);
+    }
+    console.log();
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,20 @@
+/**
+ * sf setup — Interactive configuration wizard
+ *
+ * Walks user through:
+ *   1. SF API key (required)
+ *   2. OpenRouter API key (optional, for agent)
+ *   3. Kalshi exchange credentials (optional, for positions)
+ *   4. Tavily API key (optional, for web search)
+ *   5. First thesis creation (if none exist)
+ *
+ * Each key is validated in real-time.
+ * Config is saved to ~/.sf/config.json.
+ */
+interface SetupOpts {
+    check?: boolean;
+    reset?: boolean;
+    key?: string;
+}
+export declare function setupCommand(opts: SetupOpts): Promise<void>;
+export {};