@spfunctions/cli 1.5.2 → 1.6.1

package/dist/client.d.ts

@@ -22,6 +22,7 @@ export declare class SFClient {
     updateThesis(id: string, data: Record<string, unknown>): Promise<any>;
     publish(id: string, slug: string, description?: string): Promise<any>;
     unpublish(id: string): Promise<any>;
+    augmentTree(id: string, dryRun?: boolean): Promise<any>;
     getStrategies(id: string, status?: string): Promise<any>;
     createStrategyAPI(id: string, data: Record<string, unknown>): Promise<any>;
     updateStrategyAPI(thesisId: string, strategyId: string, data: Record<string, unknown>): Promise<any>;

package/dist/client.js

@@ -86,6 +86,10 @@ class SFClient {
     async unpublish(id) {
         return this.request('DELETE', `/api/thesis/${id}/publish`);
     }
+    async augmentTree(id, dryRun = false) {
+        const qs = dryRun ? '?dryRun=true' : '';
+        return this.request('POST', `/api/thesis/${id}/augment${qs}`);
+    }
     // ── Strategy operations ──
     async getStrategies(id, status) {
         const qs = status ? `?status=${status}` : '';

package/dist/commands/agent.js

@@ -1570,16 +1570,48 @@ async function agentCommand(thesisId, opts) {
 
 Each thesis has a causal tree. Every node is a causal hypothesis with a probability. Nodes have causal relationships \u2014 when upstream nodes change, downstream nodes follow.
 
-Edge = thesis-implied price - actual market price. Positive edge means the market underprices this event. Negative edge means overpriced. Contracts with large edges AND good liquidity are the most tradeable.
+Edge = thesis-implied price - actual market price. Positive edge = market underprices. Contracts with large edges AND good liquidity are most tradeable.
 
-executableEdge is the real edge after subtracting the bid-ask spread. A contract with a big theoretical edge but wide spread may not be worth entering.
+executableEdge = real edge after subtracting bid-ask spread. Big theoretical edge with wide spread may not be worth entering.
 
-Short-term markets (weekly/monthly contracts) settle into hard data that calibrates the long-term thesis. Don't use them to bet (outcomes are nearly known) \u2014 use them to verify whether causal tree node probabilities are accurate.
+### Edge diagnosis (always classify)
+When reporting an edge, classify it:
+- "consensus gap": depth >= 500, market actively disagrees — real edge, real opponents
+- "attention gap": depth < 100, no real pricing — edge may be illusory, needs catalyst
+- "timing gap": market directionally agrees but lags — may close suddenly on news
+- "risk premium": edge reflects settlement ambiguity or platform risk, not alpha
+For edges > 20 cents, state in one sentence what must be true for the market to be right and the thesis wrong.
+
+### Price reliability
+47 cents with depth 14K = strong consensus. 47 cents with depth 50 = three people's opinion.
+- depth >= 500: reliable, treat as market consensus
+- depth 100-500: moderate confidence, caveat when citing
+- depth < 100: unreliable — do NOT treat as "the market thinks X"
+- spread > 5 cents: wide disagreement, noisy midpoint
+- liquidityScore = low: do NOT recommend entry
+
+### Kill condition awareness
+Each top-level causal node has an implicit falsifier. When scanning news or evaluating events, check: "Does any event here fundamentally break a core assumption?" If yes, flag immediately — this overrides all other analysis.
+
+### Catalyst and time
+When discussing an edge, always state contract expiry and next identifiable catalyst. No visible catalyst = flag capital lock risk.
+
+### Research workflow
+For complex questions, chain multiple tool calls:
+1. get_context 2. inspect_book 3. get_liquidity 4. web_search 5. synthesize
+Don't answer a complex question with a single tool call.
+
+### Conditional rules
+- Portfolio/positions questions: flag correlated exposure — positions sharing upstream causal nodes are not independent bets.
+- No catalyst visible within 30 days + edge not improving: flag "stale capital risk."
+- Edges < 10 cents, thin liquidity, no catalyst near: say "nothing to do right now." Do not manufacture urgency.
+
+Short-term markets settle into hard data that calibrates the thesis. Use them to verify node probabilities, not to bet.
 
 ## Your behavioral rules
 
+- IMPORTANT: You do NOT know the user's current positions at conversation start. Before discussing trades, recommending entries/exits, or analyzing portfolio risk, call get_positions FIRST. Never assume the user has no positions — they may have large existing holdings you don't know about.
 - Think before calling tools. If the data is already in context, don't re-fetch.
-- If the user asks about positions, check if Kalshi is configured first. If not, say so directly.
 - If the user says "note this" or mentions a news event, inject a signal. Don't ask "should I note this?"
 - If the user says "evaluate" or "run it", trigger immediately. Don't confirm.
 - Don't end every response with "anything else?" \u2014 the user will ask when they want to.
@@ -3183,11 +3215,24 @@ async function runPlainTextAgent(params) {
     const systemPrompt = `You are a prediction market trading assistant. Your job is not to please the user — it is to help them see reality clearly and make correct trading decisions.
 
 ## Framework
-Each thesis has a causal tree. Every node is a hypothesis with a probability. Edge = thesis-implied price - market price. Positive edge = market underprices. Contracts with large edge + good liquidity = most tradeable.
-executableEdge = edge after subtracting bid-ask spread. A big theoretical edge with wide spread may not be worth entering.
+Edge = thesis price - market price. Positive = market underprices. executableEdge = edge minus spread.
+
+Edge types: "consensus_gap" (depth >= 500, real disagreement), "attention_gap" (depth < 100, illusory pricing), "timing_gap" (market lags), "risk_premium" (settlement/platform risk). Always classify when reporting edges.
+For edges > 20 cents, state what the market must believe for it to be right.
+
+Price reliability: depth >= 500 = consensus. depth < 100 = unreliable. spread > 5 cents = noisy. Flag illiquid markets.
+
+Kill conditions: each causal node has a falsifier. Check these first when evaluating news. If triggered, override other analysis.
+
+Always state contract expiry and next catalyst. No catalyst = flag capital lock risk.
+
+For complex questions, chain: get_context -> inspect_book -> get_liquidity -> web_search -> synthesize.
+
+Flag correlated exposure across positions sharing upstream nodes. If nothing to do, say so.
 
 ## Rules
 - Be concise. Use tools for fresh data. Don't guess prices.
+- You do NOT know the user's positions at start. Call get_positions before discussing trades or portfolio.
 - If user mentions news, inject_signal immediately.
 - If user says "evaluate", trigger immediately. Don't confirm.
 - Don't end with "anything else?"

package/dist/commands/augment.d.ts

@@ -0,0 +1,12 @@
+/**
+ * sf augment <thesisId> [--dry-run]
+ *
+ * Review suggested causal tree nodes from recent evaluations,
+ * accept/reject via LLM, and merge into the tree (append-only).
+ */
+export declare function augmentCommand(thesisId: string, opts: {
+    dryRun?: boolean;
+    json?: boolean;
+    apiKey?: string;
+    apiUrl?: string;
+}): Promise<void>;

package/dist/commands/augment.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * sf augment <thesisId> [--dry-run]
+ *
+ * Review suggested causal tree nodes from recent evaluations,
+ * accept/reject via LLM, and merge into the tree (append-only).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.augmentCommand = augmentCommand;
+const client_js_1 = require("../client.js");
+async function augmentCommand(thesisId, opts) {
+    const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
+    console.log(`\x1b[2m${opts.dryRun ? 'Previewing' : 'Running'} tree augmentation for ${thesisId.slice(0, 8)}...\x1b[22m`);
+    const result = await client.augmentTree(thesisId, opts.dryRun);
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    // Display results
+    console.log();
+    if (result.warning) {
+        console.log(`  \x1b[33m⚠ ${result.warning}\x1b[39m`);
+        console.log();
+    }
+    if (result.suggestedNodes?.length > 0) {
+        console.log(`  \x1b[1mSuggested Nodes\x1b[22m (${result.suggestedNodes.length} from evaluations)`);
+        for (const s of result.suggestedNodes) {
+            console.log(`    • ${s.label} \x1b[2m(parent: ${s.parentNodeId}, est: ${Math.round(s.estimatedProbability * 100)}%, seen ${s.frequency}x)\x1b[22m`);
+        }
+        console.log();
+    }
+    if (result.acceptedNodes?.length > 0) {
+        console.log(`  \x1b[1m\x1b[32mAccepted Nodes\x1b[39m\x1b[22m (${result.acceptedNodes.length})`);
+        for (const n of result.acceptedNodes) {
+            console.log(`    \x1b[32m+\x1b[39m ${n.id}: ${n.label} \x1b[2m(prob: ${Math.round(n.probability * 100)}%, imp: ${n.importance})\x1b[22m`);
+        }
+        console.log();
+        if (Object.keys(result.updatedImportanceWeights || {}).length > 0) {
+            console.log(`  \x1b[1mRebalanced Weights\x1b[22m`);
+            for (const [nodeId, weight] of Object.entries(result.updatedImportanceWeights)) {
+                console.log(`    ${nodeId} → ${weight}`);
+            }
+            console.log();
+        }
+        if (result.applied) {
+            console.log(`  \x1b[32m✓ Applied to causal tree\x1b[39m`);
+        }
+        else if (opts.dryRun) {
+            console.log(`  \x1b[2mDry run — use without --dry-run to apply\x1b[22m`);
+        }
+    }
+    else {
+        console.log('  No nodes accepted.');
+    }
+    console.log();
+}

package/dist/commands/prompt.d.ts

@@ -0,0 +1,13 @@
+/**
+ * sf prompt [thesisId] — Get dynamic system prompt for an agent
+ *
+ * Outputs a ready-to-use system prompt with live thesis state.
+ * Pipe-friendly: sf prompt f582bf76 >> agent_context.txt
+ */
+export declare function promptCommand(thesisId: string | undefined, opts: {
+    sections?: string;
+    maxLength?: string;
+    json?: boolean;
+    apiKey?: string;
+    apiUrl?: string;
+}): Promise<void>;

package/dist/commands/prompt.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * sf prompt [thesisId] — Get dynamic system prompt for an agent
+ *
+ * Outputs a ready-to-use system prompt with live thesis state.
+ * Pipe-friendly: sf prompt f582bf76 >> agent_context.txt
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptCommand = promptCommand;
+async function promptCommand(thesisId, opts) {
+    const baseUrl = (opts.apiUrl || process.env.SF_API_URL || 'https://simplefunctions.dev').replace(/\/$/, '');
+    const apiKey = opts.apiKey || process.env.SF_API_KEY || '';
+    const params = new URLSearchParams();
+    if (opts.sections)
+        params.set('sections', opts.sections);
+    if (opts.maxLength)
+        params.set('maxLength', opts.maxLength);
+    if (opts.json)
+        params.set('format', 'json');
+    const path = thesisId
+        ? `/api/thesis/${thesisId}/prompt`
+        : '/api/prompt';
+    const qs = params.toString() ? `?${params.toString()}` : '';
+    const res = await fetch(`${baseUrl}${path}${qs}`, {
+        headers: { 'Authorization': `Bearer ${apiKey}` },
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`API error ${res.status}: ${text}`);
+    }
+    const body = await res.text();
+    process.stdout.write(body);
+    if (!body.endsWith('\n'))
+        process.stdout.write('\n');
+}

package/dist/commands/query.d.ts

@@ -0,0 +1,15 @@
+/**
+ * sf query "iran oil"
+ *
+ * LLM-enhanced prediction market knowledge search. No auth required.
+ * Searches Kalshi, Polymarket, and SimpleFunctions content.
+ * Returns structured answer with markets, thesis, content, key factors.
+ *
+ * Usage:
+ *   sf query "iran oil"          — Formatted output
+ *   sf query "fed rate cut" --json — JSON for agents
+ */
+export declare function queryCommand(q: string, opts?: {
+    json?: boolean;
+    limit?: string;
+}): Promise<void>;

package/dist/commands/query.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * sf query "iran oil"
+ *
+ * LLM-enhanced prediction market knowledge search. No auth required.
+ * Searches Kalshi, Polymarket, and SimpleFunctions content.
+ * Returns structured answer with markets, thesis, content, key factors.
+ *
+ * Usage:
+ *   sf query "iran oil"          — Formatted output
+ *   sf query "fed rate cut" --json — JSON for agents
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryCommand = queryCommand;
+const BASE_URL = 'https://simplefunctions.dev';
+async function queryCommand(q, opts) {
+    const limit = opts?.limit || '10';
+    const url = `${BASE_URL}/api/public/query?q=${encodeURIComponent(q)}&limit=${limit}`;
+    const res = await fetch(url);
+    if (!res.ok) {
+        const text = await res.text();
+        if (res.status === 429) {
+            console.error('  Rate limited. Wait a minute and try again.');
+        }
+        else {
+            console.error(`  Error: ${res.status} ${text}`);
+        }
+        return;
+    }
+    const data = await res.json();
+    if (opts?.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    // Formatted output
+    console.log();
+    console.log(`  \x1b[1m${data.query}\x1b[22m`);
+    console.log();
+    // Answer
+    if (data.answer) {
+        console.log(`  ${data.answer}`);
+        console.log();
+    }
+    // Key factors
+    if (data.keyFactors?.length > 0) {
+        console.log('  \x1b[2mKey factors:\x1b[22m');
+        for (const f of data.keyFactors) {
+            console.log(`    • ${f}`);
+        }
+        console.log();
+    }
+    // Markets
+    if (data.markets?.length > 0) {
+        console.log('  \x1b[1mMarkets\x1b[22m');
+        for (const m of data.markets.slice(0, 8)) {
+            const venue = m.venue === 'kalshi' ? '\x1b[36mK\x1b[39m' : '\x1b[35mP\x1b[39m';
+            const vol = m.volume > 1_000_000 ? `${(m.volume / 1_000_000).toFixed(1)}M` :
+                m.volume > 1_000 ? `${(m.volume / 1_000).toFixed(0)}K` :
+                    String(m.volume);
+            const ticker = m.ticker ? ` ${m.ticker}` : '';
+            console.log(`    ${venue} ${String(m.price).padStart(3)}¢  vol ${vol.padStart(6)}  ${m.title.slice(0, 55)}${ticker}`);
+        }
+        console.log();
+    }
+    // Thesis
+    if (data.thesis) {
+        const t = data.thesis;
+        console.log(`  \x1b[1mThesis\x1b[22m`);
+        console.log(`    ${t.title.slice(0, 60)}`);
+        console.log(`    ${t.confidence}% confidence  ${t.edges} edges  /thesis/${t.slug}`);
+        console.log();
+    }
+    // Content
+    if (data.content?.length > 0) {
+        console.log('  \x1b[1mContent\x1b[22m');
+        for (const c of data.content.slice(0, 5)) {
+            const type = c.type.padEnd(9);
+            console.log(`    \x1b[2m${type}\x1b[22m ${c.title.slice(0, 60)}`);
+        }
+        console.log();
+    }
+    // Sources
+    if (data.sources?.length > 0) {
+        console.log(`  \x1b[2mSources: ${data.sources.join(', ')}\x1b[22m`);
+        console.log();
+    }
+}

package/dist/commands/scan.js

@@ -218,6 +218,11 @@ async function keywordScan(query, json, venue = 'all') {
             `  ${(m.title || '').slice(0, 55)}`);
     }
     console.log('');
+    // Conversion hook
+    if (!json) {
+        console.log(`${utils_js_1.c.dim}Want 24/7 monitoring + edge detection? ${utils_js_1.c.reset}${utils_js_1.c.cyan}sf create${utils_js_1.c.reset}${utils_js_1.c.dim} "your thesis"${utils_js_1.c.reset}`);
+        console.log('');
+    }
 }
 function printMarketsTable(markets) {
     if (markets.length === 0) {

package/dist/commands/signal.d.ts

@@ -1,5 +1,6 @@
 export declare function signalCommand(id: string, content: string, opts: {
     type?: string;
+    json?: boolean;
     apiKey?: string;
     apiUrl?: string;
 }): Promise<void>;

package/dist/commands/signal.js

@@ -7,6 +7,10 @@ async function signalCommand(id, content, opts) {
     const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
     const type = opts.type || 'user_note';
     const result = await client.injectSignal(id, type, content, 'cli');
+    if (opts.json) {
+        console.log(JSON.stringify({ signalId: result.signalId || null, type, source: 'cli', content }, null, 2));
+        return;
+    }
     console.log(`${utils_js_1.c.green}✓${utils_js_1.c.reset} Signal injected`);
     console.log(`  ${utils_js_1.c.bold}Type:${utils_js_1.c.reset}    ${type}`);
     console.log(`  ${utils_js_1.c.bold}Source:${utils_js_1.c.reset}  cli`);
@@ -14,7 +18,6 @@ async function signalCommand(id, content, opts) {
     if (result.signalId) {
         console.log(`  ${utils_js_1.c.bold}ID:${utils_js_1.c.reset}      ${result.signalId}`);
     }
-    // Calculate minutes until next 15-min cron cycle (runs at :00, :15, :30, :45)
     const now = new Date();
     const minute = now.getMinutes();
     const nextCycleMin = Math.ceil((minute + 1) / 15) * 15;

package/dist/index.js

@@ -21,6 +21,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const config_js_1 = require("./config.js");
+const client_js_1 = require("./client.js");
 const list_js_1 = require("./commands/list.js");
 const get_js_1 = require("./commands/get.js");
 const context_js_1 = require("./commands/context.js");
@@ -53,7 +54,10 @@ const history_js_1 = require("./commands/history.js");
 const performance_js_1 = require("./commands/performance.js");
 const liquidity_js_1 = require("./commands/liquidity.js");
 const book_js_1 = require("./commands/book.js");
+const prompt_js_1 = require("./commands/prompt.js");
+const augment_js_1 = require("./commands/augment.js");
 const telegram_js_1 = require("./commands/telegram.js");
+const query_js_1 = require("./commands/query.js");
 const utils_js_1 = require("./utils.js");
 // ── Apply ~/.sf/config.json to process.env BEFORE any command ────────────────
 // This means client.ts, kalshi.ts, agent.ts keep reading process.env and just work.
@@ -77,8 +81,12 @@ const GROUPED_HELP = `
   \x1b[36mcreate\x1b[39m "thesis"            Create a new thesis
   \x1b[36msignal\x1b[39m <id> "content"      Inject a signal
   \x1b[36mevaluate\x1b[39m <id>              Trigger deep evaluation
+  \x1b[36maugment\x1b[39m <id>               Evolve causal tree with new nodes
   \x1b[36mpublish\x1b[39m / \x1b[36munpublish\x1b[39m <id>  Manage public visibility
 
+\x1b[1mSearch\x1b[22m
+  \x1b[36mquery\x1b[39m "question"            LLM-enhanced market knowledge search \x1b[2m(no auth)\x1b[22m
+
 \x1b[1mMarkets\x1b[22m
   \x1b[36mscan\x1b[39m "keywords"            Search Kalshi + Polymarket
   \x1b[36mscan\x1b[39m --series TICKER       Browse a Kalshi series
@@ -106,6 +114,7 @@ const GROUPED_HELP = `
 
 \x1b[1mInteractive\x1b[22m
   \x1b[36magent\x1b[39m [id]                 Agent with natural language + tools
+  \x1b[36mprompt\x1b[39m [id]                Dynamic system prompt for any agent
   \x1b[36mtelegram\x1b[39m                   Telegram bot for monitoring
 
 \x1b[1mInfo\x1b[22m
@@ -123,15 +132,96 @@ program
     .option('--api-url <url>', 'API base URL (or set SF_API_URL env var)')
     .configureHelp({
     formatHelp: (cmd, helper) => {
-        // For subcommands, use default help
         if (cmd.parent)
             return helper.formatHelp(cmd, helper);
-        // For main program, show grouped help
         return GROUPED_HELP;
     },
-});
+})
+    .action(async () => {
+    // `sf` with no args → interactive entry point
+    await interactiveEntry();
+});
+// ── Interactive entry (sf with no args) ──────────────────────────────────────
+async function interactiveEntry() {
+    // Non-TTY stdin (pipe, CI) → show help instead of hanging
+    if (!process.stdin.isTTY) {
+        console.log(GROUPED_HELP);
+        return;
+    }
+    const readline = await import('readline');
+    // Scenario B: configured + has theses → go straight to agent
+    if ((0, config_js_1.isConfigured)()) {
+        try {
+            const client = new client_js_1.SFClient();
+            const { theses } = await client.listTheses();
+            const active = (theses || []).filter((t) => t.status === 'active');
+            if (active.length > 0) {
+                // Go straight to agent (like Claude Code — open and type)
+                await (0, agent_js_1.agentCommand)(active[0].id, {});
+                return;
+            }
+        }
+        catch {
+            // API error — fall through to prompt
+        }
+    }
+    // Scenario A/C: not configured or no theses → ask for input
+    console.log();
+    console.log('  \x1b[1mSimpleFunctions\x1b[22m — prediction market intelligence');
+    console.log();
+    if ((0, config_js_1.isConfigured)()) {
+        console.log('  \x1b[2mYou have no active theses.\x1b[22m');
+    }
+    else {
+        console.log('  \x1b[2mNo login needed to explore.\x1b[22m');
+    }
+    console.log();
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    const answer = await new Promise(resolve => {
+        rl.question('  What\'s your market view? (keyword or thesis)\n  \x1b[36m>\x1b[39m ', ans => {
+            rl.close();
+            resolve(ans.trim());
+        });
+    });
+    if (!answer) {
+        // Empty input → show help
+        console.log(GROUPED_HELP);
+        return;
+    }
+    // Extract keywords and scan
+    let keywords = answer
+        .replace(/[^\w\s]/g, ' ')
+        .split(/\s+/)
+        .filter(w => w.length > 2)
+        .slice(0, 5)
+        .join(' ');
+    // If all words were too short, use the raw answer
+    if (!keywords)
+        keywords = answer.trim().slice(0, 40);
+    console.log();
+    console.log(`  \x1b[2mScanning Kalshi + Polymarket for: "${keywords}"...\x1b[22m`);
+    console.log();
+    try {
+        const { scanCommand } = await import('./commands/scan.js');
+        await scanCommand(keywords, { json: false });
+    }
+    catch (err) {
+        console.error(`  \x1b[31mScan failed: ${err.message}\x1b[39m`);
+    }
+    // Conversion hook
+    console.log();
+    if ((0, config_js_1.isConfigured)()) {
+        console.log('  \x1b[2mWant to monitor this thesis 24/7?\x1b[22m');
+        console.log(`  \x1b[36msf create\x1b[39m "${answer.slice(0, 60)}"`);
+    }
+    else {
+        console.log('  \x1b[2mWant 24/7 monitoring + edge detection?\x1b[22m');
+        console.log('  \x1b[36msf setup\x1b[39m to get started (2 min)');
+    }
+    console.log();
+}
 // ── Pre-action guard: check configuration ────────────────────────────────────
-const NO_CONFIG_COMMANDS = new Set(['setup', 'help', 'scan', 'explore', 'milestones', 'forecast', 'settlements', 'balance', 'orders', 'fills', 'schedule', 'announcements', 'history', 'liquidity']);
+const NO_CONFIG_COMMANDS = new Set(['setup', 'help', 'scan', 'explore', 'query', 'milestones', 'forecast', 'settlements', 'balance', 'orders', 'fills', 'schedule', 'announcements', 'history', 'liquidity', 'book', 'prompt', 'sf']);
 program.hook('preAction', (thisCommand, actionCommand) => {
     const cmdName = actionCommand.name();
     if (NO_CONFIG_COMMANDS.has(cmdName))
@@ -141,8 +231,18 @@ program.hook('preAction', (thisCommand, actionCommand) => {
     if (g.apiKey)
         return;
     if (!(0, config_js_1.isConfigured)()) {
-        console.log();
-        console.log('  SimpleFunctions 未配置。运行 \x1b[36msf setup\x1b[39m 开始。');
+        const isJson = process.argv.includes('--json');
+        if (isJson) {
+            console.log(JSON.stringify({ error: 'API key required. Run sf setup or pass --api-key.', code: 'NOT_CONFIGURED' }));
+        }
+        else {
+            console.log();
+            console.log('  This command needs an API key. Two options:');
+            console.log('    1. \x1b[36msf setup\x1b[39m          Interactive wizard (2 min)');
+            console.log('    2. \x1b[36msf --api-key KEY\x1b[39m  Pass inline');
+            console.log();
+            console.log('  \x1b[2mDon\'t have a key? Try \x1b[36msf scan "oil"\x1b[22m\x1b[2m — works without login.\x1b[22m');
+        }
         console.log();
         process.exit(1);
     }
@@ -203,9 +303,10 @@ program
     .command('signal <id> <content>')
     .description('Inject a signal into the thesis queue')
     .option('--type <type>', 'Signal type: news | user_note | external', 'user_note')
+    .option('--json', 'JSON output')
     .action(async (id, content, opts, cmd) => {
     const g = cmd.optsWithGlobals();
-    await run(() => (0, signal_js_1.signalCommand)(id, content, { type: opts.type, apiKey: g.apiKey, apiUrl: g.apiUrl }));
+    await run(() => (0, signal_js_1.signalCommand)(id, content, { type: opts.type, json: opts.json, apiKey: g.apiKey, apiUrl: g.apiUrl }));
 });
 // ── sf evaluate <id> ──────────────────────────────────────────────────────────
 program
@@ -497,6 +598,42 @@ program
     }
     await run(() => (0, book_js_1.bookCommand)(tickers, opts));
 });
+// ── sf prompt ────────────────────────────────────────────────────────────────
+program
+    .command('prompt [thesisId]')
+    .description('Get dynamic system prompt with live thesis state (for agent injection)')
+    .option('--sections <list>', 'Include: thesis,tree,edges,evaluation,orderbook (default: all)')
+    .option('--max-length <n>', 'Max character length (default: 3000)')
+    .option('--json', 'JSON format with metadata')
+    .action(async (thesisId, opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    await run(() => (0, prompt_js_1.promptCommand)(thesisId, {
+        sections: opts.sections,
+        maxLength: opts.maxLength,
+        json: opts.json,
+        apiKey: g.apiKey,
+        apiUrl: g.apiUrl,
+    }));
+});
+// ── sf augment <thesisId> ────────────────────────────────────────────────────
+program
+    .command('augment <thesisId>')
+    .description('Review & merge suggested causal tree nodes from evaluations')
+    .option('--dry-run', 'Preview accepted nodes without applying')
+    .option('--json', 'JSON output')
+    .action(async (thesisId, opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    await run(() => (0, augment_js_1.augmentCommand)(thesisId, { dryRun: opts.dryRun, json: opts.json, apiKey: g.apiKey, apiUrl: g.apiUrl }));
+});
+// ── sf query "question" ──────────────────────────────────────────────────────
+program
+    .command('query <question>')
+    .description('LLM-enhanced prediction market knowledge search (no auth required)')
+    .option('--json', 'JSON output')
+    .option('--limit <n>', 'Max results per category (default 10)', '10')
+    .action(async (question, opts) => {
+    await run(() => (0, query_js_1.queryCommand)(question, { json: opts.json, limit: opts.limit }));
+});
 // ── sf telegram ──────────────────────────────────────────────────────────────
 program
     .command('telegram')

package/dist/telegram/agent-bridge.js

@@ -363,13 +363,18 @@ async function getOrCreateAgent(sfClient, session) {
     const systemPrompt = `You are a prediction market trading assistant on Telegram. Your job is to help the user see reality clearly and make correct trading decisions.
 
 ## Framework
-Edge = thesis price - market price. Positive = market underprices. Negative = overpriced.
-Contracts with large edge + good liquidity = most tradeable.
+Edge = thesis price - market price. Positive = market underprices.
+Edge types: [consensus] depth>=500 real opponents, [attention] depth<100 illusory, [timing] market lags, [risk_premium] platform risk. Tag when reporting.
+Price: depth >= 500 = consensus, < 100 = unreliable, spread > 5 = noisy.
 
 ## Rules
+- When reporting an edge, tag it: [consensus] [attention] [timing] [risk_premium].
+- If any kill condition is triggered or approaching, lead with that.
+- If nothing material to do, say "quiet — no action needed." Don't pad.
 - Keep Telegram messages SHORT — bullet points, no walls of text.
 - Prices in cents (¢). P&L in dollars ($). Don't re-convert tool output units.
 - Call tools for fresh data. Never guess prices or P&L from this prompt.
+- You don't know user's positions. Call get_positions before discussing trades.
 - If user mentions news, inject_signal immediately. Don't ask "should I?"
 - If user says "evaluate" or "run it", trigger immediately.
 - Don't end with "anything else?" — user will ask.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spfunctions/cli",
-  "version": "1.5.2",
+  "version": "1.6.1",
   "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"