@spfunctions/cli 1.1.6 → 1.1.8

package/dist/client.d.ts

@@ -17,6 +17,8 @@ export declare class SFClient {
     createThesis(rawThesis: string, sync?: boolean): Promise<any>;
     injectSignal(id: string, type: string, content: string, source?: string): Promise<any>;
     evaluate(id: string): Promise<any>;
+    getFeed(hours?: number, limit?: number): Promise<any>;
+    getChanges(id: string, since: string): Promise<any>;
     updateThesis(id: string, data: Record<string, unknown>): Promise<any>;
     publish(id: string, slug: string, description?: string): Promise<any>;
     unpublish(id: string): Promise<any>;

package/dist/client.js

@@ -62,6 +62,12 @@ class SFClient {
     async evaluate(id) {
         return this.request('POST', `/api/thesis/${id}/evaluate`);
     }
+    async getFeed(hours = 24, limit = 200) {
+        return this.request('GET', `/api/feed?hours=${hours}&limit=${limit}`);
+    }
+    async getChanges(id, since) {
+        return this.request('GET', `/api/thesis/${id}/changes?since=${encodeURIComponent(since)}`);
+    }
     async updateThesis(id, data) {
         return this.request('PATCH', `/api/thesis/${id}`, data);
     }

package/dist/commands/agent.js

@@ -100,27 +100,53 @@ function createMutableLine(piTui) {
         }
     };
 }
