@spfunctions/cli 1.1.9 → 1.3.0

package/dist/commands/agent.js

@@ -1007,6 +1007,73 @@ async function agentCommand(thesisId, opts) {
                 }
             },
         },
+        {
+            name: 'create_thesis',
+            label: 'Create Thesis',
+            description: 'Create a new thesis from a raw thesis statement. Returns the thesis ID, confidence, node count, and edge count.',
+            parameters: Type.Object({
+                rawThesis: Type.String({ description: 'The raw thesis statement to create' }),
+                webhookUrl: Type.Optional(Type.String({ description: 'Optional webhook URL for notifications' })),
+            }),
+            execute: async (_toolCallId, params) => {
+                const result = await sfClient.createThesis(params.rawThesis, true);
+                const thesis = result.thesis || result;
+                const nodeCount = thesis.causalTree?.nodes?.length || 0;
+                const edgeCount = (thesis.edges || []).length;
+                const confidence = typeof thesis.confidence === 'number' ? Math.round(thesis.confidence * 100) : 0;
+                return {
+                    content: [{ type: 'text', text: `Thesis created.\nID: ${thesis.id}\nConfidence: ${confidence}%\nNodes: ${nodeCount}\nEdges: ${edgeCount}` }],
+                    details: {},
+                };
+            },
+        },
+        {
+            name: 'get_edges',
+            label: 'Get Edges',
+            description: 'Get top edges across all active theses. Returns the top 10 edges sorted by absolute edge size with ticker, market name, edge size, direction, and venue.',
+            parameters: emptyParams,
+            execute: async () => {
+                const { theses } = await sfClient.listTheses();
+                const activeTheses = (theses || []).filter((t) => t.status === 'active' || t.status === 'monitoring');
+                const allEdges = [];
+                for (const t of activeTheses) {
+                    try {
+                        const ctx = await sfClient.getContext(t.id);
+                        for (const edge of (ctx.edges || [])) {
+                            allEdges.push({ ...edge, thesisId: t.id });
+                        }
+                    }
+                    catch { /* skip inaccessible theses */ }
+                }
+                allEdges.sort((a, b) => Math.abs(b.edge || b.edgeSize || 0) - Math.abs(a.edge || a.edgeSize || 0));
+                const top10 = allEdges.slice(0, 10).map((e) => ({
+                    ticker: e.marketId || e.ticker || '-',
+                    market: e.market || e.marketTitle || '-',
+                    edge: e.edge || e.edgeSize || 0,
+                    direction: e.direction || 'yes',
+                    venue: e.venue || 'kalshi',
+                }));
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(top10, null, 2) }],
+                    details: {},
+                };
+            },
+        },
+        {
+            name: 'get_feed',
+            label: 'Get Feed',
+            description: 'Get evaluation history / activity feed. Shows recent evaluations, signals, and changes across theses.',
+            parameters: Type.Object({
+                hours: Type.Optional(Type.Number({ description: 'Hours of history to fetch (default 24)' })),
+            }),
+            execute: async (_toolCallId, params) => {
+                const result = await sfClient.getFeed(params.hours || 24);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                    details: {},
+                };
+            },
+        },
     ];
     // ── What-if tool (always available) ────────────────────────────────────────
     tools.push({
@@ -1100,8 +1167,8 @@ async function agentCommand(thesisId, opts) {
             }),
             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);
+                const priceCents = params.price_cents ? Math.round(Number(params.price_cents)) : undefined;
+                const maxCost = ((priceCents || 99) * params.count / 100).toFixed(2);
                 // Show preview
                 const preview = [
                     C.zinc200(bold('ORDER PREVIEW')),
@@ -1110,7 +1177,7 @@ async function agentCommand(thesisId, opts) {
                     `  Action:   ${params.action.toUpperCase()}`,
                     `  Quantity: ${params.count}`,
                     `  Type:     ${params.type}`,
-                    params.price_cents ? `  Price:    ${params.price_cents}\u00A2` : '',
+                    priceCents ? `  Price:    ${priceCents}\u00A2` : '',
                     `  Max cost: $${maxCost}`,
                 ].filter(Boolean).join('\n');
                 addSystemText(preview);
@@ -1128,7 +1195,7 @@ async function agentCommand(thesisId, opts) {
                         action: params.action,
                         type: params.type,
                         count: params.count,
-                        ...(priceDollars ? { yes_price: priceDollars } : {}),
+                        ...(priceCents ? { yes_price: priceCents } : {}),
                     });
                     const order = result.order || result;
                     return {
@@ -1217,6 +1284,10 @@ When the conversation produces a concrete trade idea (specific contract, directi
 - 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.
 
+## Trading status
+
+${config.tradingEnabled ? 'Trading is ENABLED. You have place_order and cancel_order tools.' : 'Trading is DISABLED. You cannot place or cancel orders. Tell the user to run `sf setup --enable-trading` to unlock trading.'}
+
 ## Current thesis state
 
 Thesis: ${ctx.thesis || ctx.rawThesis || 'N/A'}
@@ -1762,7 +1833,7 @@ Output a structured summary. Be concise but preserve every important detail —
                         const result = await createOrder({
                             ticker, side: 'yes', action: 'buy', type: 'limit',
                             count: parseInt(qtyStr),
-                            yes_price: (parseInt(priceStr) / 100).toFixed(2),
+                            yes_price: parseInt(priceStr),
                         });
                         addSystemText(C.emerald('\u2713 Order placed: ' + ((result.order || result).order_id || 'OK')));
                     }
@@ -1794,7 +1865,7 @@ Output a structured summary. Be concise but preserve every important detail —
                         const result = await createOrder({
                             ticker, side: 'yes', action: 'sell', type: 'limit',
                             count: parseInt(qtyStr),
-                            yes_price: (parseInt(priceStr) / 100).toFixed(2),
+                            yes_price: parseInt(priceStr),
                         });
                         addSystemText(C.emerald('\u2713 Order placed: ' + ((result.order || result).order_id || 'OK')));
                     }
