@spfunctions/cli 1.1.5 → 1.1.6

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');
@@ -286,23 +287,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 +332,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 +378,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);
@@ -395,7 +428,7 @@ async function agentCommand(thesisId, opts) {
     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 +441,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 +477,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)' }),
@@ -636,7 +688,303 @@ 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: {} };
+                }
+            },
+        },
     ];
+    // ── 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 +1025,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 +1210,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();
@@ -1195,6 +1557,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 +1658,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
@@ -1275,3 +1735,420 @@ Output a structured summary. Be concise but preserve every important detail —
     // ── 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();
+    }
+}