@spfunctions/cli 1.1.5 → 1.1.7

package/dist/commands/agent.js

@@ -23,6 +23,7 @@ const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const client_js_1 = require("../client.js");
 const kalshi_js_1 = require("../kalshi.js");
+const config_js_1 = require("../config.js");
 // ─── Session persistence ─────────────────────────────────────────────────────
 function getSessionDir() {
     return path_1.default.join(os_1.default.homedir(), '.sf', 'sessions');
@@ -99,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;
         }
@@ -127,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));
@@ -153,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() {
@@ -177,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));
@@ -286,23 +342,36 @@ function renderPositions(positions) {
 }
 // ─── Main command ────────────────────────────────────────────────────────────
 async function agentCommand(thesisId, opts) {
-    // ── Dynamic imports (all ESM-only packages) ────────────────────────────────
-    const piTui = await import('@mariozechner/pi-tui');
-    const piAi = await import('@mariozechner/pi-ai');
-    const piAgent = await import('@mariozechner/pi-agent-core');
-    const { TUI, ProcessTerminal, Container, Text, Markdown, Editor, Loader, Spacer, CombinedAutocompleteProvider, truncateToWidth, visibleWidth, } = piTui;
-    const { getModel, streamSimple, Type } = piAi;
-    const { Agent } = piAgent;
-    // ── Component class factories (need piTui ref) ─────────────────────────────
-    const MutableLine = createMutableLine(piTui);
-    const HeaderBar = createHeaderBar(piTui);
-    const FooterBar = createFooterBar(piTui);
     // ── Validate API keys ──────────────────────────────────────────────────────
     const openrouterKey = opts?.modelKey || process.env.OPENROUTER_API_KEY;
     if (!openrouterKey) {
-        console.error('Need OpenRouter API key. Set OPENROUTER_API_KEY or use --model-key.');
+        console.error('Need OpenRouter API key to power the agent LLM.');
+        console.error('');
+        console.error('  1. Get a key at https://openrouter.ai/keys');
+        console.error('  2. Then either:');
+        console.error('     export OPENROUTER_API_KEY=sk-or-v1-...');
+        console.error('     sf agent --model-key sk-or-v1-...');
+        console.error('     sf setup  (saves to ~/.sf/config.json)');
         process.exit(1);
     }
+    // Pre-flight: validate OpenRouter key
+    try {
+        const checkRes = await fetch('https://openrouter.ai/api/v1/auth/key', {
+            headers: { 'Authorization': `Bearer ${openrouterKey}` },
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!checkRes.ok) {
+            console.error('OpenRouter API key is invalid or expired.');
+            console.error('Get a new key at https://openrouter.ai/keys');
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (!msg.includes('timeout')) {
+            console.warn(`Warning: Could not verify OpenRouter key (${msg}). Continuing anyway.`);
+        }
+    }
     const sfClient = new client_js_1.SFClient();
     // ── Resolve thesis ID ──────────────────────────────────────────────────────
     let resolvedThesisId = thesisId;
@@ -318,6 +387,21 @@ async function agentCommand(thesisId, opts) {
     }
     // ── Fetch initial context ──────────────────────────────────────────────────
     let latestContext = await sfClient.getContext(resolvedThesisId);
+    // ── Branch: plain-text mode ────────────────────────────────────────────────
+    if (opts?.noTui) {
+        return runPlainTextAgent({ openrouterKey, sfClient, resolvedThesisId: resolvedThesisId, latestContext, opts });
+    }
+    // ── Dynamic imports (all ESM-only packages) ────────────────────────────────
+    const piTui = await import('@mariozechner/pi-tui');
+    const piAi = await import('@mariozechner/pi-ai');
+    const piAgent = await import('@mariozechner/pi-agent-core');
+    const { TUI, ProcessTerminal, Container, Text, Markdown, Editor, Loader, Spacer, CombinedAutocompleteProvider, truncateToWidth, visibleWidth, } = piTui;
+    const { getModel, streamSimple, Type } = piAi;
+    const { Agent } = piAgent;
+    // ── Component class factories (need piTui ref) ─────────────────────────────
+    const MutableLine = createMutableLine(piTui);
+    const HeaderBar = createHeaderBar(piTui);
+    const FooterBar = createFooterBar(piTui);
     // ── Model setup ────────────────────────────────────────────────────────────
     const rawModelName = opts?.model || 'anthropic/claude-sonnet-4.6';
     let currentModelName = rawModelName.replace(/^openrouter\//, '');
@@ -349,6 +433,10 @@ async function agentCommand(thesisId, opts) {
     let isProcessing = false;
     // Cache for positions (fetched by /pos or get_positions tool)
     let cachedPositions = 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.
+    let pendingPrompt = null;
     // ── Setup TUI ──────────────────────────────────────────────────────────────
     const terminal = new ProcessTerminal();
     const tui = new TUI(terminal);
@@ -372,9 +460,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),
@@ -384,18 +472,37 @@ 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();
     const editor = new Editor(tui, editorTheme, { paddingX: 1 });
     // Slash command autocomplete
-    const autocompleteProvider = new CombinedAutocompleteProvider([
+    const slashCommands = [
         { name: 'help', description: 'Show available commands' },
         { name: 'tree', description: 'Display causal tree' },
         { name: 'edges', description: 'Display edge/spread table' },
@@ -408,7 +515,13 @@ async function agentCommand(thesisId, opts) {
         { name: 'env', description: 'Show environment variable status' },
         { name: 'clear', description: 'Clear screen (keeps history)' },
         { name: 'exit', description: 'Exit agent (auto-saves)' },
-    ], process.cwd());
+    ];
+    // Add trading commands if enabled
+    if ((0, config_js_1.loadConfig)().tradingEnabled) {
+        slashCommands.splice(-2, 0, // insert before /clear and /exit
+        { name: 'buy', description: 'TICKER QTY PRICE — quick buy' }, { name: 'sell', description: 'TICKER QTY PRICE — quick sell' }, { name: 'cancel', description: 'ORDER_ID — cancel order' });
+    }
+    const autocompleteProvider = new CombinedAutocompleteProvider(slashCommands, process.cwd());
     editor.setAutocompleteProvider(autocompleteProvider);
     // Assemble TUI tree
     tui.addChild(topSpacer);
@@ -438,6 +551,19 @@ async function agentCommand(thesisId, opts) {
     function addSpacer() {
         chatContainer.addChild(new Spacer(1));
     }
+    /**
+     * Ask the user a question during tool execution.
+     * Temporarily unlocks the editor, waits for input, then resumes.
+     * Used for order confirmations and other dangerous operations.
+     */
+    function promptUser(question) {
+        return new Promise(resolve => {
+            addSystemText(C.amber(bold('\u26A0 ')) + C.zinc200(question));
+            addSpacer();
+            tui.requestRender();
+            pendingPrompt = { resolve };
+        });
+    }
     // ── Define agent tools (same as before) ────────────────────────────────────
     const thesisIdParam = Type.Object({
         thesisId: Type.String({ description: 'Thesis ID (short or full UUID)' }),
@@ -465,11 +591,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) }],
@@ -497,6 +619,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: {},
@@ -636,7 +778,378 @@ async function agentCommand(thesisId, opts) {
                 return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
             },
         },
+        {
+            name: 'create_strategy',
+            label: 'Create Strategy',
+            description: 'Create a trading strategy for a thesis. Extract hard conditions (entryBelow/stopLoss/takeProfit as cents) and soft conditions from conversation. Called when user mentions specific trade ideas.',
+            parameters: Type.Object({
+                thesisId: Type.String({ description: 'Thesis ID' }),
+                marketId: Type.String({ description: 'Market ticker e.g. KXWTIMAX-26DEC31-T150' }),
+                market: Type.String({ description: 'Human-readable market name' }),
+                direction: Type.String({ description: 'yes or no' }),
+                horizon: Type.Optional(Type.String({ description: 'short, medium, or long. Default: medium' })),
+                entryBelow: Type.Optional(Type.Number({ description: 'Entry trigger: ask <= this value (cents)' })),
+                entryAbove: Type.Optional(Type.Number({ description: 'Entry trigger: ask >= this value (cents, for NO direction)' })),
+                stopLoss: Type.Optional(Type.Number({ description: 'Stop loss: bid <= this value (cents)' })),
+                takeProfit: Type.Optional(Type.Number({ description: 'Take profit: bid >= this value (cents)' })),
+                maxQuantity: Type.Optional(Type.Number({ description: 'Max total contracts. Default: 500' })),
+                perOrderQuantity: Type.Optional(Type.Number({ description: 'Contracts per order. Default: 50' })),
+                softConditions: Type.Optional(Type.String({ description: 'LLM-evaluated conditions e.g. "only enter when n3 > 60%"' })),
+                rationale: Type.Optional(Type.String({ description: 'Full logic description' })),
+            }),
+            execute: async (_toolCallId, params) => {
+                const result = await sfClient.createStrategyAPI(params.thesisId, {
+                    marketId: params.marketId,
+                    market: params.market,
+                    direction: params.direction,
+                    horizon: params.horizon,
+                    entryBelow: params.entryBelow,
+                    entryAbove: params.entryAbove,
+                    stopLoss: params.stopLoss,
+                    takeProfit: params.takeProfit,
+                    maxQuantity: params.maxQuantity,
+                    perOrderQuantity: params.perOrderQuantity,
+                    softConditions: params.softConditions,
+                    rationale: params.rationale,
+                    createdBy: 'agent',
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result) }], details: {} };
+            },
+        },
+        {
+            name: 'list_strategies',
+            label: 'List Strategies',
+            description: 'List strategies for a thesis. Filter by status (active/watching/executed/cancelled/review) or omit for all.',
+            parameters: Type.Object({
+                thesisId: Type.String({ description: 'Thesis ID' }),
+                status: Type.Optional(Type.String({ description: 'Filter by status. Omit for all.' })),
+            }),
+            execute: async (_toolCallId, params) => {
+                const result = await sfClient.getStrategies(params.thesisId, params.status);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'update_strategy',
+            label: 'Update Strategy',
+            description: 'Update a strategy (change stop loss, take profit, status, priority, etc.)',
+            parameters: Type.Object({
+                thesisId: Type.String({ description: 'Thesis ID' }),
+                strategyId: Type.String({ description: 'Strategy ID (UUID)' }),
+                stopLoss: Type.Optional(Type.Number({ description: 'New stop loss (cents)' })),
+                takeProfit: Type.Optional(Type.Number({ description: 'New take profit (cents)' })),
+                entryBelow: Type.Optional(Type.Number({ description: 'New entry below trigger (cents)' })),
+                entryAbove: Type.Optional(Type.Number({ description: 'New entry above trigger (cents)' })),
+                status: Type.Optional(Type.String({ description: 'New status: active|watching|executed|cancelled|review' })),
+                priority: Type.Optional(Type.Number({ description: 'New priority' })),
+                softConditions: Type.Optional(Type.String({ description: 'Updated soft conditions' })),
+                rationale: Type.Optional(Type.String({ description: 'Updated rationale' })),
+            }),
+            execute: async (_toolCallId, params) => {
+                const { thesisId, strategyId, ...updates } = params;
+                const result = await sfClient.updateStrategyAPI(thesisId, strategyId, updates);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }], details: {} };
+            },
+        },
+        {
+            name: 'get_milestones',
+            label: 'Milestones',
+            description: 'Get upcoming events from Kalshi calendar. Use to check economic releases, political events, or other catalysts coming up that might affect the thesis.',
+            parameters: Type.Object({
+                hours: Type.Optional(Type.Number({ description: 'Hours ahead to look (default 168 = 1 week)' })),
+                category: Type.Optional(Type.String({ description: 'Filter by category (e.g. Economics, Politics, Sports)' })),
+            }),
+            execute: async (_toolCallId, params) => {
+                const hours = params.hours || 168;
+                const now = new Date();
+                const url = `https://api.elections.kalshi.com/trade-api/v2/milestones?limit=200&minimum_start_date=${now.toISOString()}` +
+                    (params.category ? `&category=${params.category}` : '');
+                const res = await fetch(url, { headers: { 'Accept': 'application/json' } });
+                if (!res.ok)
+                    return { content: [{ type: 'text', text: `Milestones API error: ${res.status}` }], details: {} };
+                const data = await res.json();
+                const cutoff = now.getTime() + hours * 3600000;
+                const filtered = (data.milestones || [])
+                    .filter((m) => new Date(m.start_date).getTime() <= cutoff)
+                    .slice(0, 30)
+                    .map((m) => ({
+                    title: m.title,
+                    category: m.category,
+                    start_date: m.start_date,
+                    related_event_tickers: m.related_event_tickers,
+                    hours_until: Math.round((new Date(m.start_date).getTime() - now.getTime()) / 3600000),
+                }));
+                return { content: [{ type: 'text', text: JSON.stringify(filtered, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_forecast',
+            label: 'Forecast',
+            description: 'Get market distribution (P50/P75/P90 percentile history) for a Kalshi event. Shows how market consensus has shifted over time.',
+            parameters: Type.Object({
+                eventTicker: Type.String({ description: 'Kalshi event ticker (e.g. KXWTIMAX-26DEC31)' }),
+                days: Type.Optional(Type.Number({ description: 'Days of history (default 7)' })),
+            }),
+            execute: async (_toolCallId, params) => {
+                const { getForecastHistory } = await import('../kalshi.js');
+                const days = params.days || 7;
+                // Get series ticker from event
+                const evtRes = await fetch(`https://api.elections.kalshi.com/trade-api/v2/events/${params.eventTicker}`, { headers: { 'Accept': 'application/json' } });
+                if (!evtRes.ok)
+                    return { content: [{ type: 'text', text: `Event not found: ${params.eventTicker}` }], details: {} };
+                const evtData = await evtRes.json();
+                const seriesTicker = evtData.event?.series_ticker;
+                if (!seriesTicker)
+                    return { content: [{ type: 'text', text: `No series_ticker for ${params.eventTicker}` }], details: {} };
+                const history = await getForecastHistory({
+                    seriesTicker,
+                    eventTicker: params.eventTicker,
+                    percentiles: [5000, 7500, 9000],
+                    startTs: Math.floor((Date.now() - days * 86400000) / 1000),
+                    endTs: Math.floor(Date.now() / 1000),
+                    periodInterval: 1440,
+                });
+                if (!history || history.length === 0)
+                    return { content: [{ type: 'text', text: 'No forecast data available' }], details: {} };
+                return { content: [{ type: 'text', text: JSON.stringify(history, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_settlements',
+            label: 'Settlements',
+            description: 'Get settled (resolved) contracts with P&L. Shows which contracts won/lost and realized returns.',
+            parameters: Type.Object({
+                ticker: Type.Optional(Type.String({ description: 'Filter by market ticker' })),
+            }),
+            execute: async (_toolCallId, params) => {
+                const { getSettlements } = await import('../kalshi.js');
+                const result = await getSettlements({ limit: 100, ticker: params.ticker });
+                if (!result)
+                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
+                return { content: [{ type: 'text', text: JSON.stringify(result.settlements, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_balance',
+            label: 'Balance',
+            description: 'Get Kalshi account balance and portfolio value.',
+            parameters: emptyParams,
+            execute: async () => {
+                const { getBalance } = await import('../kalshi.js');
+                const result = await getBalance();
+                if (!result)
+                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_orders',
+            label: 'Orders',
+            description: 'Get current resting orders on Kalshi.',
+            parameters: Type.Object({
+                status: Type.Optional(Type.String({ description: 'Filter by status: resting, canceled, executed. Default: resting' })),
+            }),
+            execute: async (_toolCallId, params) => {
+                const { getOrders } = await import('../kalshi.js');
+                const result = await getOrders({ status: params.status || 'resting', limit: 100 });
+                if (!result)
+                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
+                return { content: [{ type: 'text', text: JSON.stringify(result.orders, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_fills',
+            label: 'Fills',
+            description: 'Get recent trade fills (executed trades) on Kalshi.',
+            parameters: Type.Object({
+                ticker: Type.Optional(Type.String({ description: 'Filter by market ticker' })),
+            }),
+            execute: async (_toolCallId, params) => {
+                const { getFills } = await import('../kalshi.js');
+                const result = await getFills({ ticker: params.ticker, limit: 50 });
+                if (!result)
+                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
+                return { content: [{ type: 'text', text: JSON.stringify(result.fills, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_schedule',
+            label: 'Schedule',
+            description: 'Get exchange status (open/closed) and trading hours. Use to check if low liquidity is due to off-hours.',
+            parameters: emptyParams,
+            execute: async () => {
+                try {
+                    const res = await fetch('https://api.elections.kalshi.com/trade-api/v2/exchange/status', { headers: { 'Accept': 'application/json' } });
+                    if (!res.ok)
+                        return { content: [{ type: 'text', text: `Exchange API error: ${res.status}` }], details: {} };
+                    const data = await res.json();
+                    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
+                }
+                catch (err) {
+                    return { content: [{ type: 'text', text: `Failed: ${err.message}` }], details: {} };
+                }
+            },
+        },
     ];
+    // ── 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) {
+        tools.push({
+            name: 'place_order',
+            label: 'Place Order',
+            description: 'Place a buy or sell order on Kalshi. Shows a preview and asks for user confirmation before executing. Use for limit or market orders.',
+            parameters: Type.Object({
+                ticker: Type.String({ description: 'Market ticker e.g. KXWTIMAX-26DEC31-T135' }),
+                side: Type.String({ description: 'yes or no' }),
+                action: Type.String({ description: 'buy or sell' }),
+                type: Type.String({ description: 'limit or market' }),
+                count: Type.Number({ description: 'Number of contracts' }),
+                price_cents: Type.Optional(Type.Number({ description: 'Limit price in cents (1-99). Required for limit orders.' })),
+            }),
+            execute: async (_toolCallId, params) => {
+                const { createOrder } = await import('../kalshi.js');
+                const priceDollars = params.price_cents ? (params.price_cents / 100).toFixed(2) : undefined;
+                const maxCost = ((params.price_cents || 99) * params.count / 100).toFixed(2);
+                // Show preview
+                const preview = [
+                    C.zinc200(bold('ORDER PREVIEW')),
+                    `  Ticker:   ${params.ticker}`,
+                    `  Side:     ${params.side === 'yes' ? C.emerald('YES') : C.red('NO')}`,
+                    `  Action:   ${params.action.toUpperCase()}`,
+                    `  Quantity: ${params.count}`,
+                    `  Type:     ${params.type}`,
+                    params.price_cents ? `  Price:    ${params.price_cents}\u00A2` : '',
+                    `  Max cost: $${maxCost}`,
+                ].filter(Boolean).join('\n');
+                addSystemText(preview);
+                addSpacer();
+                tui.requestRender();
+                // Ask for confirmation via promptUser
+                const answer = await promptUser('Execute this order? (y/n)');
+                if (!answer.toLowerCase().startsWith('y')) {
+                    return { content: [{ type: 'text', text: 'Order cancelled by user.' }], details: {} };
+                }
+                try {
+                    const result = await createOrder({
+                        ticker: params.ticker,
+                        side: params.side,
+                        action: params.action,
+                        type: params.type,
+                        count: params.count,
+                        ...(priceDollars ? { yes_price: priceDollars } : {}),
+                    });
+                    const order = result.order || result;
+                    return {
+                        content: [{ type: 'text', text: `Order placed: ${order.order_id || 'OK'}\nStatus: ${order.status || '-'}\nFilled: ${order.fill_count_fp || 0}/${order.initial_count_fp || params.count}` }],
+                        details: {},
+                    };
+                }
+                catch (err) {
+                    const msg = err.message || String(err);
+                    if (msg.includes('403')) {
+                        return { content: [{ type: 'text', text: '403 Forbidden \u2014 your Kalshi key lacks write permission. Get a read+write key at kalshi.com/account/api-keys' }], details: {} };
+                    }
+                    return { content: [{ type: 'text', text: `Order failed: ${msg}` }], details: {} };
+                }
+            },
+        }, {
+            name: 'cancel_order',
+            label: 'Cancel Order',
+            description: 'Cancel a resting order by order ID.',
+            parameters: Type.Object({
+                order_id: Type.String({ description: 'Order ID to cancel' }),
+            }),
+            execute: async (_toolCallId, params) => {
+                const { cancelOrder } = await import('../kalshi.js');
+                const answer = await promptUser(`Cancel order ${params.order_id}? (y/n)`);
+                if (!answer.toLowerCase().startsWith('y')) {
+                    return { content: [{ type: 'text', text: 'Cancel aborted by user.' }], details: {} };
+                }
+                try {
+                    await cancelOrder(params.order_id);
+                    return { content: [{ type: 'text', text: `Order ${params.order_id} cancelled.` }], details: {} };
+                }
+                catch (err) {
+                    return { content: [{ type: 'text', text: `Cancel failed: ${err.message}` }], details: {} };
+                }
+            },
+        });
+    }
     // ── System prompt builder ──────────────────────────────────────────────────
     function buildSystemPrompt(ctx) {
         const edgesSummary = ctx.edges
@@ -677,6 +1190,15 @@ Short-term markets (weekly/monthly contracts) settle into hard data that calibra
 - 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.
 
+## Strategy rules
+
+When the conversation produces a concrete trade idea (specific contract, direction, price conditions), use create_strategy to record it immediately. Don't wait for the user to say "record this."
+- Extract hard conditions (specific prices in cents) into entryBelow/stopLoss/takeProfit.
+- Put fuzzy conditions into softConditions (e.g. "only if n3 > 60%", "spread < 3¢").
+- Put the full reasoning into rationale.
+- After creating, confirm the strategy details and mention that sf runtime --dangerous can execute it.
+- If the user says "change the stop loss on T150 to 30", use update_strategy.
+
 ## Current thesis state
 
 Thesis: ${ctx.thesis || ctx.rawThesis || 'N/A'}
@@ -853,6 +1375,11 @@ ${ctx.lastEvaluation?.summary ? `Latest evaluation summary: ${ctx.lastEvaluation
                     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' +
+                    (config.tradingEnabled ? (C.zinc600('\u2500'.repeat(30)) + '\n' +
+                        C.emerald('/buy       ') + C.zinc400('TICKER QTY PRICE \u2014 quick buy') + '\n' +
+                        C.emerald('/sell      ') + C.zinc400('TICKER QTY PRICE \u2014 quick sell') + '\n' +
+                        C.emerald('/cancel    ') + C.zinc400('ORDER_ID \u2014 cancel order') + '\n' +
+                        C.zinc600('\u2500'.repeat(30)) + '\n') : '') +
                     C.emerald('/clear     ') + C.zinc400('Clear screen (keeps history)') + '\n' +
                     C.emerald('/exit      ') + C.zinc400('Exit (auto-saves)'));
                 addSpacer();
@@ -936,7 +1463,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();
@@ -976,13 +1504,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}`));
@@ -1195,6 +1719,93 @@ Output a structured summary. Be concise but preserve every important detail —
                 tui.requestRender();
                 return true;
             }
+            case '/buy': {
+                // /buy TICKER QTY PRICE — quick trade without LLM
+                const [, ticker, qtyStr, priceStr] = parts;
+                if (!ticker || !qtyStr || !priceStr) {
+                    addSystemText(C.zinc400('Usage: /buy TICKER QTY PRICE_CENTS  (e.g. /buy KXWTIMAX-26DEC31-T135 100 50)'));
+                    return true;
+                }
+                if (!config.tradingEnabled) {
+                    addSystemText(C.red('Trading disabled. Run: sf setup --enable-trading'));
+                    return true;
+                }
+                addSpacer();
+                const answer = await promptUser(`BUY ${qtyStr}x ${ticker} YES @ ${priceStr}\u00A2 — execute? (y/n)`);
+                if (answer.toLowerCase().startsWith('y')) {
+                    try {
+                        const { createOrder } = await import('../kalshi.js');
+                        const result = await createOrder({
+                            ticker, side: 'yes', action: 'buy', type: 'limit',
+                            count: parseInt(qtyStr),
+                            yes_price: (parseInt(priceStr) / 100).toFixed(2),
+                        });
+                        addSystemText(C.emerald('\u2713 Order placed: ' + ((result.order || result).order_id || 'OK')));
+                    }
+                    catch (err) {
+                        addSystemText(C.red('\u2717 ' + err.message));
+                    }
+                }
+                else {
+                    addSystemText(C.zinc400('Cancelled.'));
+                }
+                addSpacer();
+                return true;
+            }
+            case '/sell': {
+                const [, ticker, qtyStr, priceStr] = parts;
+                if (!ticker || !qtyStr || !priceStr) {
+                    addSystemText(C.zinc400('Usage: /sell TICKER QTY PRICE_CENTS'));
+                    return true;
+                }
+                if (!config.tradingEnabled) {
+                    addSystemText(C.red('Trading disabled. Run: sf setup --enable-trading'));
+                    return true;
+                }
+                addSpacer();
+                const answer = await promptUser(`SELL ${qtyStr}x ${ticker} YES @ ${priceStr}\u00A2 — execute? (y/n)`);
+                if (answer.toLowerCase().startsWith('y')) {
+                    try {
+                        const { createOrder } = await import('../kalshi.js');
+                        const result = await createOrder({
+                            ticker, side: 'yes', action: 'sell', type: 'limit',
+                            count: parseInt(qtyStr),
+                            yes_price: (parseInt(priceStr) / 100).toFixed(2),
+                        });
+                        addSystemText(C.emerald('\u2713 Order placed: ' + ((result.order || result).order_id || 'OK')));
+                    }
+                    catch (err) {
+                        addSystemText(C.red('\u2717 ' + err.message));
+                    }
+                }
+                else {
+                    addSystemText(C.zinc400('Cancelled.'));
+                }
+                addSpacer();
+                return true;
+            }
+            case '/cancel': {
+                const [, orderId] = parts;
+                if (!orderId) {
+                    addSystemText(C.zinc400('Usage: /cancel ORDER_ID'));
+                    return true;
+                }
+                if (!config.tradingEnabled) {
+                    addSystemText(C.red('Trading disabled. Run: sf setup --enable-trading'));
+                    return true;
+                }
+                addSpacer();
+                try {
+                    const { cancelOrder } = await import('../kalshi.js');
+                    await cancelOrder(orderId);
+                    addSystemText(C.emerald(`\u2713 Order ${orderId} cancelled.`));
+                }
+                catch (err) {
+                    addSystemText(C.red('\u2717 ' + err.message));
+                }
+                addSpacer();
+                return true;
+            }
             case '/exit':
             case '/quit': {
                 cleanup();
@@ -1209,6 +1820,17 @@ Output a structured summary. Be concise but preserve every important detail —
         const trimmed = input.trim();
         if (!trimmed)
             return;
+        // If a tool is waiting for user confirmation, resolve it
+        if (pendingPrompt) {
+            const { resolve } = pendingPrompt;
+            pendingPrompt = null;
+            const userResponse = new Text(C.zinc400('  > ') + C.zinc200(trimmed), 1, 0);
+            chatContainer.addChild(userResponse);
+            addSpacer();
+            tui.requestRender();
+            resolve(trimmed);
+            return;
+        }
         if (isProcessing)
             return;
         // Add to editor history
@@ -1261,17 +1883,489 @@ 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();
     // ── Start TUI ──────────────────────────────────────────────────────────────
     tui.start();
 }
+// ============================================================================
+// PLAIN-TEXT MODE (--no-tui)
+// ============================================================================
+async function runPlainTextAgent(params) {
+    const { openrouterKey, sfClient, resolvedThesisId, opts } = params;
+    let latestContext = params.latestContext;
+    const readline = await import('readline');
+    const piAi = await import('@mariozechner/pi-ai');
+    const piAgent = await import('@mariozechner/pi-agent-core');
+    const { getModel, streamSimple, Type } = piAi;
+    const { Agent } = piAgent;
+    const rawModelName = opts?.model || 'anthropic/claude-sonnet-4.6';
+    let currentModelName = rawModelName.replace(/^openrouter\//, '');
+    function resolveModel(name) {
+        try {
+            return getModel('openrouter', name);
+        }
+        catch {
+            return {
+                modelId: name, provider: 'openrouter', api: 'openai-completions',
+                baseUrl: 'https://openrouter.ai/api/v1', id: name, name,
+                inputPrice: 0, outputPrice: 0, contextWindow: 200000,
+                supportsImages: true, supportsTools: true,
+            };
+        }
+    }
+    let model = resolveModel(currentModelName);
+    // ── Tools (same definitions as TUI mode) ──────────────────────────────────
+    const thesisIdParam = Type.Object({ thesisId: Type.String({ description: 'Thesis ID' }) });
+    const signalParams = Type.Object({
+        thesisId: Type.String({ description: 'Thesis ID' }),
+        content: Type.String({ description: 'Signal content' }),
+        type: Type.Optional(Type.String({ description: 'Signal type: news, user_note, external' })),
+    });
+    const scanParams = Type.Object({
+        query: Type.Optional(Type.String({ description: 'Keyword search' })),
+        series: Type.Optional(Type.String({ description: 'Series ticker' })),
+        market: Type.Optional(Type.String({ description: 'Market ticker' })),
+    });
+    const webSearchParams = Type.Object({ query: Type.String({ description: 'Search keywords' }) });
+    const emptyParams = Type.Object({});
+    const tools = [
+        {
+            name: 'get_context', label: 'Get Context',
+            description: 'Get thesis snapshot: causal tree, edge prices, last evaluation, confidence',
+            parameters: thesisIdParam,
+            execute: async (_id, p) => {
+                const ctx = await sfClient.getContext(p.thesisId);
+                latestContext = ctx;
+                return { content: [{ type: 'text', text: JSON.stringify(ctx, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'inject_signal', label: 'Inject Signal',
+            description: 'Inject a signal into the thesis',
+            parameters: signalParams,
+            execute: async (_id, p) => {
+                const result = await sfClient.injectSignal(p.thesisId, p.type || 'user_note', p.content);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }], details: {} };
+            },
+        },
+        {
+            name: 'trigger_evaluation', label: 'Evaluate',
+            description: 'Trigger a deep evaluation cycle',
+            parameters: thesisIdParam,
+            execute: async (_id, p) => {
+                const result = await sfClient.evaluate(p.thesisId);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }], details: {} };
+            },
+        },
+        {
+            name: 'scan_markets', label: 'Scan Markets',
+            description: 'Search Kalshi prediction markets',
+            parameters: scanParams,
+            execute: async (_id, p) => {
+                let result;
+                if (p.market) {
+                    result = await (0, client_js_1.kalshiFetchMarket)(p.market);
+                }
+                else if (p.series) {
+                    result = await (0, client_js_1.kalshiFetchMarketsBySeries)(p.series);
+                }
+                else if (p.query) {
+                    const series = await (0, client_js_1.kalshiFetchAllSeries)();
+                    const kws = p.query.toLowerCase().split(/\s+/);
+                    result = series.filter((s) => kws.every((k) => ((s.title || '') + (s.ticker || '')).toLowerCase().includes(k))).slice(0, 15);
+                }
+                else {
+                    result = { error: 'Provide query, series, or market' };
+                }
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'list_theses', label: 'List Theses',
+            description: 'List all theses',
+            parameters: emptyParams,
+            execute: async () => {
+                const theses = await sfClient.listTheses();
+                return { content: [{ type: 'text', text: JSON.stringify(theses, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_positions', label: 'Get Positions',
+            description: 'Get Kalshi positions with live prices',
+            parameters: emptyParams,
+            execute: async () => {
+                const positions = await (0, kalshi_js_1.getPositions)();
+                if (!positions)
+                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
+                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);
+                    }
+                }
+                return { content: [{ type: 'text', text: JSON.stringify(positions, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'web_search', label: 'Web Search',
+            description: 'Search latest news and information',
+            parameters: webSearchParams,
+            execute: async (_id, p) => {
+                const apiKey = process.env.TAVILY_API_KEY;
+                if (!apiKey)
+                    return { content: [{ type: 'text', text: 'Tavily not configured. Set TAVILY_API_KEY.' }], details: {} };
+                const res = await fetch('https://api.tavily.com/search', {
+                    method: 'POST', headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ api_key: apiKey, query: p.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: {} };
+            },
+        },
+        {
+            name: 'get_milestones', label: 'Milestones',
+            description: 'Get upcoming events from Kalshi calendar. Use to check economic releases, political events, or other catalysts.',
+            parameters: Type.Object({
+                hours: Type.Optional(Type.Number({ description: 'Hours ahead to look (default 168 = 1 week)' })),
+                category: Type.Optional(Type.String({ description: 'Filter by category (e.g. Economics, Politics, Sports)' })),
+            }),
+            execute: async (_id, p) => {
+                const hours = p.hours || 168;
+                const now = new Date();
+                const url = `https://api.elections.kalshi.com/trade-api/v2/milestones?limit=200&minimum_start_date=${now.toISOString()}` +
+                    (p.category ? `&category=${p.category}` : '');
+                const res = await fetch(url, { headers: { 'Accept': 'application/json' } });
+                if (!res.ok)
+                    return { content: [{ type: 'text', text: `Milestones API error: ${res.status}` }], details: {} };
+                const data = await res.json();
+                const cutoff = now.getTime() + hours * 3600000;
+                const filtered = (data.milestones || [])
+                    .filter((m) => new Date(m.start_date).getTime() <= cutoff)
+                    .slice(0, 30)
+                    .map((m) => ({
+                    title: m.title, category: m.category, start_date: m.start_date,
+                    related_event_tickers: m.related_event_tickers,
+                    hours_until: Math.round((new Date(m.start_date).getTime() - now.getTime()) / 3600000),
+                }));
+                return { content: [{ type: 'text', text: JSON.stringify(filtered, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_forecast', label: 'Forecast',
+            description: 'Get market distribution (P50/P75/P90 percentile history) for a Kalshi event.',
+            parameters: Type.Object({
+                eventTicker: Type.String({ description: 'Kalshi event ticker (e.g. KXWTIMAX-26DEC31)' }),
+                days: Type.Optional(Type.Number({ description: 'Days of history (default 7)' })),
+            }),
+            execute: async (_id, p) => {
+                const { getForecastHistory } = await import('../kalshi.js');
+                const days = p.days || 7;
+                const evtRes = await fetch(`https://api.elections.kalshi.com/trade-api/v2/events/${p.eventTicker}`, { headers: { 'Accept': 'application/json' } });
+                if (!evtRes.ok)
+                    return { content: [{ type: 'text', text: `Event not found: ${p.eventTicker}` }], details: {} };
+                const evtData = await evtRes.json();
+                const seriesTicker = evtData.event?.series_ticker;
+                if (!seriesTicker)
+                    return { content: [{ type: 'text', text: `No series_ticker for ${p.eventTicker}` }], details: {} };
+                const history = await getForecastHistory({
+                    seriesTicker, eventTicker: p.eventTicker, percentiles: [5000, 7500, 9000],
+                    startTs: Math.floor((Date.now() - days * 86400000) / 1000),
+                    endTs: Math.floor(Date.now() / 1000), periodInterval: 1440,
+                });
+                if (!history || history.length === 0)
+                    return { content: [{ type: 'text', text: 'No forecast data available' }], details: {} };
+                return { content: [{ type: 'text', text: JSON.stringify(history, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_settlements', label: 'Settlements',
+            description: 'Get settled (resolved) contracts with P&L.',
+            parameters: Type.Object({ ticker: Type.Optional(Type.String({ description: 'Filter by market ticker' })) }),
+            execute: async (_id, p) => {
+                const { getSettlements } = await import('../kalshi.js');
+                const result = await getSettlements({ limit: 100, ticker: p.ticker });
+                if (!result)
+                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
+                return { content: [{ type: 'text', text: JSON.stringify(result.settlements, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_balance', label: 'Balance',
+            description: 'Get Kalshi account balance and portfolio value.',
+            parameters: emptyParams,
+            execute: async () => {
+                const { getBalance } = await import('../kalshi.js');
+                const result = await getBalance();
+                if (!result)
+                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_orders', label: 'Orders',
+            description: 'Get current resting orders on Kalshi.',
+            parameters: Type.Object({ status: Type.Optional(Type.String({ description: 'Filter by status: resting, canceled, executed. Default: resting' })) }),
+            execute: async (_id, p) => {
+                const { getOrders } = await import('../kalshi.js');
+                const result = await getOrders({ status: p.status || 'resting', limit: 100 });
+                if (!result)
+                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
+                return { content: [{ type: 'text', text: JSON.stringify(result.orders, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_fills', label: 'Fills',
+            description: 'Get recent trade fills (executed trades) on Kalshi.',
+            parameters: Type.Object({ ticker: Type.Optional(Type.String({ description: 'Filter by market ticker' })) }),
+            execute: async (_id, p) => {
+                const { getFills } = await import('../kalshi.js');
+                const result = await getFills({ ticker: p.ticker, limit: 50 });
+                if (!result)
+                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
+                return { content: [{ type: 'text', text: JSON.stringify(result.fills, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_schedule',
+            label: 'Schedule',
+            description: 'Get exchange status (open/closed) and trading hours. Use to check if low liquidity is due to off-hours.',
+            parameters: emptyParams,
+            execute: async () => {
+                try {
+                    const res = await fetch('https://api.elections.kalshi.com/trade-api/v2/exchange/status', { headers: { 'Accept': 'application/json' } });
+                    if (!res.ok)
+                        return { content: [{ type: 'text', text: `Exchange API error: ${res.status}` }], details: {} };
+                    const data = await res.json();
+                    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
+                }
+                catch (err) {
+                    return { content: [{ type: 'text', text: `Failed: ${err.message}` }], details: {} };
+                }
+            },
+        },
+    ];
+    // ── System prompt ─────────────────────────────────────────────────────────
+    const ctx = latestContext;
+    const edgesSummary = ctx.edges
+        ?.sort((a, b) => Math.abs(b.edge) - Math.abs(a.edge))
+        .slice(0, 5)
+        .map((e) => `  ${(e.market || '').slice(0, 40)} | ${e.venue || 'kalshi'} | mkt ${e.marketPrice}\u00A2 | edge ${e.edge > 0 ? '+' : ''}${e.edge}`)
+        .join('\n') || '  (no edges)';
+    const nodesSummary = ctx.causalTree?.nodes
+        ?.filter((n) => n.depth === 0)
+        .map((n) => `  ${n.id} ${(n.label || '').slice(0, 40)} \u2014 ${Math.round(n.probability * 100)}%`)
+        .join('\n') || '  (no causal tree)';
+    const conf = typeof ctx.confidence === 'number' ? Math.round(ctx.confidence * 100) : 0;
+    const systemPrompt = `You are a prediction market trading assistant. Help the user make correct trading decisions.
+
+Current thesis: ${ctx.thesis || ctx.rawThesis || 'N/A'}
+ID: ${resolvedThesisId}
+Confidence: ${conf}%
+Status: ${ctx.status}
+
+Causal tree nodes:
+${nodesSummary}
+
+Top edges:
+${edgesSummary}
+
+${ctx.lastEvaluation?.summary ? `Latest evaluation: ${ctx.lastEvaluation.summary.slice(0, 300)}` : ''}
+
+Rules: Be concise. Use tools when needed. Don't ask "anything else?".`;
+    // ── Create agent ──────────────────────────────────────────────────────────
+    const agent = new Agent({
+        initialState: { systemPrompt, model, tools, thinkingLevel: 'off' },
+        streamFn: streamSimple,
+        getApiKey: (provider) => provider === 'openrouter' ? openrouterKey : undefined,
+    });
+    // ── Session restore ───────────────────────────────────────────────────────
+    if (!opts?.newSession) {
+        const saved = loadSession(resolvedThesisId);
+        if (saved?.messages?.length > 0) {
+            try {
+                agent.replaceMessages(saved.messages);
+                agent.setSystemPrompt(systemPrompt);
+            }
+            catch { /* start fresh */ }
+        }
+    }
+    // ── Subscribe to agent events → plain stdout ──────────────────────────────
+    let currentText = '';
+    agent.subscribe((event) => {
+        if (event.type === 'message_update') {
+            const e = event.assistantMessageEvent;
+            if (e.type === 'text_delta') {
+                process.stdout.write(e.delta);
+                currentText += e.delta;
+            }
+        }
+        if (event.type === 'message_end') {
+            if (currentText) {
+                process.stdout.write('\n');
+                currentText = '';
+            }
+        }
+        if (event.type === 'tool_execution_start') {
+            process.stderr.write(`  \u26A1 ${event.toolName}...\n`);
+        }
+        if (event.type === 'tool_execution_end') {
+            const status = event.isError ? '\u2717' : '\u2713';
+            process.stderr.write(`  ${status} ${event.toolName}\n`);
+        }
+    });
+    // ── Welcome ───────────────────────────────────────────────────────────────
+    const thesisText = ctx.thesis || ctx.rawThesis || 'N/A';
+    console.log(`SF Agent — ${resolvedThesisId.slice(0, 8)} | ${conf}% | ${currentModelName}`);
+    console.log(`Thesis: ${thesisText.length > 100 ? thesisText.slice(0, 100) + '...' : thesisText}`);
+    console.log(`Edges: ${(ctx.edges || []).length} | Status: ${ctx.status}`);
+    console.log('Type /help for commands, /exit to quit.\n');
+    // ── REPL loop ─────────────────────────────────────────────────────────────
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: '> ' });
+    rl.prompt();
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            rl.prompt();
+            continue;
+        }
+        if (trimmed === '/exit' || trimmed === '/quit') {
+            try {
+                saveSession(resolvedThesisId, currentModelName, agent.state.messages);
+            }
+            catch { }
+            rl.close();
+            return;
+        }
+        if (trimmed === '/help') {
+            console.log('Commands: /help /exit /tree /edges /eval /model <name>');
+            rl.prompt();
+            continue;
+        }
+        if (trimmed === '/tree') {
+            latestContext = await sfClient.getContext(resolvedThesisId);
+            const nodes = latestContext.causalTree?.nodes || [];
+            for (const n of nodes) {
+                const indent = '  '.repeat(n.depth || 0);
+                console.log(`${indent}${n.id} ${(n.label || '').slice(0, 60)} — ${Math.round(n.probability * 100)}%`);
+            }
+            rl.prompt();
+            continue;
+        }
+        if (trimmed === '/edges') {
+            latestContext = await sfClient.getContext(resolvedThesisId);
+            const edges = (latestContext.edges || []).sort((a, b) => Math.abs(b.edge) - Math.abs(a.edge)).slice(0, 15);
+            for (const e of edges) {
+                const sign = e.edge > 0 ? '+' : '';
+                console.log(`  ${(e.market || '').slice(0, 45).padEnd(45)} ${e.marketPrice}¢  edge ${sign}${e.edge}  ${e.venue}`);
+            }
+            rl.prompt();
+            continue;
+        }
+        if (trimmed === '/eval') {
+            console.log('Triggering evaluation...');
+            const result = await sfClient.evaluate(resolvedThesisId);
+            console.log(`Confidence: ${result.previousConfidence} → ${result.newConfidence}`);
+            if (result.summary)
+                console.log(result.summary);
+            rl.prompt();
+            continue;
+        }
+        if (trimmed.startsWith('/model')) {
+            const newModel = trimmed.slice(6).trim();
+            if (!newModel) {
+                console.log(`Current: ${currentModelName}`);
+                rl.prompt();
+                continue;
+            }
+            currentModelName = newModel.replace(/^openrouter\//, '');
+            model = resolveModel(currentModelName);
+            agent.setModel(model);
+            console.log(`Model: ${currentModelName}`);
+            rl.prompt();
+            continue;
+        }
+        // Regular message → agent
+        try {
+            await agent.prompt(trimmed);
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+        }
+        // Save after each turn
+        try {
+            saveSession(resolvedThesisId, currentModelName, agent.state.messages);
+        }
+        catch { }
+        rl.prompt();
+    }
+}