@@ -2299,7 +2370,305 @@ async function runPlainTextAgent(params) {
                 }
             },
         },
+        {
+            name: 'create_thesis',
+            label: 'Create Thesis',
+            description: 'Create a new thesis from a raw thesis statement. Returns the thesis ID, confidence, node count, and edge count.',
+            parameters: Type.Object({
+                rawThesis: Type.String({ description: 'The raw thesis statement to create' }),
+                webhookUrl: Type.Optional(Type.String({ description: 'Optional webhook URL for notifications' })),
+            }),
+            execute: async (_id, p) => {
+                const result = await sfClient.createThesis(p.rawThesis, true);
+                const thesis = result.thesis || result;
+                const nodeCount = thesis.causalTree?.nodes?.length || 0;
+                const edgeCount = (thesis.edges || []).length;
+                const confidence = typeof thesis.confidence === 'number' ? Math.round(thesis.confidence * 100) : 0;
+                return {
+                    content: [{ type: 'text', text: `Thesis created.\nID: ${thesis.id}\nConfidence: ${confidence}%\nNodes: ${nodeCount}\nEdges: ${edgeCount}` }],
+                    details: {},
+                };
+            },
+        },
+        {
+            name: 'get_edges',
+            label: 'Get Edges',
+            description: 'Get top edges across all active theses. Returns the top 10 edges sorted by absolute edge size with ticker, market name, edge size, direction, and venue.',
+            parameters: emptyParams,
+            execute: async () => {
+                const { theses } = await sfClient.listTheses();
+                const activeTheses = (theses || []).filter((t) => t.status === 'active' || t.status === 'monitoring');
+                const allEdges = [];
+                for (const t of activeTheses) {
+                    try {
+                        const ctx = await sfClient.getContext(t.id);
+                        for (const edge of (ctx.edges || [])) {
+                            allEdges.push({ ...edge, thesisId: t.id });
+                        }
+                    }
+                    catch { /* skip inaccessible theses */ }
+                }
+                allEdges.sort((a, b) => Math.abs(b.edge || b.edgeSize || 0) - Math.abs(a.edge || a.edgeSize || 0));
+                const top10 = allEdges.slice(0, 10).map((e) => ({
+                    ticker: e.marketId || e.ticker || '-',
+                    market: e.market || e.marketTitle || '-',
+                    edge: e.edge || e.edgeSize || 0,
+                    direction: e.direction || 'yes',
+                    venue: e.venue || 'kalshi',
+                }));
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(top10, null, 2) }],
+                    details: {},
+                };
+            },
+        },
+        {
+            name: 'get_feed',
+            label: 'Get Feed',
+            description: 'Get evaluation history / activity feed. Shows recent evaluations, signals, and changes across theses.',
+            parameters: Type.Object({
+                hours: Type.Optional(Type.Number({ description: 'Hours of history to fetch (default 24)' })),
+            }),
+            execute: async (_id, p) => {
+                const result = await sfClient.getFeed(p.hours || 24);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                    details: {},
+                };
+            },
+        },
+        {
+            name: 'explore_public',
+            label: 'Explore Public Theses',
+            description: 'Browse public theses from other users. No auth required. Pass a slug to get details, or omit to list all.',
+            parameters: Type.Object({
+                slug: Type.Optional(Type.String({ description: 'Specific thesis slug, or empty to list all' })),
+            }),
+            execute: async (_id, p) => {
+                const base = 'https://simplefunctions.dev';
+                if (p.slug) {
+                    const res = await fetch(`${base}/api/public/thesis/${p.slug}`);
+                    if (!res.ok)
+                        return { content: [{ type: 'text', text: `Not found: ${p.slug}` }], details: {} };
+                    const data = await res.json();
+                    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
+                }
+                const res = await fetch(`${base}/api/public/theses`);
+                if (!res.ok)
+                    return { content: [{ type: 'text', text: 'Failed to fetch public theses' }], details: {} };
+                const data = await res.json();
+                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 (_id, p) => {
+                const result = await sfClient.createStrategyAPI(p.thesisId, {
+                    marketId: p.marketId,
+                    market: p.market,
+                    direction: p.direction,
+                    horizon: p.horizon,
+                    entryBelow: p.entryBelow,
+                    entryAbove: p.entryAbove,
+                    stopLoss: p.stopLoss,
+                    takeProfit: p.takeProfit,
+                    maxQuantity: p.maxQuantity,
+                    perOrderQuantity: p.perOrderQuantity,
+                    softConditions: p.softConditions,
+                    rationale: p.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 (_id, p) => {
+                const result = await sfClient.getStrategies(p.thesisId, p.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 (_id, p) => {
+                const { thesisId, strategyId, ...updates } = p;
+                const result = await sfClient.updateStrategyAPI(thesisId, strategyId, updates);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }], details: {} };
+            },
+        },
+        {
+            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.',
+            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 (_id, p) => {
+                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(p.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 prob = overrideMap.get(n.id) ?? n.probability ?? 0;
+                    return s + prob * (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: p.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) for plain mode ──────────
+    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. Executes directly (no confirmation prompt in plain mode).',
+            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 (_id, p) => {
+                const { createOrder } = await import('../kalshi.js');
+                const priceCents = p.price_cents ? Math.round(Number(p.price_cents)) : undefined;
+                const maxCost = ((priceCents || 99) * p.count / 100).toFixed(2);
+                process.stderr.write(`  Order: ${p.action.toUpperCase()} ${p.count}x ${p.ticker} ${p.side.toUpperCase()} @ ${priceCents ? priceCents + '\u00A2' : 'market'} (max $${maxCost})\n`);
+                try {
+                    const result = await createOrder({
+                        ticker: p.ticker,
+                        side: p.side,
+                        action: p.action,
+                        type: p.type,
+                        count: p.count,
+                        ...(priceCents ? { yes_price: priceCents } : {}),
+                    });
+                    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 || p.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. Executes directly (no confirmation prompt in plain mode).',
+            parameters: Type.Object({
+                order_id: Type.String({ description: 'Order ID to cancel' }),
+            }),
+            execute: async (_id, p) => {
+                const { cancelOrder } = await import('../kalshi.js');
+                try {
+                    await cancelOrder(p.order_id);
+                    return { content: [{ type: 'text', text: `Order ${p.order_id} cancelled.` }], details: {} };
+                }
+                catch (err) {
+                    return { content: [{ type: 'text', text: `Cancel failed: ${err.message}` }], details: {} };
+                }
+            },
+        });
+    }
     // ── System prompt ─────────────────────────────────────────────────────────
     const ctx = latestContext;
     const edgesSummary = ctx.edges

package/dist/commands/setup.d.ts

@@ -17,6 +17,7 @@ interface SetupOpts {
     key?: string;
     enableTrading?: boolean;
     disableTrading?: boolean;
+    kalshi?: boolean;
 }
 export declare function setupCommand(opts: SetupOpts): Promise<void>;
 export {};

package/dist/commands/setup.js

@@ -71,13 +71,13 @@ async function validateSFKey(key, apiUrl) {
             headers: { 'Authorization': `Bearer ${key}` },
         });
         if (res.ok)
-            return { valid: true, msg: `API Key 有效 — 连接到 ${apiUrl.replace('https://', '')}` };
+            return { valid: true, msg: `API key valid — connected to ${apiUrl.replace('https://', '')}` };
         if (res.status === 401)
-            return { valid: false, msg: '无效 key，请重试' };
-        return { valid: false, msg: `服务器返回 ${res.status}` };
+            return { valid: false, msg: 'Invalid key, please try again' };
+        return { valid: false, msg: `Server returned ${res.status}` };
     }
     catch (err) {
-        return { valid: false, msg: `连接失败: ${err.message}` };
+        return { valid: false, msg: `Connection failed: ${err.message}` };
     }
 }
 async function validateOpenRouterKey(key) {
@@ -86,22 +86,22 @@ async function validateOpenRouterKey(key) {
             headers: { 'Authorization': `Bearer ${key}` },
         });
         if (res.ok)
-            return { valid: true, msg: 'OpenRouter 连接正常 — 可用模型: claude-sonnet-4.6' };
-        return { valid: false, msg: `OpenRouter 返回 ${res.status}` };
+            return { valid: true, msg: 'OpenRouter connected — available model: claude-sonnet-4.6' };
+        return { valid: false, msg: `OpenRouter returned ${res.status}` };
     }
     catch (err) {
-        return { valid: false, msg: `连接失败: ${err.message}` };
+        return { valid: false, msg: `Connection failed: ${err.message}` };
     }
 }
 async function validateKalshi() {
     try {
         const positions = await (0, kalshi_js_1.getPositions)();
         if (positions === null)
-            return { valid: false, msg: 'Kalshi 认证失败', posCount: 0 };
-        return { valid: true, msg: `Kalshi 认证成功 — 发现 ${positions.length} 个持仓`, posCount: positions.length };
+            return { valid: false, msg: 'Kalshi authentication failed', posCount: 0 };
+        return { valid: true, msg: `Kalshi authenticated — found ${positions.length} position(s)`, posCount: positions.length };
     }
     catch (err) {
-        return { valid: false, msg: `Kalshi 连接失败: ${err.message}`, posCount: 0 };
+        return { valid: false, msg: `Kalshi connection failed: ${err.message}`, posCount: 0 };
     }
 }
 async function validateTavily(key) {
@@ -112,11 +112,11 @@ async function validateTavily(key) {
             body: JSON.stringify({ api_key: key, query: 'test', max_results: 1 }),
         });
         if (res.ok)
