@jellyos/agent 0.1.4 → 0.1.6

package/dist/runner/AgentRunner.js

@@ -7,9 +7,39 @@
  * 4. Emits events so the TUI can render incrementally
  */
 import { ModelClient, resolveModelChain, } from "./ModelClient.js";
-import { ToolDispatcher } from "./ToolDispatcher.js";
+import { ToolDispatcher, forecastContextGrowth } from "./ToolDispatcher.js";
 import { SwarmRouter } from "./SwarmRouter.js";
+import { priceFeed } from "../tools/PriceFeed.js";
+import { newsFeed } from "../tools/NewsSentiment.js";
+import { Tracer } from "../telemetry/Tracer.js";
 const MAX_TOOL_ROUNDS = 12;
+const REFLECT_AT_ROUND = 6;
+function detectTaskType(message) {
+    const m = message.toLowerCase();
+    if (/\bhow much|price of|worth|cost of|current price\b/.test(m))
+        return "price_check";
+    if (/\brsi|macd|bollinger|technical|chart|candle|ohlcv\b/.test(m))
+        return "ta_analysis";
+    if (/\bcode|script|write|implement|function|typescript|python\b/.test(m))
+        return "code";
+    if (/\bpredict|forecast|will.*price|going to|expect.*price\b/.test(m))
+        return "prediction";
+    if (/\bnews|sentiment|latest|headlines|today.*market\b/.test(m))
+        return "news_summary";
+    if (/\bstrategy|plan|portfolio|risk|position|trade\b/.test(m))
+        return "strategy";
+    return "general";
+}
+// Task → tier mapping: cheap tasks go to workers, deep tasks go to orchestrators
+const TASK_TIER_MAP = {
+    price_check: "worker", // fast cheap answer: $0.02-0.10/M
+    news_summary: "worker", // simple text summarization
+    code: "worker", // qwen3-coder, deepseek are great
+    ta_analysis: "analyst", // needs math accuracy
+    general: "analyst", // balanced
+    strategy: "orchestrator", // needs deep reasoning
+    prediction: "orchestrator", // thinking model for max effect
+};
 /** Effect level → swarm behaviour config */
 const EFFECT_SWARM = {
     eco: { threshold: 999, maxAgents: 0 }, // never swarm
@@ -23,17 +53,27 @@ export class AgentRunner {
     onEvent;
     sessionCtx;
     effectLevel;
+    goalManager;
+    contextStore;
     modelChain;
     dispatcher;
     swarmRouter;
     modelRegistry;
     costTracker;
-    constructor(registry, session, onEvent, sessionCtx, effectLevel = "normal", modelReg, costTracker) {
+    abortController = null;
+    /** #25: Cancel the current in-flight stream immediately */
+    abort() {
+        this.abortController?.abort();
+        this.abortController = null;
+    }
+    constructor(registry, session, onEvent, sessionCtx, effectLevel = "normal", modelReg, costTracker, goalManager, contextStore) {
         this.registry = registry;
         this.session = session;
         this.onEvent = onEvent;
         this.sessionCtx = sessionCtx;
         this.effectLevel = effectLevel;
+        this.goalManager = goalManager;
+        this.contextStore = contextStore;
         this.modelRegistry = modelReg;
         this.costTracker = costTracker;
         this.modelChain = resolveModelChain(modelReg);
@@ -60,20 +100,106 @@ export class AgentRunner {
     }
     /** Run one user turn — may invoke multiple tool rounds and model fallbacks internally */
     async run(userMessage) {
-        // 1. Fire before_agent_start hooks — extension injects live context, system prompt
+        // #30: Start trace for this turn
+        const sessionId = `jelly-${Date.now().toString(36)}`;
+        const tracer = new Tracer(sessionId, userMessage);
+        // 1. Fire before_agent_start hooks
         await this.registry.fireHook("before_agent_start", this.sessionCtx);
-        // 2. Sync system prompt from registry (extension may have called setSystemPrompt)
-        this.session.setSystemPrompt(this.registry.getSystemPrompt());
-        // 3. Check swarm eligibility before adding to history
+        // 2. #38: Rebuild dynamic system prompt each turn
+        const basePrompt = this.registry.getSystemPrompt();
+        const dynamicSuffix = this.buildDynamicSystemSuffix();
+        this.session.setSystemPrompt(basePrompt + dynamicSuffix);
+        // 3. #40/#32: Pre-flight context pressure check — smart compact if needed
+        const pressure = this.session.getContextPressure();
+        if (pressure.pct >= 85 && pressure.pct < 95) {
+            // #32: Try tier-2 summarization with cheap model before hard-dropping turns
+            await this.session.summarizeOldTurns(async (messages) => {
+                const chain = resolveModelChain(this.modelRegistry);
+                // Use cheapest available model for summarization (worker or free tier)
+                const summaryCfg = chain[chain.length - 1] ?? chain[0];
+                const client = new ModelClient(summaryCfg, this.modelRegistry);
+                const preview = messages
+                    .map(m => `${m.role}: ${typeof m.content === "string" ? m.content.slice(0, 150) : "[tool call]"}`)
+                    .join("\n");
+                let out = "";
+                for await (const chunk of client.stream([
+                    { role: "system", content: "Summarize the following conversation in 3-5 bullet points. Be specific about prices, decisions, and findings." },
+                    { role: "user", content: preview },
+                ], [])) {
+                    if (chunk.type === "delta" && chunk.text)
+                        out += chunk.text;
+                }
+                return out || "(summary unavailable)";
+            });
+        }
+        else if (pressure.pct >= 95) {
+            this.session.forceCompact();
+        }
+        // 4. #33: Guard swarm against insufficient context headroom
         if (this.swarmRouter.shouldSwarm(userMessage)) {
+            if (!this.session.getContextPressure().turboReady) {
+                this.onEvent({ type: "text_delta", text: "\u26a1 Compacting context for turbo mode...\n" });
+                this.session.forceCompact();
+            }
             await this.runSwarm(userMessage);
             return;
         }
-        // 4. Single-agent path — add user message to history
-        this.session.addMessage({ role: "user", content: userMessage });
-        await this.runSingleAgent();
+        // 5. #16: Inject live market context into the user message
+        const enriched = await this.buildLiveContext(userMessage);
+        this.session.addMessage({ role: "user", content: enriched });
+        await this.runSingleAgent(userMessage, tracer);
+        tracer.flush("ok");
         this.onEvent({ type: "turn_done" });
     }
+    // ── #16: Live market context injection ─────────────────────────────────────
+    async buildLiveContext(message) {
+        const parts = [];
+        // Extract ticker symbols mentioned in the message
+        const tickerRe = /\b(BTC|ETH|SOL|BNB|MATIC|ARB|OP|AVAX|LINK|UNI|DOGE|XRP|ADA|DOT|ATOM|NEAR|SUI|APT|PEPE|AAVE|WIF|BONK)\b/gi;
+        const mentioned = [...new Set((message.match(tickerRe) ?? []).map(s => s.toLowerCase()))];
+        if (mentioned.length > 0) {
+            const ticks = priceFeed.getMultiple(mentioned);
+            if (ticks.length > 0) {
+                parts.push("Current prices: " + ticks.map(t => priceFeed.formatPrice(t)).join(" | "));
+            }
+        }
+        // News sentiment badge if message is analysis/sentiment related
+        if (/sentiment|news|market|mood|bullish|bearish|fear|greed/i.test(message)) {
+            const badge = newsFeed.statusBadge();
+            if (badge && badge !== "📰 ?")
+                parts.push(`News: ${badge}`);
+        }
+        if (parts.length === 0)
+            return message;
+        return `<live_context>\n${parts.join("\n")}\n</live_context>\n\n${message}`;
+    }
+    // ── #38: Dynamic system prompt suffix ──────────────────────────────────────
+    buildDynamicSystemSuffix() {
+        const sections = [];
+        // Active goals
+        const goals = this.goalManager?.getActive() ?? [];
+        if (goals.length > 0) {
+            sections.push(`\n## Active Goals\n${goals.map(g => `- [${g.id}] ${g.text}`).join("\n")}`);
+        }
+        // Active task context references
+        const activeTasks = this.contextStore?.getActiveTasks() ?? [];
+        if (activeTasks.length > 0) {
+            sections.push(`\n## Saved Task Context\n` +
+                activeTasks.map(t => this.contextStore.getReference(t.taskId)).join("\n"));
+        }
+        // Context pressure advisory
+        const pressure = this.session.getContextPressure();
+        if (pressure.level === "red" || pressure.level === "critical") {
+            sections.push(`\n## ⚠ Context Window at ${pressure.pct}%\n` +
+                `Be concise. Prefer short summaries. Use read_task_context() for historical data rather than repeating it. ` +
+                `${pressure.turboReady ? "" : "Swarm mode is temporarily paused to preserve headroom."}`);
+        }
+        // Effect level advisory
+        if (this.effectLevel === "eco") {
+            sections.push("\n## Mode: ECO\nBe brief. Minimize tool calls. Prefer one tool per response.");
+        }
+        return sections.join("");
+    }
     // ── Swarm path ─────────────────────────────────────────────────────────────
     async runSwarm(userMessage) {
         const systemPrompt = this.registry.getSystemPrompt();
@@ -85,7 +211,7 @@ export class AgentRunner {
                 ms: result.ms,
                 remaining,
             });
-        });
+        }, this.contextStore);
         this.onEvent({ type: "swarm_review", subCount: subResults.length });
         // Stream reviewer synthesis token-by-token (already complete — re-emit as deltas)
         for (const ch of synthesis) {
@@ -97,25 +223,48 @@ export class AgentRunner {
         this.onEvent({ type: "turn_done" });
     }
     // ── Single-agent path (also used for each sub-task in turbo/max) ────────────
-    async runSingleAgent() {
+    async runSingleAgent(userMessage, tracer) {
         const openAITools = this.registry.toOpenAITools();
+        const t0 = Date.now();
+        this.abortController = new AbortController();
+        const abortSignal = this.abortController.signal;
         let rounds = 0;
+        // #37: Route to appropriate model tier based on task type
+        let taskModelChain = this.modelChain;
+        if (userMessage && this.modelRegistry) {
+            const taskType = detectTaskType(userMessage);
+            const targetTier = TASK_TIER_MAP[taskType];
+            // For max effect + prediction tasks, enable thinking mode
+            const useThinking = this.effectLevel === "max" && taskType === "prediction";
+            const taskModel = this.modelRegistry.pick(targetTier);
+            if (taskModel) {
+                const cfg = this.modelRegistry.buildConfig(taskModel.id, this.modelChain[0]?.maxTokens ?? 8192, this.modelChain[0]?.temperature ?? 0.7, targetTier);
+                if (cfg) {
+                    if (useThinking) {
+                        cfg.thinkingEnabled = true;
+                        cfg.thinkingBudget = 8000;
+                    }
+                    taskModelChain = [cfg, ...this.modelChain.filter(m => m.model !== cfg.model)];
+                }
+            }
+        }
         while (rounds < MAX_TOOL_ROUNDS) {
             rounds++;
             const messages = this.session.getMessages();
             let assistantText = "";
             let pendingToolCalls = [];
             let modelError = null;
+            let usageTokens = null;
             // Try model chain — rotate on 429/5xx
-            for (let mi = 0; mi < this.modelChain.length; mi++) {
-                const cfg = this.modelChain[mi];
+            for (let mi = 0; mi < taskModelChain.length; mi++) {
+                const cfg = taskModelChain[mi];
                 const client = new ModelClient(cfg, this.modelRegistry);
                 assistantText = "";
                 pendingToolCalls = [];
                 modelError = null;
                 let gotError = false;
                 let isRateLimit = false;
-                for await (const chunk of client.stream(messages, openAITools)) {
+                for await (const chunk of client.stream(messages, openAITools, abortSignal)) {
                     if (chunk.type === "delta" && chunk.text) {
                         assistantText += chunk.text;
                         this.onEvent({ type: "text_delta", text: chunk.text });
@@ -123,9 +272,18 @@ export class AgentRunner {
                     else if (chunk.type === "tool_call" && chunk.tool_calls) {
                         pendingToolCalls = chunk.tool_calls;
                     }
+                    else if (chunk.type === "done" && chunk.finish_reason === "aborted") {
+                        // #25: Stream was aborted by user — clean exit
+                        this.onEvent({ type: "turn_done" });
+                        return;
+                    }
+                    else if (chunk.type === "done" && chunk.usage) {
+                        usageTokens = chunk.usage;
+                    }
                     else if (chunk.type === "error") {
                         modelError = chunk.error ?? "Unknown model error";
                         gotError = true;
+                        this.costTracker?.recordError(); // #1: track errors
                         // Rotate on 429 rate-limit OR any 5xx server error
                         isRateLimit = /429|rate.?limit/i.test(modelError)
                             || (chunk.status !== undefined && chunk.status >= 500);
@@ -135,7 +293,7 @@ export class AgentRunner {
                 if (!gotError)
                     break; // success — use this model's output
                 // Rotate to next model on rate-limit or server errors
-                const nextCfg = this.modelChain[mi + 1];
+                const nextCfg = taskModelChain[mi + 1];
                 // Save any partial text the user already saw before rotating
                 if (assistantText.trim()) {
                     this.session.addMessage({ role: "assistant", content: assistantText + "\n\n[connection interrupted — retrying with fallback model]" });
@@ -160,6 +318,22 @@ export class AgentRunner {
                 this.onEvent({ type: "error", message: modelError });
                 return;
             }
+            // #1: Record cost for this model call
+            if (this.costTracker && !modelError) {
+                const cfg = this.modelChain[0];
+                if (usageTokens) {
+                    this.costTracker.record(cfg.model, usageTokens.prompt_tokens, usageTokens.completion_tokens, Date.now() - t0);
+                }
+                else {
+                    // Fallback: estimate from char counts (~4 chars per token)
+                    const allMsgs = this.session.getMessages();
+                    const promptChars = allMsgs.reduce((n, m) => n + (typeof m.content === "string" ? m.content.length : 0), 0);
+                    const promptTok = Math.ceil(promptChars / 4);
+                    const completeTok = Math.ceil(assistantText.length / 4);
+                    this.costTracker.record(cfg.model, promptTok, completeTok, Date.now() - t0);
+                }
+                usageTokens = null; // reset for next round
+            }
             // Save assistant turn
             const assistantMsg = {
                 role: "assistant",
@@ -169,13 +343,69 @@ export class AgentRunner {
             this.session.addMessage(assistantMsg);
             if (pendingToolCalls.length === 0)
                 break;
-            // Dispatch tool calls
+            // #9: Reflection — at mid-point, force model to assess progress
+            if (rounds === REFLECT_AT_ROUND) {
+                this.session.addMessage({
+                    role: "user",
+                    content: `[AGENT REFLECTION — round ${rounds}/${MAX_TOOL_ROUNDS}] ` +
+                        `You have used ${rounds} tool calls. ` +
+                        `Summarize what you have found so far, then decide: ` +
+                        `(a) you have enough to answer — do so now, or ` +
+                        `(b) you need specific additional data — state exactly what and use ONE more tool. ` +
+                        `Do not call tools unless you have a clear remaining gap.`,
+                });
+            }
+            // #10: Check for tools requiring approval before dispatching
+            const approvedCalls = [];
             for (const tc of pendingToolCalls) {
+                const toolDef = this.registry.getTool(tc.function.name);
+                if (toolDef?.requiresApproval) {
+                    const approved = await new Promise((resolve) => {
+                        this.onEvent({
+                            type: "approval_request",
+                            toolName: tc.function.name,
+                            args: tc.function.arguments,
+                            approve: resolve,
+                        });
+                        // Auto-deny after 60 seconds if no response
+                        setTimeout(() => resolve(false), 60_000);
+                    });
+                    if (!approved) {
+                        // Inject a denial message so model knows it was blocked
+                        this.session.addMessage({
+                            role: "tool",
+                            content: `Tool "${tc.function.name}" was denied by user. Do not retry without asking explicitly.`,
+                            name: tc.function.name,
+                            tool_call_id: tc.id,
+                        });
+                        this.onEvent({ type: "tool_done", name: tc.function.name, result: "[DENIED by user]", isError: true });
+                        continue;
+                    }
+                }
+                approvedCalls.push(tc);
+            }
+            for (const tc of approvedCalls) {
                 this.onEvent({ type: "tool_start", name: tc.function.name, args: tc.function.arguments });
+                tracer?.startSpan(`tool:${tc.function.name}`, { args: tc.function.arguments.slice(0, 100) });
+            }
+            if (approvedCalls.length === 0)
+                continue;
+            // #40: Pre-tool context budget forecast — compact proactively if needed
+            const forecastedGrowth = forecastContextGrowth(approvedCalls);
+            const currentChars = this.session.charCount();
+            const forecastedPct = (currentChars + forecastedGrowth) / 80_000 * 100;
+            if (forecastedPct > 90) {
+                // Pre-compact before tools add more content
+                this.session.forceCompact();
+                this.onEvent({ type: "text_delta", text: `\n⚡ Pre-compacting context (forecast: ${forecastedPct.toFixed(0)}% after tools)\n` });
             }
-            const results = await this.dispatcher.dispatch(pendingToolCalls);
+            const results = await this.dispatcher.dispatch(approvedCalls);
             for (const r of results) {
                 this.onEvent({ type: "tool_done", name: r.name, result: r.content, isError: r.isError });
+                // #30: End tool span
+                const toolSpan = tracer?.trace?.spans?.slice().reverse().find((s) => s.name === `tool:${r.name}` && !s.durationMs);
+                if (toolSpan)
+                    tracer?.endSpan(toolSpan.spanId, r.isError ? "error" : "ok", { resultLen: r.content.length });
                 this.session.addMessage({
                     role: "tool",
                     content: r.content,

package/dist/runner/ModelClient.d.ts

@@ -37,6 +37,11 @@ export interface ChatChunk {
     finish_reason?: string;
     /** HTTP status code — used by AgentRunner for rate-limit detection */
     status?: number;
+    /** Token usage reported by provider on final chunk */
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+    };
 }
 export interface ModelConfig {
     baseUrl: string;
@@ -46,6 +51,10 @@ export interface ModelConfig {
     temperature: number;
     siteUrl?: string;
     siteName?: string;
+    /** Enable extended thinking for Claude Opus 4.x / o3 / Qwen3 thinking models (#13) */
+    thinkingEnabled?: boolean;
+    /** Thinking token budget — only applies when thinkingEnabled=true (#13) */
+    thinkingBudget?: number;
 }
 /**
  * Build the ordered model fallback chain.
@@ -83,6 +92,6 @@ export declare class ModelClient {
             description: string;
             parameters: unknown;
         };
-    }>): AsyncGenerator<ChatChunk>;
+    }>, abortSignal?: AbortSignal): AsyncGenerator<ChatChunk>;
 }
 //# sourceMappingURL=ModelClient.d.ts.map

package/dist/runner/ModelClient.js

@@ -127,7 +127,7 @@ export class ModelClient {
      * chunk and returns — the caller (AgentRunner) decides whether to rotate.
      * Also reports success/failure to the ModelRegistry for tiering and cooldown.
      */
-    async *stream(messages, tools) {
+    async *stream(messages, tools, abortSignal) {
         const t0 = Date.now();
         let hadError = false;
         const headers = {
@@ -139,16 +139,68 @@ export class ModelClient {
             headers["HTTP-Referer"] = this.cfg.siteUrl;
         if (this.cfg.siteName)
             headers["X-Title"] = this.cfg.siteName;
+        // #13: Detect thinking-capable models
+        const THINKING_MODELS = new Set([
+            "anthropic/claude-opus-4.7", "anthropic/claude-opus-4.7-fast",
+            "anthropic/claude-opus-4.6", "anthropic/claude-opus-4.6-fast",
+            "anthropic/claude-opus-4.5", "anthropic/claude-opus-4",
+            "openai/o3", "openai/o3-pro", "openai/o3-mini",
+            "openai/o4", "openai/o4-mini",
+        ]);
+        const isThinkingModel = THINKING_MODELS.has(this.cfg.model) || /thinking/i.test(this.cfg.model);
+        const useThinking = this.cfg.thinkingEnabled && isThinkingModel;
+        const isOSeries = /openai\/o[34]/i.test(this.cfg.model);
+        const isAnthropicModel = this.cfg.model.startsWith("anthropic/") ||
+            this.cfg.baseUrl.includes("anthropic.com");
+        // Build request body
         const body = {
             model: this.cfg.model,
-            messages,
             max_tokens: this.cfg.maxTokens,
-            temperature: this.cfg.temperature,
             stream: true,
         };
+        // #13: Temperature handling — o-series does not support temperature
+        if (!isOSeries) {
+            body.temperature = useThinking ? 1.0 : this.cfg.temperature; // thinking requires 1.0
+        }
+        // #15: Prompt caching for Anthropic — extract system message, add cache_control
+        if (isAnthropicModel) {
+            const sysMsg = messages.find(m => m.role === "system");
+            const rest = messages.filter(m => m.role !== "system");
+            if (sysMsg && typeof sysMsg.content === "string" && sysMsg.content.length > 512) {
+                // Cache the system prompt (saves up to 90% on repeated calls)
+                body.system = [{
+                        type: "text",
+                        text: sysMsg.content,
+                        cache_control: { type: "ephemeral" },
+                    }];
+                body.messages = rest;
+            }
+            else {
+                body.messages = messages;
+            }
+            // #13: Extended thinking for Claude Opus 4.x
+            if (useThinking) {
+                body.thinking = { type: "enabled", budget_tokens: this.cfg.thinkingBudget ?? 8000 };
+                headers["anthropic-beta"] = "thinking-v1";
+            }
+        }
+        else {
+            body.messages = messages;
+        }
+        // #13: o-series reasoning effort
+        if (isOSeries && useThinking) {
+            body.reasoning_effort = "high";
+        }
         if (tools && tools.length > 0) {
-            body.tools = tools;
+            // strict: true enforces valid JSON on GPT-4o+ and GPT-5.x
+            // Skip strict mode for o-series (not supported) and thinking models
+            body.tools = tools.map(t => ({
+                ...t,
+                function: isOSeries ? t.function : { ...t.function, strict: true },
+            }));
             body.tool_choice = "auto";
+            // Disable parallel tool calls — prevents race conditions in tool_call_id map
+            body.parallel_tool_calls = false;
         }
         const MAX_RETRIES = 2;
         const RETRY_STATUSES = new Set([429, 500, 502, 503, 504]);
@@ -156,14 +208,23 @@ export class ModelClient {
         let lastError = "";
         for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
             try {
+                // #25: Combine user abort signal with 120s timeout
+                const timeoutSignal = AbortSignal.timeout(120_000);
+                const combinedSignal = abortSignal
+                    ? AbortSignal.any([abortSignal, timeoutSignal])
+                    : timeoutSignal;
                 res = await fetch(`${this.cfg.baseUrl}/chat/completions`, {
                     method: "POST",
                     headers,
                     body: JSON.stringify(body),
-                    signal: AbortSignal.timeout(120_000),
+                    signal: combinedSignal,
                 });
             }
             catch (e) {
+                if (e?.name === "AbortError") {
+                    yield { type: "done", finish_reason: "aborted" };
+                    return;
+                }
                 hadError = true;
                 lastError = `Network error: ${e.message}`;
                 if (attempt < MAX_RETRIES) {
@@ -238,6 +299,17 @@ export class ModelClient {
                     }
                 }
                 const finish = chunk.choices?.[0]?.finish_reason;
+                // Capture usage from final chunk (OpenAI/OpenRouter send this on finish)
+                if (chunk.usage) {
+                    yield {
+                        type: "done",
+                        finish_reason: finish ?? "usage",
+                        usage: {
+                            prompt_tokens: chunk.usage.prompt_tokens ?? 0,
+                            completion_tokens: chunk.usage.completion_tokens ?? 0,
+                        },
+                    };
+                }
                 if (finish === "tool_calls" || finish === "stop") {
                     if (toolCallMap.size > 0) {
                         const tool_calls = [...toolCallMap.values()].map(tc => ({
@@ -248,7 +320,8 @@ export class ModelClient {
                         yield { type: "tool_call", tool_calls };
                         toolCallMap.clear();
                     }
-                    yield { type: "done", finish_reason: finish };
+                    if (!chunk.usage)
+                        yield { type: "done", finish_reason: finish };
                 }
             }
         }

package/dist/runner/SwarmRouter.d.ts

@@ -9,6 +9,7 @@
  * the provider; concurrency is capped at Math.min(maxAgents, os.cpus().length).
  */
 import type { ModelRegistry } from "../models/ModelRegistry.js";
+import type { ContextStore } from "../session/ContextStore.js";
 export interface SwarmConfig {
     /** Maximum parallel workers (hard cap: 5). Default: min(cpuCount, 3). */
     maxAgents?: number;
@@ -27,11 +28,10 @@ export interface SubTaskResult {
  * Tuned so "check ETH price" ≈ 10, "analyze ETH and BTC then predict" ≈ 55.
  */
 export declare function scoreComplexity(prompt: string): number;
-/**
- * Splits a complex prompt into 2–5 focused sub-task strings.
- * Uses simple heuristics so no extra model call is needed.
- */
-export declare function decompose(prompt: string, maxTasks: number): string[];
+/** Original heuristic decomposer — used as fallback when LLM planner fails */
+export declare function decomposeHeuristic(prompt: string, maxTasks: number): string[];
+/** Exported for tests — heuristic only, no model call */
+export declare const decompose: typeof decomposeHeuristic;
 export declare class SwarmRouter {
     private maxAgents;
     private complexityThreshold;
@@ -53,7 +53,7 @@ export declare class SwarmRouter {
      * @param systemPrompt  - Current system prompt (passed to each sub-agent + reviewer)
      * @param onProgress    - Called as each sub-task completes
      */
-    run(prompt: string, systemPrompt: string, onProgress: (result: SubTaskResult, remaining: number) => void): Promise<{
+    run(prompt: string, systemPrompt: string, onProgress: (result: SubTaskResult, remaining: number) => void, contextStore?: ContextStore): Promise<{
         synthesis: string;
         subResults: SubTaskResult[];
     }>;