-/** Header bar: [SF Agent — {id}]  [{confidence}%]  [{model}] */
+/**
+ * Header bar — trading terminal style.
+ * Shows: thesis ID, confidence+delta, positions P&L, edge count, top edge
+ */
 function createHeaderBar(piTui) {
     const { truncateToWidth, visibleWidth } = piTui;
     return class HeaderBar {
-        left;
-        center;
-        right;
+        thesisId = '';
+        confidence = 0;
+        confidenceDelta = 0;
+        pnlDollars = 0;
+        positionCount = 0;
+        edgeCount = 0;
+        topEdge = ''; // e.g. "RECESSION +21¢"
         cachedWidth;
         cachedLines;
-        constructor(left, center, right) {
-            this.left = left;
-            this.center = center;
-            this.right = right;
+        setFromContext(ctx, positions) {
+            this.thesisId = (ctx.thesisId || '').slice(0, 8);
+            this.confidence = typeof ctx.confidence === 'number'
+                ? Math.round(ctx.confidence * 100)
+                : (typeof ctx.confidence === 'string' ? Math.round(parseFloat(ctx.confidence) * 100) : 0);
+            this.confidenceDelta = ctx.lastEvaluation?.confidenceDelta
+                ? Math.round(ctx.lastEvaluation.confidenceDelta * 100)
+                : 0;
+            this.edgeCount = (ctx.edges || []).length;
+            // Top edge by absolute size
+            const edges = ctx.edges || [];
+            if (edges.length > 0) {
+                const top = [...edges].sort((a, b) => Math.abs(b.edge || b.edgeSize || 0) - Math.abs(a.edge || a.edgeSize || 0))[0];
+                const name = (top.market || top.marketTitle || top.marketId || '').slice(0, 20);
+                const edge = top.edge || top.edgeSize || 0;
+                this.topEdge = `${name} ${edge > 0 ? '+' : ''}${Math.round(edge)}\u00A2`;
+            }
+            // P&L from positions
+            if (positions && positions.length > 0) {
+                this.positionCount = positions.length;
+                this.pnlDollars = positions.reduce((sum, p) => {
+                    const pnl = p.unrealized_pnl || 0;
+                    return sum + pnl;
+                }, 0) / 100; // cents → dollars
+            }
+            this.cachedWidth = undefined;
+            this.cachedLines = undefined;
         }
-        update(left, center, right) {
-            if (left !== undefined)
-                this.left = left;
-            if (center !== undefined)
-                this.center = center;
-            if (right !== undefined)
-                this.right = right;
+        updateConfidence(newConf, delta) {
+            this.confidence = Math.round(newConf * 100);
+            this.confidenceDelta = Math.round(delta * 100);
             this.cachedWidth = undefined;
             this.cachedLines = undefined;
         }
@@ -128,23 +154,39 @@ function createHeaderBar(piTui) {
             this.cachedWidth = undefined;
             this.cachedLines = undefined;
         }
+        // Keep legacy update() for compatibility with /switch etc.
+        update(left, center, right) {
+            this.cachedWidth = undefined;
+            this.cachedLines = undefined;
+        }
         render(width) {
             if (this.cachedLines && this.cachedWidth === width)
                 return this.cachedLines;
             this.cachedWidth = width;
-            const l = this.left;
-            const c = this.center;
-            const r = this.right;
-            const lw = visibleWidth(l);
-            const cw = visibleWidth(c);
-            const rw = visibleWidth(r);
-            const totalContent = lw + cw + rw;
-            const totalPad = Math.max(0, width - totalContent);
-            const leftPad = Math.max(1, Math.floor(totalPad / 2));
-            const rightPad = Math.max(1, totalPad - leftPad);
-            let line = l + ' '.repeat(leftPad) + c + ' '.repeat(rightPad) + r;
-            line = C.bgZinc900(truncateToWidth(line, width, ''));
-            // Pad to full width for background
+            // Build segments
+            const id = C.emerald(bold(this.thesisId));
+            // Confidence with arrow
+            const arrow = this.confidenceDelta > 0 ? '\u25B2' : this.confidenceDelta < 0 ? '\u25BC' : '\u2500';
+            const arrowColor = this.confidenceDelta > 0 ? C.emerald : this.confidenceDelta < 0 ? C.red : C.zinc600;
+            const deltaStr = this.confidenceDelta !== 0 ? ` (${this.confidenceDelta > 0 ? '+' : ''}${this.confidenceDelta})` : '';
+            const conf = arrowColor(`${arrow} ${this.confidence}%${deltaStr}`);
+            // P&L
+            let pnl = '';
+            if (this.positionCount > 0) {
+                const pnlStr = this.pnlDollars >= 0
+                    ? C.emerald(`+$${this.pnlDollars.toFixed(2)}`)
+                    : C.red(`-$${Math.abs(this.pnlDollars).toFixed(2)}`);
+                pnl = C.zinc600(`${this.positionCount} pos `) + pnlStr;
+            }
+            // Edges
+            const edges = C.zinc600(`${this.edgeCount} edges`);
+            // Top edge
+            const top = this.topEdge ? C.zinc400(this.topEdge) : '';
+            // Assemble with separators
+            const sep = C.zinc600(' \u2502 ');
+            const parts = [id, conf, pnl, edges, top].filter(Boolean);
+            const content = parts.join(sep);
+            let line = C.bgZinc900(' ' + truncateToWidth(content, width - 2, '') + ' ');
             const lineVw = visibleWidth(line);
             if (lineVw < width) {
                 line = line + C.bgZinc900(' '.repeat(width - lineVw));
@@ -154,13 +196,16 @@ function createHeaderBar(piTui) {
         }
     };
 }
-/** Footer bar: [tokens: N | cost: $N | tools: N]  [/help] */
+/** Footer bar: model | tokens | exchange status | trading status | /help */
 function createFooterBar(piTui) {
     const { truncateToWidth, visibleWidth } = piTui;
     return class FooterBar {
         tokens = 0;
         cost = 0;
         toolCount = 0;
+        modelName = '';
+        tradingEnabled = false;
+        exchangeOpen = null; // null = unknown
         cachedWidth;
         cachedLines;
         invalidate() {
@@ -178,13 +223,23 @@ function createFooterBar(piTui) {
             const tokStr = this.tokens >= 1000
                 ? `${(this.tokens / 1000).toFixed(1)}k`
                 : `${this.tokens}`;
-            const leftText = C.zinc600(`tokens: ${tokStr}  cost: $${this.cost.toFixed(3)}  tools: ${this.toolCount}`);
-            const rightText = C.zinc600('/help');
+            const model = C.zinc600(this.modelName.split('/').pop() || this.modelName);
+            const tokens = C.zinc600(`${tokStr} tok`);
+            const exchange = this.exchangeOpen === true
+                ? C.emerald('OPEN')
+                : this.exchangeOpen === false
+                    ? C.red('CLOSED')
+                    : C.zinc600('...');
+            const trading = this.tradingEnabled
+                ? C.amber('\u26A1 trading')
+                : C.zinc600('\u26A1 read-only');
+            const help = C.zinc600('/help');
+            const sep = C.zinc600(' \u2502 ');
+            const leftText = [model, tokens, exchange, trading].join(sep);
             const lw = visibleWidth(leftText);
-            const rw = visibleWidth(rightText);
-            const gap = Math.max(1, width - lw - rw);
-            let line = leftText + ' '.repeat(gap) + rightText;
-            line = C.bgZinc900(truncateToWidth(line, width, ''));
+            const rw = visibleWidth(help);
+            const gap = Math.max(1, width - lw - rw - 2);
+            let line = C.bgZinc900(' ' + leftText + ' '.repeat(gap) + help + ' ');
             const lineVw = visibleWidth(line);
             if (lineVw < width) {
                 line = line + C.bgZinc900(' '.repeat(width - lineVw));
@@ -378,6 +433,13 @@ async function agentCommand(thesisId, opts) {
     let isProcessing = false;
     // Cache for positions (fetched by /pos or get_positions tool)
     let cachedPositions = null;
+    // ── Heartbeat polling state ───────────────────────────────────────────────
+    // Background poll delta endpoint every 60s.
+    // If confidence changed ≥ 3%, auto-trigger agent analysis.
+    // If agent is busy (isProcessing), queue and deliver after agent finishes.
+    let lastPollTimestamp = new Date().toISOString();
+    let pendingHeartbeatDelta = null; // queued delta when agent is busy
+    let heartbeatPollTimer = null;
     // ── Inline confirmation mechanism ─────────────────────────────────────────
     // Tools can call promptUser() during execution to ask the user a question.
     // This temporarily unlocks the editor, waits for input, then resumes.
@@ -405,9 +467,9 @@ async function agentCommand(thesisId, opts) {
     const mdDefaultStyle = {
         color: (s) => C.zinc400(s),
     };
-    // Editor theme
+    // Editor theme — use dim zinc borders instead of default green
     const editorTheme = {
-        borderColor: (s) => C.zinc800(s),
+        borderColor: (s) => `\x1b[38;2;50;50;55m${s}\x1b[39m`,
         selectList: {
             selectedPrefix: (s) => C.emerald(s),
             selectedText: (s) => C.zinc200(s),
@@ -417,12 +479,31 @@ async function agentCommand(thesisId, opts) {
         },
     };
     // ── Build components ───────────────────────────────────────────────────────
-    const shortId = (resolvedThesisId || '').slice(0, 8);
-    const confidencePct = typeof latestContext.confidence === 'number'
-        ? Math.round(latestContext.confidence * 100)
-        : (typeof latestContext.confidence === 'string' ? parseInt(latestContext.confidence) : 0);
-    const headerBar = new HeaderBar(C.emerald(bold('SF Agent')) + C.zinc600(` \u2014 ${shortId}`), confidencePct > 0 ? C.zinc200(`${confidencePct}%`) : '', C.zinc600(currentModelName.split('/').pop() || currentModelName));
+    const headerBar = new HeaderBar();
+    // Fetch positions for header P&L (non-blocking, best-effort)
+    let initialPositions = null;
+    try {
+        initialPositions = await (0, kalshi_js_1.getPositions)();
+        if (initialPositions) {
+            for (const pos of initialPositions) {
+                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);
+                }
+            }
+        }
+    }
+    catch { /* positions not available, fine */ }
+    headerBar.setFromContext(latestContext, initialPositions || undefined);
     const footerBar = new FooterBar();
+    footerBar.modelName = currentModelName;
+    footerBar.tradingEnabled = (0, config_js_1.loadConfig)().tradingEnabled || false;
+    // Fetch exchange status for footer (non-blocking)
+    fetch('https://api.elections.kalshi.com/trade-api/v2/exchange/status', { headers: { 'Accept': 'application/json' } })
+        .then(r => r.json())
+        .then(d => { footerBar.exchangeOpen = !!d.exchange_active; footerBar.update(); tui.requestRender(); })
+        .catch(() => { });
     const topSpacer = new Spacer(1);
     const bottomSpacer = new Spacer(1);
     const chatContainer = new Container();
@@ -517,11 +598,7 @@ async function agentCommand(thesisId, opts) {
             execute: async (_toolCallId, params) => {
                 const ctx = await sfClient.getContext(params.thesisId);
                 latestContext = ctx;
-                // Update header with new confidence
-                const conf = typeof ctx.confidence === 'number'
-                    ? Math.round(ctx.confidence * 100)
-                    : 0;
-                headerBar.update(undefined, conf > 0 ? C.zinc200(`${conf}%`) : '', undefined);
+                headerBar.setFromContext(ctx, initialPositions || undefined);
                 tui.requestRender();
                 return {
                     content: [{ type: 'text', text: JSON.stringify(ctx, null, 2) }],
@@ -549,6 +626,26 @@ async function agentCommand(thesisId, opts) {
             parameters: thesisIdParam,
             execute: async (_toolCallId, params) => {
                 const result = await sfClient.evaluate(params.thesisId);
+                // Show confidence change prominently
+                if (result.evaluation?.confidenceDelta && Math.abs(result.evaluation.confidenceDelta) >= 0.01) {
+                    const delta = result.evaluation.confidenceDelta;
+                    const prev = Math.round((result.evaluation.previousConfidence || 0) * 100);
+                    const now = Math.round((result.evaluation.newConfidence || 0) * 100);
+                    const arrow = delta > 0 ? '\u25B2' : '\u25BC';
+                    const color = delta > 0 ? C.emerald : C.red;
+                    addSystemText(color(`  ${arrow} Confidence ${prev}% \u2192 ${now}% (${delta > 0 ? '+' : ''}${Math.round(delta * 100)})`));
+                    addSpacer();
+                    // Update header
+                    headerBar.updateConfidence(result.evaluation.newConfidence, delta);
+                    tui.requestRender();
+                }
+                // Refresh context after eval
+                try {
+                    latestContext = await sfClient.getContext(params.thesisId);
+                    headerBar.setFromContext(latestContext, initialPositions || undefined);
+                    tui.requestRender();
+                }
+                catch { }
                 return {
                     content: [{ type: 'text', text: JSON.stringify(result) }],
                     details: {},
@@ -901,6 +998,81 @@ async function agentCommand(thesisId, opts) {
             },
         },
     ];
+    // ── What-if tool (always available) ────────────────────────────────────────
+    tools.push({
+        name: 'what_if',
+        label: 'What-If',
+        description: 'Run a what-if scenario: override causal tree node probabilities and see how edges and confidence change. Zero LLM cost — pure computation. Use when user asks "what if X happens?" or "what if this node drops to Y%?".',
+        parameters: Type.Object({
+            overrides: Type.Array(Type.Object({
+                nodeId: Type.String({ description: 'Causal tree node ID (e.g. n1, n3.1)' }),
+                newProbability: Type.Number({ description: 'New probability 0-1' }),
+            }), { description: 'Node probability overrides' }),
+        }),
+        execute: async (_toolCallId, params) => {
+            // Inline what-if simulation
+            const ctx = latestContext;
+            const allNodes = [];
+            function flatten(nodes) {
+                for (const n of nodes) {
+                    allNodes.push(n);
+                    if (n.children?.length)
+                        flatten(n.children);
+                }
+            }
+            const rawNodes = ctx.causalTree?.nodes || [];
+            flatten(rawNodes);
+            const treeNodes = rawNodes.filter((n) => n.depth === 0 || (n.depth === undefined && !n.id.includes('.')));
+            const overrideMap = new Map(params.overrides.map((o) => [o.nodeId, o.newProbability]));
+            const oldConf = treeNodes.reduce((s, n) => s + (n.probability || 0) * (n.importance || 0), 0);
+            const newConf = treeNodes.reduce((s, n) => {
+                const p = overrideMap.get(n.id) ?? n.probability ?? 0;
+                return s + p * (n.importance || 0);
+            }, 0);
+            const nodeScales = new Map();
+            for (const [nid, np] of overrideMap.entries()) {
+                const nd = allNodes.find((n) => n.id === nid);
+                if (nd && nd.probability > 0)
+                    nodeScales.set(nid, Math.max(0, Math.min(2, np / nd.probability)));
+            }
+            const edges = (ctx.edges || []).map((edge) => {
+                const relNode = edge.relatedNodeId;
+                let scaleFactor = 1;
+                if (relNode) {
+                    const candidates = [relNode, relNode.split('.').slice(0, -1).join('.'), relNode.split('.')[0]].filter(Boolean);
+                    for (const cid of candidates) {
+                        if (nodeScales.has(cid)) {
+                            scaleFactor = nodeScales.get(cid);
+                            break;
+                        }
+                    }
+                }
+                const mkt = edge.marketPrice || 0;
+                const oldTP = edge.thesisPrice || edge.thesisImpliedPrice || mkt;
+                const oldEdge = edge.edge || edge.edgeSize || 0;
+                const newTP = Math.round((mkt + (oldTP - mkt) * scaleFactor) * 100) / 100;
+                const dir = edge.direction || 'yes';
+                const newEdge = Math.round((dir === 'yes' ? newTP - mkt : mkt - newTP) * 100) / 100;
+                return {
+                    market: edge.market || edge.marketTitle || edge.marketId,
+                    marketPrice: mkt,
+                    oldEdge,
+                    newEdge,
+                    delta: newEdge - oldEdge,
+                    signal: Math.abs(newEdge - oldEdge) < 1 ? 'unchanged' : (oldEdge > 0 && newEdge < 0) || (oldEdge < 0 && newEdge > 0) ? 'REVERSED' : Math.abs(newEdge) < 2 ? 'GONE' : 'reduced',
+                };
+            }).filter((e) => e.signal !== 'unchanged');
+            const result = {
+                overrides: params.overrides.map((o) => {
+                    const node = allNodes.find((n) => n.id === o.nodeId);
+                    return { nodeId: o.nodeId, label: node?.label || o.nodeId, oldProb: node?.probability, newProb: o.newProbability };
+                }),
+                confidence: { old: Math.round(oldConf * 100), new: Math.round(newConf * 100), delta: Math.round((newConf - oldConf) * 100) },
+                affectedEdges: edges,
+            };
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }], details: {} };
+        },
+    });
     // ── Trading tools (conditional on tradingEnabled) ──────────────────────────
     const config = (0, config_js_1.loadConfig)();
     if (config.tradingEnabled) {
@@ -1163,6 +1335,12 @@ ${ctx.lastEvaluation?.summary ? `Latest evaluation summary: ${ctx.lastEvaluation
             isProcessing = false;
             persistSession();
             flushRender();
+            // Deliver queued heartbeat notification if any
+            if (pendingHeartbeatDelta) {
+                const delta = pendingHeartbeatDelta;
+                pendingHeartbeatDelta = null;
+                handleHeartbeatDelta(delta);
+            }
         }
         if (event.type === 'tool_execution_start') {
             const toolLine = new MutableLine(C.zinc600(`  \u26A1 ${event.toolName}...`));
@@ -1298,7 +1476,8 @@ ${ctx.lastEvaluation?.summary ? `Latest evaluation summary: ${ctx.lastEvaluation
                 model = resolveModel(currentModelName);
                 // Update agent model
                 agent.setModel(model);
-                headerBar.update(undefined, undefined, C.zinc600(currentModelName.split('/').pop() || currentModelName));
+                footerBar.modelName = currentModelName;
+                footerBar.update();
                 addSystemText(C.emerald(`Model switched to ${currentModelName}`));
                 addSpacer();
                 tui.requestRender();
@@ -1338,13 +1517,9 @@ ${ctx.lastEvaluation?.summary ? `Latest evaluation summary: ${ctx.lastEvaluation
                         addSystemText(C.emerald(`Switched to ${resolvedThesisId.slice(0, 8)}`) + C.zinc400(' (new session)'));
                     }
                     // Update header
-                    headerBar.update(C.emerald(bold('SF Agent')) + C.zinc600(` \u2014 ${resolvedThesisId.slice(0, 8)}`), newConf > 0 ? C.zinc200(`${newConf}%`) : '', undefined);
+                    headerBar.setFromContext(newContext, initialPositions || undefined);
                     chatContainer.clear();
-                    const thText = (newContext.thesis || newContext.rawThesis || '').slice(0, 120);
-                    addSystemText(C.zinc600('\u2500'.repeat(50)) + '\n' +
-                        C.zinc200(bold(thText)) + '\n' +
-                        C.zinc600(`${newContext.status || 'active'}  ${newConf > 0 ? newConf + '%' : ''}  ${(newContext.edges || []).length} edges`) + '\n' +
-                        C.zinc600('\u2500'.repeat(50)));
+                    addSystemText(buildWelcomeDashboard(newContext, initialPositions));
                 }
                 catch (err) {
                     addSystemText(C.red(`Switch failed: ${err.message}`));
@@ -1703,6 +1878,8 @@ Output a structured summary. Be concise but preserve every important detail —
     };
     // ── Ctrl+C handler ─────────────────────────────────────────────────────────
     function cleanup() {
+        if (heartbeatPollTimer)
+            clearInterval(heartbeatPollTimer);
         if (currentLoader)
             currentLoader.stop();
         persistSession();
@@ -1721,17 +1898,125 @@ Output a structured summary. Be concise but preserve every important detail —
     // Also handle SIGINT
     process.on('SIGINT', cleanup);
     process.on('SIGTERM', cleanup);
+    // ── Welcome dashboard builder ────────────────────────────────────────────
+    function buildWelcomeDashboard(ctx, positions) {
+        const lines = [];
+        const thesisText = ctx.thesis || ctx.rawThesis || 'N/A';
+        const truncated = thesisText.length > 100 ? thesisText.slice(0, 100) + '...' : thesisText;
+        const conf = typeof ctx.confidence === 'number'
+            ? Math.round(ctx.confidence * 100)
+            : (typeof ctx.confidence === 'string' ? Math.round(parseFloat(ctx.confidence) * 100) : 0);
+        const delta = ctx.lastEvaluation?.confidenceDelta
+            ? Math.round(ctx.lastEvaluation.confidenceDelta * 100)
+            : 0;
+        const deltaStr = delta !== 0 ? ` (${delta > 0 ? '+' : ''}${delta})` : '';
+        const evalAge = ctx.lastEvaluation?.evaluatedAt
+            ? Math.round((Date.now() - new Date(ctx.lastEvaluation.evaluatedAt).getTime()) / 3600000)
+            : null;
+        lines.push(C.zinc600('\u2500'.repeat(55)));
+        lines.push(' ' + C.zinc200(bold(truncated)));
+        lines.push(' ' + C.zinc600(`${ctx.status || 'active'}  ${conf}%${deltaStr}`) +
+            (evalAge !== null ? C.zinc600(`  \u2502  last eval: ${evalAge < 1 ? '<1' : evalAge}h ago`) : ''));
+        lines.push(C.zinc600('\u2500'.repeat(55)));
+        // Positions section
+        if (positions && positions.length > 0) {
+            lines.push(' ' + C.zinc400(bold('POSITIONS')));
+            let totalPnl = 0;
+            for (const p of positions) {
+                const pnlCents = p.unrealized_pnl || 0;
+                totalPnl += pnlCents;
+                const pnlStr = pnlCents >= 0
+                    ? C.emerald(`+$${(pnlCents / 100).toFixed(2)}`)
+                    : C.red(`-$${(Math.abs(pnlCents) / 100).toFixed(2)}`);
+                const ticker = (p.ticker || '').slice(0, 28).padEnd(28);
+                const qty = String(p.quantity || 0).padStart(5);
+                const side = p.side === 'yes' ? C.emerald('Y') : C.red('N');
+                lines.push(`  ${C.zinc400(ticker)} ${qty} ${side}  ${pnlStr}`);
+            }
+            const totalStr = totalPnl >= 0
+                ? C.emerald(bold(`+$${(totalPnl / 100).toFixed(2)}`))
+                : C.red(bold(`-$${(Math.abs(totalPnl) / 100).toFixed(2)}`));
+            lines.push(`  ${''.padEnd(28)} ${C.zinc600('Total')} ${totalStr}`);
+        }
+        // Top edges section
+        const edges = ctx.edges || [];
+        if (edges.length > 0) {
+            const sorted = [...edges].sort((a, b) => Math.abs(b.edge || b.edgeSize || 0) - Math.abs(a.edge || a.edgeSize || 0)).slice(0, 5);
+            lines.push(C.zinc600('\u2500'.repeat(55)));
+            lines.push(' ' + C.zinc400(bold('TOP EDGES')) + C.zinc600('                          mkt   edge  liq'));
+            for (const e of sorted) {
+                const name = (e.market || e.marketTitle || e.marketId || '').slice(0, 30).padEnd(30);
+                const mkt = String(Math.round(e.marketPrice || 0)).padStart(3) + '\u00A2';
+                const edge = e.edge || e.edgeSize || 0;
+                const edgeStr = (edge > 0 ? '+' : '') + Math.round(edge);
+                const liq = e.orderbook?.liquidityScore || (e.venue === 'polymarket' ? '-' : '?');
+                const edgeColor = Math.abs(edge) >= 15 ? C.emerald : Math.abs(edge) >= 8 ? C.amber : C.zinc400;
+                lines.push(`  ${C.zinc400(name)} ${C.zinc400(mkt)}  ${edgeColor(edgeStr.padStart(4))}  ${C.zinc600(liq)}`);
+            }
+        }
+        lines.push(C.zinc600('\u2500'.repeat(55)));
+        return lines.join('\n');
+    }
     // ── Show initial welcome ───────────────────────────────────────────────────
-    const thesisText = latestContext.thesis || latestContext.rawThesis || 'N/A';
-    const truncatedThesis = thesisText.length > 120 ? thesisText.slice(0, 120) + '...' : thesisText;
     const sessionStatus = sessionRestored
-        ? C.zinc600(`  resumed (${agent.state.messages.length} messages)`)
-        : C.zinc600('  new session');
-    addSystemText(C.zinc600('\u2500'.repeat(50)) + '\n' +
-        C.zinc200(bold(truncatedThesis)) + '\n' +
-        C.zinc600(`${latestContext.status || 'active'}  ${confidencePct > 0 ? confidencePct + '%' : ''}  ${(latestContext.edges || []).length} edges`) + sessionStatus + '\n' +
-        C.zinc600('\u2500'.repeat(50)));
+        ? C.zinc600(`resumed (${agent.state.messages.length} messages)`)
+        : C.zinc600('new session');
+    addSystemText(buildWelcomeDashboard(latestContext, initialPositions));
+    addSystemText(' ' + sessionStatus);
     addSpacer();
+    // ── Heartbeat delta handler ───────────────────────────────────────────────
+    const HEARTBEAT_CONFIDENCE_THRESHOLD = 0.03; // 3%
+    function handleHeartbeatDelta(delta) {
+        const absDelta = Math.abs(delta.confidenceDelta || 0);
+        const confPct = Math.round((delta.confidence || 0) * 100);
+        const deltaPct = Math.round((delta.confidenceDelta || 0) * 100);
+        const sign = deltaPct > 0 ? '+' : '';
+        if (absDelta >= HEARTBEAT_CONFIDENCE_THRESHOLD) {
+            // Big change → auto-trigger agent analysis
+            const arrow = deltaPct > 0 ? '\u25B2' : '\u25BC';
+            const color = deltaPct > 0 ? C.emerald : C.red;
+            addSystemText(color(`  ${arrow} Heartbeat: confidence ${sign}${deltaPct}% → ${confPct}%`));
+            if (delta.latestSummary) {
+                addSystemText(C.zinc400(`  ${delta.latestSummary.slice(0, 100)}`));
+            }
+            addSpacer();
+            // Update header
+            headerBar.setFromContext({ ...latestContext, confidence: delta.confidence, lastEvaluation: { confidenceDelta: delta.confidenceDelta } }, initialPositions || undefined);
+            tui.requestRender();
+            // Auto-trigger agent
+            isProcessing = true;
+            const prompt = `[HEARTBEAT ALERT] Confidence just changed ${sign}${deltaPct}% to ${confPct}%. ${delta.evaluationCount} evaluation(s) since last check. Latest: "${(delta.latestSummary || '').slice(0, 150)}". Briefly analyze what happened and whether any action is needed. Be concise.`;
+            agent.prompt(prompt).catch((err) => {
+                addSystemText(C.red(`Error: ${err.message}`));
+                isProcessing = false;
+            });
+        }
+        else if (absDelta > 0) {
+            // Small change → silent notification line only
+            addSystemText(C.zinc600(`  \u2500 heartbeat: ${confPct}% (${sign}${deltaPct}%) \u2014 ${delta.evaluationCount || 0} eval(s)`));
+            tui.requestRender();
+        }
+        // absDelta === 0: truly nothing changed, stay silent
+    }
+    // ── Start heartbeat polling ───────────────────────────────────────────────
+    heartbeatPollTimer = setInterval(async () => {
+        try {
+            const delta = await sfClient.getChanges(resolvedThesisId, lastPollTimestamp);
+            lastPollTimestamp = new Date().toISOString();
+            if (!delta.changed)
+                return;
+            if (isProcessing || pendingPrompt) {
+                // Agent is busy — queue for delivery after agent_end
+                pendingHeartbeatDelta = delta;
+            }
+            else {
+                handleHeartbeatDelta(delta);
+            }
+        }
+        catch {
+            // Silent — don't spam errors from background polling
+        }
+    }, 60_000); // every 60 seconds
     // ── Start TUI ──────────────────────────────────────────────────────────────
     tui.start();
 }

package/dist/commands/feed.d.ts

@@ -0,0 +1,13 @@
+/**
+ * sf feed — Evaluation history stream.
+ *
+ * Shows what the heartbeat engine has been thinking.
+ * One line per evaluation cycle, newest first.
+ */
+export declare function feedCommand(opts: {
+    hours?: string;
+    thesis?: string;
+    json?: boolean;
+    apiKey?: string;
+    apiUrl?: string;
+}): Promise<void>;

package/dist/commands/feed.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * sf feed — Evaluation history stream.
+ *
+ * Shows what the heartbeat engine has been thinking.
+ * One line per evaluation cycle, newest first.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.feedCommand = feedCommand;
+const client_js_1 = require("../client.js");
+const utils_js_1 = require("../utils.js");
+async function feedCommand(opts) {
+    const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
+    const hours = parseInt(opts.hours || '24');
+    const data = await client.getFeed(hours, 200);
+    let feed = data.feed || [];
+    if (feed.length === 0) {
+        console.log(`${utils_js_1.c.dim}No evaluations in the last ${hours} hours.${utils_js_1.c.reset}`);
+        return;
+    }
+    // Filter by thesis if specified
+    if (opts.thesis) {
+        feed = feed.filter((e) => e.thesisId.startsWith(opts.thesis) || e.thesisShortId === opts.thesis);
+        if (feed.length === 0) {
+            console.log(`${utils_js_1.c.dim}No evaluations for ${opts.thesis} in the last ${hours} hours.${utils_js_1.c.reset}`);
+            return;
+        }
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(feed, null, 2));
+        return;
+    }
+    // Render feed
+    console.log();
+    console.log(`${utils_js_1.c.bold}${utils_js_1.c.cyan}Evaluation Feed${utils_js_1.c.reset}${utils_js_1.c.dim} — last ${hours}h, ${feed.length} cycles${utils_js_1.c.reset}`);
+    console.log(`${utils_js_1.c.dim}${'─'.repeat(75)}${utils_js_1.c.reset}`);
+    for (const entry of feed) {
+        const time = new Date(entry.evaluatedAt);
+        const timeStr = time.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+        // Confidence + delta
+        const conf = Math.round(entry.confidence * 100);
+        const delta = Math.round(entry.delta * 100);
+        let deltaStr;
+        if (delta > 0) {
+            deltaStr = `${utils_js_1.c.green}+${delta}%${utils_js_1.c.reset}`;
+        }
+        else if (delta < 0) {
+            deltaStr = `${utils_js_1.c.red}${delta}%${utils_js_1.c.reset}`;
+        }
+        else {
+            deltaStr = `${utils_js_1.c.dim}0%${utils_js_1.c.reset}`;
+        }
+        // Thesis ID (short)
+        const id = entry.thesisShortId || entry.thesisId?.slice(0, 8) || '?';
+        // Summary — truncate to fit one line
+        const summary = (entry.summary || 'No summary').replace(/\n/g, ' ').slice(0, 80);
+        // Node changes
+        const nodes = entry.updatedNodes || [];
+        const nodeStr = nodes.length > 0
+            ? nodes.slice(0, 3).map((n) => `${n.nodeId}→${Math.round((n.newProb || 0) * 100)}%`).join(', ')
+            : '';
+        // Format line
+        console.log(`${utils_js_1.c.dim}[${timeStr}]${utils_js_1.c.reset} ` +
+            `${utils_js_1.c.cyan}${id}${utils_js_1.c.reset} ` +
+            `${conf}% (${deltaStr})  ` +
+            `${utils_js_1.c.dim}${summary}${utils_js_1.c.reset}`);
+        if (nodeStr) {
+            console.log(`${' '.repeat(9)} ${utils_js_1.c.dim}nodes: ${nodeStr}${utils_js_1.c.reset}`);
+        }
+    }
+    console.log(`${utils_js_1.c.dim}${'─'.repeat(75)}${utils_js_1.c.reset}`);
+    console.log();
+}

package/dist/commands/whatif.d.ts

@@ -0,0 +1,17 @@
+/**
+ * sf whatif — What-if scenario analysis.
+ *
+ * Pure computation, zero LLM cost. Answers:
+ * "If node X drops to 10%, what happens to my edges and positions?"
+ *
+ * Usage:
+ *   sf whatif f582bf76 --set "n1=0.1"
+ *   sf whatif f582bf76 --set "n1=0.1" --set "n3.1=0.2"
+ *   sf whatif f582bf76 --set "n1=0.1" --json
+ */
+export declare function whatifCommand(thesisId: string, opts: {
+    set?: string[];
+    json?: boolean;
+    apiKey?: string;
+    apiUrl?: string;
+}): Promise<void>;

package/dist/commands/whatif.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * sf whatif — What-if scenario analysis.
+ *
+ * Pure computation, zero LLM cost. Answers:
+ * "If node X drops to 10%, what happens to my edges and positions?"
+ *
+ * Usage:
+ *   sf whatif f582bf76 --set "n1=0.1"
+ *   sf whatif f582bf76 --set "n1=0.1" --set "n3.1=0.2"
+ *   sf whatif f582bf76 --set "n1=0.1" --json
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whatifCommand = whatifCommand;
+const client_js_1 = require("../client.js");
+const kalshi_js_1 = require("../kalshi.js");
+const utils_js_1 = require("../utils.js");
+// Inline what-if simulation (mirrors server-side logic, zero dependency)
+function simulateWhatIf(ctx, overrides) {
+    const allNodes = [];
+    function flatten(nodes) {
+        for (const n of nodes) {
+            allNodes.push(n);
+            if (n.children?.length)
+                flatten(n.children);
+        }
+    }
+    const rawNodes = ctx.causalTree?.nodes || [];
+    flatten(rawNodes);
+    // Top-level nodes only (depth=0 or no depth field + no dot in id)
+    const treeNodes = rawNodes.filter((n) => n.depth === 0 || (n.depth === undefined && !n.id.includes('.')));
+    const overrideMap = new Map(overrides.map(o => [o.nodeId, o.newProbability]));
+    const overrideDetails = overrides.map(o => {
+        const node = allNodes.find((n) => n.id === o.nodeId);
+        return {
+            nodeId: o.nodeId,
+            oldProb: node?.probability ?? 0,
+            newProb: o.newProbability,
+            label: node?.label || o.nodeId,
+        };
+    });
+    // Confidence (only top-level nodes)
+    const oldConf = treeNodes.reduce((s, n) => s + (n.probability || 0) * (n.importance || 0), 0);
+    const newConf = treeNodes.reduce((s, n) => {
+        const p = overrideMap.get(n.id) ?? n.probability ?? 0;
+        return s + p * (n.importance || 0);
+    }, 0);
+    // Per-node override ratios — only scale edges directly related to overridden nodes.
+    // No global scale: edges unrelated to any override stay unchanged.
+    // User must explicitly override each node they think is affected.
+    const nodeScales = new Map();
+    for (const [nodeId, newProb] of overrideMap.entries()) {
+        const node = allNodes.find((n) => n.id === nodeId);
+        if (node && node.probability > 0) {
+            nodeScales.set(nodeId, Math.max(0, Math.min(2, newProb / node.probability)));
+        }
+    }
+    // Edges
+    const edges = (ctx.edges || []).map((edge) => {
+        const relNode = edge.relatedNodeId;
+        let scaleFactor = 1; // default: no change
+        // Only scale if edge's related node (or its ancestor) was overridden
+        if (relNode) {
+            const candidates = [relNode, relNode.split('.').slice(0, -1).join('.'), relNode.split('.')[0]].filter(Boolean);
+            for (const cid of candidates) {
+                if (nodeScales.has(cid)) {
+                    scaleFactor = nodeScales.get(cid);
+                    break;
+                }
+            }
+        }
+        const mkt = edge.marketPrice || 0;
+        const oldTP = edge.thesisPrice || edge.thesisImpliedPrice || mkt;
+        const oldEdge = edge.edge || edge.edgeSize || 0;
+        const premium = oldTP - mkt;
+        const newTP = Math.round((mkt + premium * scaleFactor) * 100) / 100;
+        const dir = edge.direction || 'yes';
+        const newEdge = Math.round((dir === 'yes' ? newTP - mkt : mkt - newTP) * 100) / 100;
+        const delta = Math.round((newEdge - oldEdge) * 100) / 100;
+        let signal = 'unchanged';
+        if (Math.abs(delta) < 1)
+            signal = 'unchanged';
+        else if ((oldEdge > 0 && newEdge < 0) || (oldEdge < 0 && newEdge > 0))
+            signal = 'reversed';
+        else if (Math.abs(newEdge) < 2)
+            signal = 'gone';
+        else if (Math.abs(newEdge) < Math.abs(oldEdge))
+            signal = 'reduced';
+        return {
+            marketId: edge.marketId,
+            market: edge.market || edge.marketTitle || edge.marketId,
+            venue: edge.venue,
+            direction: dir,
+            marketPrice: mkt,
+            oldThesisPrice: oldTP,
+            newThesisPrice: newTP,
+            oldEdge,
+            newEdge,
+            delta,
+            signal,
+            relatedNodeId: relNode,
+        };
+    });
+    edges.sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
+    return {
+        overrides: overrideDetails,
+        oldConfidence: oldConf,
+        newConfidence: newConf,
+        confidenceDelta: Math.round((newConf - oldConf) * 100) / 100,
+        edges,
+    };
+}
+async function whatifCommand(thesisId, opts) {
+    if (!opts.set || opts.set.length === 0) {
+        throw new Error('Usage: sf whatif <thesisId> --set "n1=0.1" [--set "n3=0.5"]');
+    }
+    // Parse overrides
+    const overrides = opts.set.map(s => {
+        const [nodeId, valStr] = s.split('=');
+        if (!nodeId || !valStr)
+            throw new Error(`Invalid override: "${s}". Format: nodeId=probability`);
+        const prob = parseFloat(valStr);
+        if (isNaN(prob) || prob < 0 || prob > 1)
+            throw new Error(`Invalid probability: "${valStr}". Must be 0-1.`);
+        return { nodeId: nodeId.trim(), newProbability: prob };
+    });
+    const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
+    const ctx = await client.getContext(thesisId);
+    const result = simulateWhatIf(ctx, overrides);
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    // Render
+    console.log();
+    console.log(`${utils_js_1.c.bold}${utils_js_1.c.cyan}WHAT-IF Scenario${utils_js_1.c.reset}`);
+    console.log(`${utils_js_1.c.dim}${'─'.repeat(65)}${utils_js_1.c.reset}`);
+    // Overrides
+    for (const o of result.overrides) {
+        const oldPct = Math.round(o.oldProb * 100);
+        const newPct = Math.round(o.newProb * 100);
+        const arrow = newPct > oldPct ? utils_js_1.c.green + '↑' + utils_js_1.c.reset : utils_js_1.c.red + '↓' + utils_js_1.c.reset;
+        console.log(`  ${utils_js_1.c.cyan}${o.nodeId}${utils_js_1.c.reset} ${o.label.slice(0, 40)}`);
+        console.log(`    ${oldPct}% ${arrow} ${utils_js_1.c.bold}${newPct}%${utils_js_1.c.reset}`);
+    }
+    // Confidence
+    const oldPct = Math.round(result.oldConfidence * 100);
+    const newPct = Math.round(result.newConfidence * 100);
+    const deltaSign = result.confidenceDelta > 0 ? '+' : '';
+    const confColor = result.confidenceDelta >= 0 ? utils_js_1.c.green : utils_js_1.c.red;
+    console.log();
+    console.log(`  Confidence: ${oldPct}% → ${confColor}${utils_js_1.c.bold}${newPct}%${utils_js_1.c.reset} (${confColor}${deltaSign}${Math.round(result.confidenceDelta * 100)}${utils_js_1.c.reset})`);
+    console.log();
+    // Edges
+    const affected = result.edges.filter((e) => e.signal !== 'unchanged');
+    if (affected.length === 0) {
+        console.log(`  ${utils_js_1.c.dim}No edges affected.${utils_js_1.c.reset}`);
+    }
+    else {
+        console.log(`  ${utils_js_1.c.bold}Edges Affected${utils_js_1.c.reset}`);
+        console.log(`  ${'Market'.padEnd(35)} ${'Now'.padEnd(6)} ${'Edge'.padEnd(8)} ${'→'.padEnd(3)} ${'New Edge'.padEnd(8)} Signal`);
+        console.log(`  ${utils_js_1.c.dim}${'─'.repeat(65)}${utils_js_1.c.reset}`);
+        for (const e of affected) {
+            const name = (e.market || e.marketId).slice(0, 33).padEnd(35);
+            const mkt = `${Math.round(e.marketPrice)}¢`.padEnd(6);
+            const oldE = `${e.oldEdge > 0 ? '+' : ''}${Math.round(e.oldEdge)}`.padEnd(8);
+            const newE = `${e.newEdge > 0 ? '+' : ''}${Math.round(e.newEdge)}`.padEnd(8);
+            let signalStr;
+            switch (e.signal) {
+                case 'reversed':
+                    signalStr = `${utils_js_1.c.red}${utils_js_1.c.bold}REVERSED${utils_js_1.c.reset}`;
+                    break;
+                case 'gone':
+                    signalStr = `${utils_js_1.c.red}GONE${utils_js_1.c.reset}`;
+                    break;
+                case 'reduced':
+                    signalStr = `${utils_js_1.c.dim}reduced${utils_js_1.c.reset}`;
+                    break;
+                default: signalStr = `${utils_js_1.c.dim}-${utils_js_1.c.reset}`;
+            }
+            console.log(`  ${utils_js_1.c.dim}${name}${utils_js_1.c.reset} ${mkt} ${oldE} → ${newE} ${signalStr}`);
+        }
+    }
+    // Position risk (if positions available)
+    try {
+        const positions = await (0, kalshi_js_1.getPositions)();
+        if (positions && positions.length > 0) {
+            const edgeMap = new Map(result.edges.map((e) => [e.marketId, e]));
+            const atRisk = positions.filter((p) => {
+                const e = edgeMap.get(p.ticker);
+                return e && (e.signal === 'reversed' || e.signal === 'gone');
+            });
+            if (atRisk.length > 0) {
+                console.log();
+                console.log(`  ${utils_js_1.c.red}${utils_js_1.c.bold}⚠ Positions at Risk${utils_js_1.c.reset}`);
+                for (const p of atRisk) {
+                    const e = edgeMap.get(p.ticker);
+                    const livePrice = await (0, kalshi_js_1.getMarketPrice)(p.ticker);
+                    const currentPnl = livePrice !== null
+                        ? ((livePrice - p.average_price_paid) * p.quantity / 100).toFixed(2)
+                        : '?';
+                    console.log(`  ${utils_js_1.c.red}${p.ticker}${utils_js_1.c.reset}  ${p.quantity} ${p.side}  P&L $${currentPnl}  edge ${e.oldEdge > 0 ? '+' : ''}${Math.round(e.oldEdge)} → ${utils_js_1.c.red}${e.newEdge > 0 ? '+' : ''}${Math.round(e.newEdge)}${utils_js_1.c.reset}`);
+                }
+            }
+        }
+    }
+    catch { /* positions not available, skip */ }
+    console.log();
+}

package/dist/index.js

@@ -42,6 +42,8 @@ const settlements_js_1 = require("./commands/settlements.js");
 const balance_js_1 = require("./commands/balance.js");
 const orders_js_1 = require("./commands/orders.js");
 const fills_js_1 = require("./commands/fills.js");
+const feed_js_1 = require("./commands/feed.js");
+const whatif_js_1 = require("./commands/whatif.js");
 const trade_js_1 = require("./commands/trade.js");
 const cancel_js_1 = require("./commands/cancel.js");
 const schedule_js_1 = require("./commands/schedule.js");
@@ -296,6 +298,27 @@ program
     .action(async (opts) => {
     await run(() => (0, fills_js_1.fillsCommand)(opts));
 });
+// ── sf feed ──────────────────────────────────────────────────────────────────
+program
+    .command('feed')
+    .description('Evaluation history stream — what the heartbeat engine has been thinking')
+    .option('--hours <n>', 'Hours to look back (default 24)', '24')
+    .option('--thesis <id>', 'Filter by thesis')
+    .option('--json', 'JSON output')
+    .action(async (opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    await run(() => (0, feed_js_1.feedCommand)({ ...opts, apiKey: g.apiKey, apiUrl: g.apiUrl }));
+});
+// ── sf whatif <thesisId> ──────────────────────────────────────────────────────
+program
+    .command('whatif <thesisId>')
+    .description('What-if scenario — "if node X drops to 10%, what happens to my edges?"')
+    .option('--set <override>', 'Node override: nodeId=probability (0-1). Repeatable.', (val, prev) => [...prev, val], [])
+    .option('--json', 'JSON output')
+    .action(async (thesisId, opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    await run(() => (0, whatif_js_1.whatifCommand)(thesisId, { set: opts.set, json: opts.json, apiKey: g.apiKey, apiUrl: g.apiUrl }));
+});
 // ── sf schedule ──────────────────────────────────────────────────────────────
 program
     .command('schedule')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spfunctions/cli",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "description": "Prediction market intelligence CLI. Causal thesis model, 24/7 Kalshi/Polymarket scan, live orderbook, edge detection. Interactive agent mode with tool calling.",
   "bin": {
     "sf": "./dist/index.js"