-            return { valid: true, msg: 'Tavily 连接正常' };
-        return { valid: false, msg: `Tavily 返回 ${res.status}` };
+            return { valid: true, msg: 'Tavily connected' };
+        return { valid: false, msg: `Tavily returned ${res.status}` };
     }
     catch (err) {
-        return { valid: false, msg: `连接失败: ${err.message}` };
+        return { valid: false, msg: `Connection failed: ${err.message}` };
     }
 }
 async function setupCommand(opts) {
@@ -127,9 +127,9 @@ async function setupCommand(opts) {
     // ── sf setup --reset ──────────────────────────────────────────────────────
     if (opts.reset) {
         (0, config_js_1.resetConfig)();
-        ok('配置已重置');
+        ok('Config reset');
         blank();
-        info('运行 sf setup 重新配置');
+        info('Run sf setup to reconfigure');
         blank();
         return;
     }
@@ -144,7 +144,25 @@ async function setupCommand(opts) {
         const existing = (0, config_js_1.loadFileConfig)();
         (0, config_js_1.saveConfig)({ ...existing, apiKey: opts.key, apiUrl });
         ok(result.msg);
-        ok(`保存到 ${(0, config_js_1.getConfigPath)()}`);
+        ok(`Saved to ${(0, config_js_1.getConfigPath)()}`);
+        return;
+    }
+    // ── sf setup --kalshi (reconfigure Kalshi credentials) ──────────────────
+    if (opts.kalshi) {
+        const existing = (0, config_js_1.loadFileConfig)();
+        blank();
+        console.log(`  ${bold('Reconfigure Kalshi Credentials')}`);
+        blank();
+        info('Go to https://kalshi.com/account/api-keys to generate a new API key.');
+        info('If you need trading, make sure to enable read+write permissions.');
+        blank();
+        await promptForKalshi(existing);
+        (0, config_js_1.saveConfig)(existing);
+        if (existing.kalshiKeyId) {
+            process.env.KALSHI_API_KEY_ID = existing.kalshiKeyId;
+            process.env.KALSHI_PRIVATE_KEY_PATH = existing.kalshiPrivateKeyPath;
+        }
+        blank();
         return;
     }
     // ── sf setup --enable-trading / --disable-trading ────────────────────────
@@ -169,7 +187,7 @@ async function setupCommand(opts) {
 async function showCheck() {
     const config = (0, config_js_1.loadConfig)();
     blank();
-    console.log(`  ${bold('SimpleFunctions 配置状态')}`);
+    console.log(`  ${bold('SimpleFunctions Config Status')}`);
     console.log(`  ${dim('─'.repeat(35))}`);
     blank();
     // SF API Key
@@ -177,38 +195,38 @@ async function showCheck() {
         ok(`SF_API_KEY        ${dim(mask(config.apiKey))}`);
     }
     else {
-        fail('SF_API_KEY        未配置（必须）');
+        fail('SF_API_KEY        not configured (required)');
     }
     // OpenRouter
     if (config.openrouterKey) {
         ok(`OPENROUTER_KEY    ${dim(mask(config.openrouterKey))}`);
     }
     else {
-        fail(`OPENROUTER_KEY    未配置（agent 不可用）`);
+        fail(`OPENROUTER_KEY    not configured (agent unavailable)`);
     }
     // Kalshi
     if (config.kalshiKeyId && config.kalshiPrivateKeyPath) {
         ok(`KALSHI            ${dim(mask(config.kalshiKeyId))}`);
     }
     else {
-        info(`${dim('○')} KALSHI            ${dim('跳过')}`);
+        info(`${dim('○')} KALSHI            ${dim('skipped')}`);
     }
     // Tavily
     if (config.tavilyKey) {
         ok(`TAVILY            ${dim(mask(config.tavilyKey))}`);
     }
     else {
-        info(`${dim('○')} TAVILY            ${dim('跳过')}`);
+        info(`${dim('○')} TAVILY            ${dim('skipped')}`);
     }
     // Trading
     if (config.tradingEnabled) {
-        ok('TRADING           已启用');
+        ok('TRADING           enabled');
     }
     else {
-        info(`${dim('○')} TRADING           ${dim('未启用 — sf setup --enable-trading')}`);
+        info(`${dim('○')} TRADING           ${dim('disabled — sf setup --enable-trading')}`);
     }
     blank();
-    console.log(`  ${dim('配置文件: ' + (0, config_js_1.getConfigPath)())}`);
+    console.log(`  ${dim('Config file: ' + (0, config_js_1.getConfigPath)())}`);
     blank();
 }
 // ─── Interactive Wizard ──────────────────────────────────────────────────────
@@ -222,19 +240,19 @@ async function runWizard() {
     // ════════════════════════════════════════════════════════════════════════════
     // Step 1: SF API Key
     // ════════════════════════════════════════════════════════════════════════════
-    console.log(`  ${bold('第 1 步：API Key')}`);
+    console.log(`  ${bold('Step 1: API Key')}`);
     blank();
     const existingSfKey = process.env.SF_API_KEY || config.apiKey;
     if (existingSfKey) {
         const result = await validateSFKey(existingSfKey, apiUrl);
         if (result.valid) {
-            ok(`已检测到 SF_API_KEY — ${dim(mask(existingSfKey))}`);
-            info(dim('跳过。'));
+            ok(`Detected SF_API_KEY — ${dim(mask(existingSfKey))}`);
+            info(dim('Skipping.'));
             config.apiKey = existingSfKey;
             blank();
         }
         else {
-            fail(`已有 key 无效: ${result.msg}`);
+            fail(`Existing key invalid: ${result.msg}`);
             config.apiKey = await promptForSFKey(apiUrl);
         }
     }
@@ -249,19 +267,19 @@ async function runWizard() {
     // ════════════════════════════════════════════════════════════════════════════
     // Step 2: OpenRouter API Key
     // ════════════════════════════════════════════════════════════════════════════
-    console.log(`  ${bold('第 2 步：AI 模型（用于 sf agent）')}`);
+    console.log(`  ${bold('Step 2: AI Model (for sf agent)')}`);
     blank();
     const existingOrKey = process.env.OPENROUTER_API_KEY || config.openrouterKey;
     if (existingOrKey) {
         const result = await validateOpenRouterKey(existingOrKey);
         if (result.valid) {
-            ok(`已检测到 OPENROUTER_API_KEY — ${dim(mask(existingOrKey))}`);
-            info(dim('跳过。'));
+            ok(`Detected OPENROUTER_API_KEY — ${dim(mask(existingOrKey))}`);
+            info(dim('Skipping.'));
             config.openrouterKey = existingOrKey;
             blank();
         }
         else {
-            fail(`已有 key 无效: ${result.msg}`);
+            fail(`Existing key invalid: ${result.msg}`);
             config.openrouterKey = await promptForOpenRouterKey();
         }
     }
@@ -274,7 +292,7 @@ async function runWizard() {
     // ════════════════════════════════════════════════════════════════════════════
     // Step 3: Kalshi Exchange
     // ════════════════════════════════════════════════════════════════════════════
-    console.log(`  ${bold('第 3 步：Kalshi 交易所（可选）')}`);
+    console.log(`  ${bold('Step 3: Kalshi Exchange (optional)')}`);
     blank();
     const existingKalshiId = process.env.KALSHI_API_KEY_ID || config.kalshiKeyId;
     const existingKalshiPath = process.env.KALSHI_PRIVATE_KEY_PATH || config.kalshiPrivateKeyPath;
@@ -284,14 +302,14 @@ async function runWizard() {
         process.env.KALSHI_PRIVATE_KEY_PATH = existingKalshiPath;
         const result = await validateKalshi();
         if (result.valid) {
-            ok(`已检测到 Kalshi — ${dim(mask(existingKalshiId))} (${result.posCount} 个持仓)`);
-            info(dim('跳过。'));
+            ok(`Detected Kalshi — ${dim(mask(existingKalshiId))} (${result.posCount} position(s))`);
+            info(dim('Skipping.'));
             config.kalshiKeyId = existingKalshiId;
             config.kalshiPrivateKeyPath = existingKalshiPath;
             blank();
         }
         else {
-            fail(`已有凭证无效: ${result.msg}`);
+            fail(`Existing credentials invalid: ${result.msg}`);
             await promptForKalshi(config);
         }
     }
@@ -302,19 +320,19 @@ async function runWizard() {
     // ════════════════════════════════════════════════════════════════════════════
     // Step 4: Tavily
     // ════════════════════════════════════════════════════════════════════════════
-    console.log(`  ${bold('第 4 步：新闻搜索（可选）')}`);
+    console.log(`  ${bold('Step 4: News Search (optional)')}`);
     blank();
     const existingTavily = process.env.TAVILY_API_KEY || config.tavilyKey;
     if (existingTavily) {
         const result = await validateTavily(existingTavily);
         if (result.valid) {
-            ok(`已检测到 TAVILY_API_KEY — ${dim(mask(existingTavily))}`);
-            info(dim('跳过。'));
+            ok(`Detected TAVILY_API_KEY — ${dim(mask(existingTavily))}`);
+            info(dim('Skipping.'));
             config.tavilyKey = existingTavily;
             blank();
         }
         else {
-            fail(`已有 key 无效: ${result.msg}`);
+            fail(`Existing key invalid: ${result.msg}`);
             config.tavilyKey = await promptForTavily();
         }
     }
@@ -328,18 +346,18 @@ async function runWizard() {
     // Step 5: Trading
     // ════════════════════════════════════════════════════════════════════════════
     if (config.kalshiKeyId) {
-        console.log(`  ${bold('第 5 步：交易功能（可选）')}`);
+        console.log(`  ${bold('Step 5: Trading (optional)')}`);
         blank();
-        info('⚠️  启用后 sf buy / sf sell / sf cancel 可用。');
-        info('你的 Kalshi API key 必须有 read+write 权限。');
+        info('Warning: enabling this unlocks sf buy / sf sell / sf cancel.');
+        info('Your Kalshi API key must have read+write permissions.');
         blank();
-        const enableTrading = await promptYN('  启用交易功能？(y/N) ', false);
+        const enableTrading = await promptYN('  Enable trading? (y/N) ', false);
         config.tradingEnabled = enableTrading;
         if (enableTrading) {
-            ok('交易功能已启用');
+            ok('Trading enabled');
         }
         else {
-            info(dim('跳过。之后可以 sf setup --enable-trading 启用。'));
+            info(dim('Skipped. You can enable later with sf setup --enable-trading.'));
         }
         blank();
         (0, config_js_1.saveConfig)(config);
@@ -348,24 +366,24 @@ async function runWizard() {
     // Summary
     // ════════════════════════════════════════════════════════════════════════════
     console.log(`  ${dim('─'.repeat(25))}`);
-    info(`配置保存到 ${dim((0, config_js_1.getConfigPath)())}`);
+    info(`Config saved to ${dim((0, config_js_1.getConfigPath)())}`);
     blank();
     if (config.apiKey)
-        ok('SF_API_KEY        已配置');
+        ok('SF_API_KEY        configured');
     else
-        fail('SF_API_KEY        未配置');
+        fail('SF_API_KEY        not configured');
     if (config.openrouterKey)
-        ok('OPENROUTER_KEY    已配置');
+        ok('OPENROUTER_KEY    configured');
     else
-        fail('OPENROUTER_KEY    跳过');
+        fail('OPENROUTER_KEY    skipped');
     if (config.kalshiKeyId)
-        ok('KALSHI            已配置');
+        ok('KALSHI            configured');
     else
-        info(`${dim('○')} KALSHI            跳过`);
+        info(`${dim('○')} KALSHI            skipped`);
     if (config.tavilyKey)
-        ok('TAVILY            已配置');
+        ok('TAVILY            configured');
     else
-        info(`${dim('○')} TAVILY            跳过`);
+        info(`${dim('○')} TAVILY            skipped`);
     blank();
     // ════════════════════════════════════════════════════════════════════════════
     // Step 5: Thesis creation
@@ -376,18 +394,18 @@ async function runWizard() {
 }
 // ─── Step prompt helpers ─────────────────────────────────────────────────────
 async function promptForSFKey(apiUrl) {
-    info(`还没有 key？去 ${cyan('https://simplefunctions.dev/dashboard')} 注册获取。`);
-    info('按 Enter 打开浏览器，或直接粘贴你的 key：');
+    info(`Don't have a key? Sign up at ${cyan('https://simplefunctions.dev/dashboard')}.`);
+    info('Press Enter to open browser, or paste your key:');
     blank();
     while (true) {
         const answer = await prompt('  > ');
         if (!answer) {
             // Open browser
             openBrowser('https://simplefunctions.dev/dashboard');
-            info(dim('浏览器已打开。获取 key 后粘贴到这里：'));
+            info(dim('Browser opened. Paste your key here once you have it:'));
             continue;
         }
-        info(dim('验证中...'));
+        info(dim('Validating...'));
         const result = await validateSFKey(answer, apiUrl);
         if (result.valid) {
             ok(result.msg);
@@ -400,40 +418,40 @@ async function promptForSFKey(apiUrl) {
     }
 }
 async function promptForOpenRouterKey() {
-    info(`需要 OpenRouter API key。去 ${cyan('https://openrouter.ai/settings/keys')} 获取。`);
-    info('按 Enter 跳过（agent 功能不可用），或粘贴 key：');
+    info(`Requires an OpenRouter API key. Get one at ${cyan('https://openrouter.ai/settings/keys')}.`);
+    info('Press Enter to skip (agent unavailable), or paste key:');
     blank();
     const answer = await prompt('  > ');
     if (!answer) {
-        info(dim('跳过。'));
+        info(dim('Skipped.'));
         blank();
         return undefined;
     }
-    info(dim('验证中...'));
+    info(dim('Validating...'));
     const result = await validateOpenRouterKey(answer);
     if (result.valid) {
         ok(result.msg);
     }
     else {
         fail(result.msg);
-        info(dim('已保存，之后可以重新运行 sf setup 修正。'));
+        info(dim('Saved. You can re-run sf setup later to fix this.'));
     }
     blank();
     return answer;
 }
 async function promptForKalshi(config) {
-    info(`连接 Kalshi 查看你的持仓和盈亏。`);
-    info(`需要 API Key ID 和私钥文件。`);
-    info(`${cyan('https://kalshi.com/account/api-keys')} 获取。`);
-    info('按 Enter 跳过，或粘贴 Key ID：');
+    info(`Connect Kalshi to view your positions and P&L.`);
+    info(`Requires an API Key ID and private key file.`);
+    info(`Get them at ${cyan('https://kalshi.com/account/api-keys')}.`);
+    info('Press Enter to skip, or paste Key ID:');
     blank();
     const keyId = await prompt('  > ');
     if (!keyId) {
-        info(dim('跳过。'));
+        info(dim('Skipped.'));
         blank();
         return;
     }
-    info('私钥文件路径（默认 ~/.kalshi/private.pem）：');
+    info('Private key file path (default ~/.kalshi/private.pem):');
     const keyPathInput = await prompt('  > ');
     const keyPath = keyPathInput || '~/.kalshi/private.pem';
     config.kalshiKeyId = keyId;
@@ -441,36 +459,36 @@ async function promptForKalshi(config) {
     // Temporarily set for validation
     process.env.KALSHI_API_KEY_ID = keyId;
     process.env.KALSHI_PRIVATE_KEY_PATH = keyPath;
-    info(dim('验证中...'));
+    info(dim('Validating...'));
     const result = await validateKalshi();
     if (result.valid) {
         ok(result.msg);
     }
     else {
         fail(result.msg);
-        info(dim('已保存，之后可以重新运行 sf setup 修正。'));
+        info(dim('Saved. You can re-run sf setup later to fix this.'));
     }
     blank();
 }
 async function promptForTavily() {
-    info(`Tavily API 用于 agent 的 web_search 功能。`);
-    info(`${cyan('https://tavily.com')} 获取免费 key。`);
-    info('按 Enter 跳过：');
+    info(`Tavily API powers the agent's web_search tool.`);
+    info(`Get a free key at ${cyan('https://tavily.com')}.`);
+    info('Press Enter to skip:');
     blank();
     const answer = await prompt('  > ');
     if (!answer) {
-        info(dim('跳过。'));
+        info(dim('Skipped.'));
         blank();
         return undefined;
     }
-    info(dim('验证中...'));
+    info(dim('Validating...'));
     const result = await validateTavily(answer);
     if (result.valid) {
         ok(result.msg);
     }
     else {
         fail(result.msg);
-        info(dim('已保存，之后可以重新运行 sf setup 修正。'));
+        info(dim('Saved. You can re-run sf setup later to fix this.'));
     }
     blank();
     return answer;
@@ -483,67 +501,67 @@ async function handleThesisStep(config) {
         const theses = data.theses || [];
         const activeTheses = theses.filter((t) => t.status === 'active');
         if (activeTheses.length > 0) {
-            console.log(`  ${bold('第 6 步：论文')}`);
+            console.log(`  ${bold('Step 6: Theses')}`);
             blank();
-            ok(`已有 ${activeTheses.length} 个活跃论文：`);
+            ok(`Found ${activeTheses.length} active thesis(es):`);
             for (const t of activeTheses.slice(0, 5)) {
                 const conf = typeof t.confidence === 'number' ? Math.round(t.confidence * 100) : 0;
                 const thesis = (t.rawThesis || t.thesis || t.title || '').slice(0, 60);
                 info(`  ${dim(t.id.slice(0, 8))} — ${thesis} — ${conf}%`);
             }
-            info(dim('跳过创建。'));
+            info(dim('Skipping creation.'));
             blank();
             // Offer to launch agent
             if (config.openrouterKey) {
                 console.log(`  ${dim('─'.repeat(25))}`);
-                console.log(`  ${bold('全部就绪！')}`);
+                console.log(`  ${bold('All set!')}`);
                 blank();
-                info(`  ${cyan('sf agent')}             和你的论文对话`);
-                info(`  ${cyan('sf context <id>')}      查看论文快照`);
-                info(`  ${cyan('sf positions')}         查看持仓`);
-                info(`  ${cyan('sf setup --check')}     检查配置`);
+                info(`  ${cyan('sf agent')}             Chat with your thesis`);
+                info(`  ${cyan('sf context <id>')}      View thesis snapshot`);
+                info(`  ${cyan('sf positions')}         View positions`);
+                info(`  ${cyan('sf setup --check')}     Check config`);
                 blank();
-                const shouldLaunch = await promptYN(`  要不要现在启动 agent？(Y/n) `);
+                const shouldLaunch = await promptYN(`  Launch agent now? (Y/n) `);
                 if (shouldLaunch) {
                     blank();
-                    info('启动中...');
+                    info('Launching...');
                     blank();
                     await (0, agent_js_1.agentCommand)(activeTheses[0].id, { model: config.model });
                 }
             }
             else {
                 blank();
-                console.log(`  ${bold('全部就绪！')}`);
+                console.log(`  ${bold('All set!')}`);
                 blank();
-                info(`  ${cyan('sf list')}              查看所有论文`);
-                info(`  ${cyan('sf context <id>')}      查看论文快照`);
-                info(`  ${cyan('sf positions')}         查看持仓`);
-                info(`  ${cyan('sf setup --check')}     检查配置`);
+                info(`  ${cyan('sf list')}              List all theses`);
+                info(`  ${cyan('sf context <id>')}      View thesis snapshot`);
+                info(`  ${cyan('sf positions')}         View positions`);
+                info(`  ${cyan('sf setup --check')}     Check config`);
                 blank();
             }
             return;
         }
         // No theses — offer to create one
-        console.log(`  ${bold('第 6 步：创建你的第一个论文')}`);
+        console.log(`  ${bold('Step 6: Create Your First Thesis')}`);
         blank();
-        info('论文是你对市场的一个核心判断。系统会基于它构建因果模型，');
-        info('然后持续扫描预测市场寻找被错误定价的合约。');
+        info('A thesis is your core market conviction. The system builds a causal model');
+        info('from it, then continuously scans prediction markets for mispriced contracts.');
         blank();
-        info('比如：');
-        info(`  ${dim('"美联储2026年不会降息，通胀因油价持续高企"')}`);
-        info(`  ${dim('"AI裁员潮导致消费萎缩，标普年底跌20%"')}`);
-        info(`  ${dim('"Trump无法退出伊朗战争，油价维持$100以上六个月"')}`);
+        info('Examples:');
+        info(`  ${dim('"The Fed won\'t cut rates in 2026 — inflation stays elevated due to oil prices"')}`);
+        info(`  ${dim('"AI-driven layoffs cause consumer spending to contract, S&P drops 20% by year-end"')}`);
+        info(`  ${dim('"Trump can\'t exit the Iran conflict — oil stays above $100 for six months"')}`);
         blank();
-        const thesis = await prompt('  输入你的论文（按 Enter 跳过，之后用 sf create）：\n  > ');
+        const thesis = await prompt('  Enter your thesis (press Enter to skip, use sf create later):\n  > ');
         if (!thesis) {
             blank();
-            info(dim('跳过。之后用 sf create "你的论文" 创建。'));
+            info(dim('Skipped. Use sf create "your thesis" to create one later.'));
             blank();
             showFinalHints(config);
             return;
         }
         blank();
-        info('构建因果模型中...（约30秒）');
+        info('Building causal model... (~30s)');
         blank();
         try {
             const result = await client.createThesis(thesis, true);
@@ -552,20 +570,20 @@ async function handleThesisStep(config) {
                 const edgeCount = result.edgeAnalysis?.edges?.length || 0;
                 const totalMarkets = result.edgeAnalysis?.totalMarketsAnalyzed || 0;
                 const confidence = Math.round((parseFloat(result.confidence) || 0.5) * 100);
-                ok(`因果树：${nodeCount} 个节点`);
-                ok(`扫描 ${totalMarkets} 个市场，找到 ${edgeCount} 个有边际的合约`);
-                ok(`置信度：${confidence}%`);
-                ok(`论文 ID：${result.id.slice(0, 8)}`);
+                ok(`Causal tree: ${nodeCount} node(s)`);
+                ok(`Scanned ${totalMarkets} markets, found ${edgeCount} contract(s) with edge`);
+                ok(`Confidence: ${confidence}%`);
+                ok(`Thesis ID: ${result.id.slice(0, 8)}`);
                 blank();
                 // Offer to launch agent
                 if (config.openrouterKey) {
                     console.log(`  ${dim('─'.repeat(25))}`);
-                    console.log(`  ${bold('全部就绪！')}`);
+                    console.log(`  ${bold('All set!')}`);
                     blank();
-                    const shouldLaunch = await promptYN(`  要不要现在启动 agent？(Y/n) `);
+                    const shouldLaunch = await promptYN(`  Launch agent now? (Y/n) `);
                     if (shouldLaunch) {
                         blank();
-                        info('启动中...');
+                        info('Launching...');
                         blank();
                         await (0, agent_js_1.agentCommand)(result.id, { model: config.model });
                     }
@@ -579,15 +597,15 @@ async function handleThesisStep(config) {
                 }
             }
             else {
-                fail(`创建失败：${result.error || '未知错误'}`);
-                info(dim('之后可以用 sf create "你的论文" 重试'));
+                fail(`Creation failed: ${result.error || 'unknown error'}`);
+                info(dim('You can retry later with sf create "your thesis"'));
                 blank();
                 showFinalHints(config);
             }
         }
         catch (err) {
-            fail(`创建失败：${err.message}`);
-            info(dim('之后可以用 sf create "你的论文" 重试'));
+            fail(`Creation failed: ${err.message}`);
+            info(dim('You can retry later with sf create "your thesis"'));
             blank();
             showFinalHints(config);
         }
@@ -600,12 +618,12 @@ async function handleThesisStep(config) {
 }
 function showFinalHints(config) {
     console.log(`  ${dim('─'.repeat(25))}`);
-    console.log(`  ${bold('全部就绪！')}`);
+    console.log(`  ${bold('All set!')}`);
     blank();
-    info(`  ${cyan('sf agent')}             和你的论文对话`);
-    info(`  ${cyan('sf list')}              查看所有论文`);
-    info(`  ${cyan('sf context <id>')}      查看论文快照`);
-    info(`  ${cyan('sf positions')}         查看持仓`);
-    info(`  ${cyan('sf setup --check')}     检查配置`);
+    info(`  ${cyan('sf agent')}             Chat with your thesis`);
+    info(`  ${cyan('sf list')}              List all theses`);
+    info(`  ${cyan('sf context <id>')}      View thesis snapshot`);
+    info(`  ${cyan('sf positions')}         View positions`);
+    info(`  ${cyan('sf setup --check')}     Check config`);
     blank();
 }

package/dist/commands/trade.js

@@ -26,7 +26,6 @@ async function executeOrder(ticker, qty, action, opts) {
     if (priceCents !== undefined && (priceCents < 1 || priceCents > 99)) {
         throw new Error('Price must be 1-99 cents.');
     }
-    const priceDollars = priceCents ? (priceCents / 100).toFixed(2) : undefined;
     const maxCost = ((priceCents || 99) * quantity / 100).toFixed(2);
     console.log();
     console.log(`  ${utils_js_1.c.bold}${utils_js_1.c.cyan}${action.toUpperCase()} Order${utils_js_1.c.reset}`);
@@ -35,7 +34,7 @@ async function executeOrder(ticker, qty, action, opts) {
     console.log(`  Side:      ${side === 'yes' ? utils_js_1.c.green + 'YES' + utils_js_1.c.reset : utils_js_1.c.red + 'NO' + utils_js_1.c.reset}`);
     console.log(`  Quantity:  ${quantity}`);
     console.log(`  Type:      ${orderType}`);
-    if (priceDollars)
+    if (priceCents)
         console.log(`  Price:     ${priceCents}¢`);
     console.log(`  Max cost:  $${maxCost}`);
     console.log();
@@ -53,7 +52,7 @@ async function executeOrder(ticker, qty, action, opts) {
             action,
             type: orderType,
             count: quantity,
-            ...(priceDollars ? { yes_price: priceDollars } : {}),
+            ...(priceCents ? { yes_price: priceCents } : {}),
         });
         const order = result.order || result;
         console.log();

package/dist/index.js

@@ -63,8 +63,8 @@ program
     .option('--api-url <url>', 'API base URL (or set SF_API_URL env var)');
 // ── Pre-action guard: check configuration ────────────────────────────────────
 const NO_CONFIG_COMMANDS = new Set(['setup', 'help', 'scan', 'explore', 'milestones', 'forecast', 'settlements', 'balance', 'orders', 'fills', 'schedule', 'announcements', 'history']);
-program.hook('preAction', (thisCommand) => {
-    const cmdName = thisCommand.name();
+program.hook('preAction', (thisCommand, actionCommand) => {
+    const cmdName = actionCommand.name();
     if (NO_CONFIG_COMMANDS.has(cmdName))
         return;
     // --api-key flag overrides config check
@@ -87,8 +87,9 @@ program
     .option('--key <key>', 'Set SF API key (non-interactive, for CI)')
     .option('--enable-trading', 'Enable trading (sf buy/sell/cancel)')
     .option('--disable-trading', 'Disable trading')
+    .option('--kalshi', 'Reconfigure Kalshi API credentials')
     .action(async (opts) => {
-    await run(() => (0, setup_js_1.setupCommand)({ check: opts.check, reset: opts.reset, key: opts.key, enableTrading: opts.enableTrading, disableTrading: opts.disableTrading }));
+    await run(() => (0, setup_js_1.setupCommand)({ check: opts.check, reset: opts.reset, key: opts.key, enableTrading: opts.enableTrading, disableTrading: opts.disableTrading, kalshi: opts.kalshi }));
 });
 // ── sf list ──────────────────────────────────────────────────────────────────
 program

package/dist/kalshi.d.ts

@@ -103,7 +103,7 @@ export declare function createOrder(params: {
     action: 'buy' | 'sell';
     type: 'limit' | 'market';
     count: number;
-    yes_price?: string;
+    yes_price?: number;
     client_order_id?: string;
 }): Promise<{
     order: any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spfunctions/cli",
-  "version": "1.1.9",
+  "version": "1.3.0",
   "description": "Prediction market intelligence CLI. Causal thesis model, 24/7 Kalshi/Polymarket scan, live orderbook, edge detection. Interactive agent mode with tool calling.",
   "bin": {
     "sf": "./dist/index.js"
@@ -39,6 +39,6 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/simplefunctions/simplefunctions"
+    "url": "https://github.com/spfunctions/simplefunctions-cli"
   }
 }