@jellyos/agent 0.1.3 → 0.1.5

package/dist/session/SessionManager.js

@@ -1,11 +1,17 @@
 /**
  * SessionManager — manages conversation history, compaction, and persistence.
  *
- * History is kept in memory. If it exceeds MAX_TOKENS worth of rough char count,
- * it compacts by summarizing the oldest messages (keeps system + last N turns).
+ * Compaction is done in atomic turn pairs so tool_call_id references are
+ * never orphaned (which causes 400 errors from every provider).
+ *
+ * Three compaction tiers:
+ *   Tier 1 (>70%): trim long tool results to 1-line summaries
+ *   Tier 2 (>85%): drop oldest complete turns (atomic pairs only)
+ *   Tier 3 (>95%): hard reset keeping only last KEEP_TURNS turns
  */
 const MAX_HISTORY_CHARS = 80_000; // ~20k tokens rough estimate
-const KEEP_RECENT = 20; // always keep last N messages after compaction
+const KEEP_TURNS = 8; // complete turns to keep on hard reset
+const TOOL_RESULT_CAP = 500; // trim tool results longer than this
 export class SessionManager {
     history = [];
     systemPrompt = "";
@@ -29,22 +35,159 @@ export class SessionManager {
         const sys = { role: "system", content: this.buildSystemContent() };
         return [sys, ...this.history];
     }
-    /** Full raw history (no system) */
+    /** Full raw history (no system prompt) */
     getHistory() {
         return [...this.history];
     }
     clear() {
         this.history = [];
     }
+    charCount() {
+        return this.history.reduce((n, m) => n + (typeof m.content === "string" ? m.content.length : 0), 0);
+    }
+    getContextPressure() {
+        const chars = this.charCount();
+        const pct = Math.min(100, Math.round(chars / MAX_HISTORY_CHARS * 100));
+        return {
+            chars,
+            pct,
+            level: pct < 50 ? "green" : pct < 70 ? "yellow" : pct < 90 ? "red" : "critical",
+            turboReady: pct < 70, // keep 30% free for swarm sub-agent outputs
+        };
+    }
     buildSystemContent() {
         return this.systemPrompt || "You are JellyOS, an AI trading agent.";
     }
+    /**
+     * Split history into atomic turns.
+     * A turn = [user_msg, assistant_msg, ...tool_result_msgs]
+     * Keeping turns atomic prevents orphaned tool_call_id errors.
+     */
+    splitIntoTurns() {
+        const turns = [];
+        let current = [];
+        for (const msg of this.history) {
+            // New user message starts a new turn (unless history starts with assistant)
+            if (msg.role === "user" && current.length > 0) {
+                turns.push(current);
+                current = [];
+            }
+            current.push(msg);
+        }
+        if (current.length > 0)
+            turns.push(current);
+        return turns;
+    }
+    /**
+     * Tier 1: Trim long tool results in-place. No messages dropped.
+     * Replaces content >TOOL_RESULT_CAP chars with a 1-line summary.
+     */
+    trimToolResults() {
+        for (const msg of this.history) {
+            if (msg.role === "tool" && typeof msg.content === "string" &&
+                msg.content.length > TOOL_RESULT_CAP) {
+                const firstLine = msg.content.split("\n")[0] ?? msg.content.slice(0, 120);
+                msg.content = `${firstLine} … [trimmed, ${msg.content.length} chars]`;
+            }
+        }
+    }
+    /**
+     * Tier 2: Drop oldest turns, but ANCHOR high-value messages (prices, signals,
+     * decisions) so they survive compaction. (#36 semantic anchor compaction)
+     */
+    dropOldTurns() {
+        const turns = this.splitIntoTurns();
+        if (turns.length <= KEEP_TURNS)
+            return;
+        const recentTurns = turns.slice(-KEEP_TURNS);
+        const olderTurns = turns.slice(0, -KEEP_TURNS);
+        // #36: From older turns, extract high-weight messages as anchors
+        const anchors = [];
+        for (const turn of olderTurns) {
+            for (const msg of turn) {
+                if (this.messageWeight(msg) >= 7)
+                    anchors.push(msg);
+            }
+        }
+        // Prepend anchors (deduped) before the recent window
+        const anchorIds = new Set(anchors.map(m => `${m.role}:${String(m.content).slice(0, 50)}`));
+        const recentFlat = recentTurns.flat();
+        // Remove any anchors already in recent window
+        const recentIds = new Set(recentFlat.map(m => `${m.role}:${String(m.content).slice(0, 50)}`));
+        const dedupedAnchors = anchors.filter(m => !recentIds.has(`${m.role}:${String(m.content).slice(0, 50)}`));
+        this.history = [...dedupedAnchors, ...recentFlat];
+        void anchorIds; // suppress unused warning
+    }
+    /** #36: Score a message's semantic importance (0-10) */
+    messageWeight(msg) {
+        if (msg.role === "system")
+            return 10;
+        const content = typeof msg.content === "string" ? msg.content.toLowerCase() : "";
+        if (msg.role === "tool") {
+            // High value: price data, signals, positions, goals
+            if (/\$[\d,]+|\d+%|signal|buy|sell|position|goal|rsi|macd/.test(content))
+                return 8;
+            if (/news|sentiment|bullish|bearish|tvl|funding/.test(content))
+                return 6;
+            return 2; // generic tool result — expendable
+        }
+        if (msg.role === "user")
+            return 3;
+        if (msg.role === "assistant") {
+            // Keep assistant messages with decisions/recommendations
+            if (/recommend|suggest|should|will|plan|strategy|target|stop/.test(content))
+                return 7;
+            return 4;
+        }
+        return 1;
+    }
     maybeCompact() {
-        const totalChars = this.history.reduce((n, m) => n + (typeof m.content === "string" ? m.content.length : 0), 0);
-        if (totalChars <= MAX_HISTORY_CHARS)
+        const pct = this.getContextPressure().pct;
+        if (pct < 70)
+            return;
+        if (pct < 85) {
+            this.trimToolResults();
             return;
-        // Keep the last KEEP_RECENT messages, drop the rest
-        this.history = this.history.slice(-KEEP_RECENT);
+        } // Tier 1: trim verbose tool results
+        if (pct < 95) {
+            this.trimToolResults();
+            this.dropOldTurns();
+            return;
+        } // Tier 2: drop turns
+        // Tier 3: hard reset — emergency
+        this.trimToolResults();
+        this.dropOldTurns();
+        if (this.getContextPressure().pct >= 95) {
+            const turns = this.splitIntoTurns();
+            this.history = turns.slice(-4).flat();
+        }
+    }
+    /** Force compaction */
+    forceCompact() {
+        this.trimToolResults();
+        this.dropOldTurns();
+    }
+    /**
+     * #32: Tier-2 summarization via a cheap model.
+     * Compresses the oldest 40% of turns into a single summary message.
+     * Call this when pct is between 70-90 to reclaim space gracefully.
+     * @param summarizeCallback — provided by AgentRunner which has model access
+     */
+    async summarizeOldTurns(summarizeCallback) {
+        const turns = this.splitIntoTurns();
+        if (turns.length < 4)
+            return; // not enough history to summarize
+        const splitAt = Math.floor(turns.length * 0.4);
+        const toSummarize = turns.slice(0, splitAt).flat();
+        const toKeep = turns.slice(splitAt).flat();
+        const summary = await summarizeCallback(toSummarize);
+        this.history = [
+            {
+                role: "system",
+                content: `[CONVERSATION SUMMARY — ${toSummarize.length} earlier messages compressed]\n${summary}`,
+            },
+            ...toKeep,
+        ];
     }
 }
 //# sourceMappingURL=SessionManager.js.map

package/dist/telemetry/Tracer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Tracer — lightweight JSONL span tracing for agent observability. (#30)
+ *
+ * Zero external dependencies. Writes structured traces to ~/.jelly/traces.jsonl.
+ * Each trace covers one user turn and records all model calls, tool dispatches,
+ * and swarm sub-tasks with timing and status.
+ *
+ * View traces: cat ~/.jelly/traces.jsonl | jq
+ * Last 5 traces: tail -5 ~/.jelly/traces.jsonl | jq
+ * /traces command in REPL shows a formatted summary.
+ */
+export interface Span {
+    spanId: string;
+    name: string;
+    startMs: number;
+    durationMs?: number;
+    status: "ok" | "error" | "aborted";
+    attrs: Record<string, unknown>;
+}
+export interface Trace {
+    traceId: string;
+    sessionId: string;
+    prompt: string;
+    startMs: number;
+    durationMs?: number;
+    spans: Span[];
+    totalCost?: number;
+    modelUsed?: string;
+}
+export declare class Tracer {
+    /** @internal exposed for AgentRunner span lookup */
+    readonly trace: Trace;
+    constructor(sessionId: string, prompt: string);
+    /** Start a named span, returns spanId */
+    startSpan(name: string, attrs?: Record<string, unknown>): string;
+    /** End a span by ID */
+    endSpan(spanId: string, status?: "ok" | "error" | "aborted", attrs?: Record<string, unknown>): void;
+    /** Record model call details */
+    recordModel(spanId: string, model: string, promptTokens: number, completionTokens: number, costNano: number): void;
+    /** Flush trace to disk */
+    flush(status?: "ok" | "error" | "aborted"): void;
+    get traceId(): string;
+    /** Read last N traces from disk for /traces command */
+    static readRecent(limit?: number): Trace[];
+    /** Format traces for REPL display */
+    static formatSummary(traces: Trace[]): string;
+}
+//# sourceMappingURL=Tracer.d.ts.map

package/dist/telemetry/Tracer.js

@@ -0,0 +1,102 @@
+/**
+ * Tracer — lightweight JSONL span tracing for agent observability. (#30)
+ *
+ * Zero external dependencies. Writes structured traces to ~/.jelly/traces.jsonl.
+ * Each trace covers one user turn and records all model calls, tool dispatches,
+ * and swarm sub-tasks with timing and status.
+ *
+ * View traces: cat ~/.jelly/traces.jsonl | jq
+ * Last 5 traces: tail -5 ~/.jelly/traces.jsonl | jq
+ * /traces command in REPL shows a formatted summary.
+ */
+import { appendFileSync, existsSync, readFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
+const JELLY_HOME = process.env.JELLYOS_HOME ?? join(homedir(), ".jelly");
+const TRACES_FILE = join(JELLY_HOME, "traces.jsonl");
+export class Tracer {
+    /** @internal exposed for AgentRunner span lookup */
+    trace;
+    constructor(sessionId, prompt) {
+        this.trace = {
+            traceId: randomUUID().slice(0, 12),
+            sessionId,
+            prompt: prompt.slice(0, 200),
+            startMs: Date.now(),
+            spans: [],
+        };
+    }
+    /** Start a named span, returns spanId */
+    startSpan(name, attrs = {}) {
+        const spanId = randomUUID().slice(0, 8);
+        this.trace.spans.push({ spanId, name, startMs: Date.now(), status: "ok", attrs });
+        return spanId;
+    }
+    /** End a span by ID */
+    endSpan(spanId, status = "ok", attrs = {}) {
+        const span = this.trace.spans.find(s => s.spanId === spanId);
+        if (!span)
+            return;
+        span.durationMs = Date.now() - span.startMs;
+        span.status = status;
+        Object.assign(span.attrs, attrs);
+    }
+    /** Record model call details */
+    recordModel(spanId, model, promptTokens, completionTokens, costNano) {
+        this.endSpan(spanId, "ok", { model, promptTokens, completionTokens, costNano });
+        this.trace.modelUsed = model;
+        this.trace.totalCost = (this.trace.totalCost ?? 0) + costNano;
+    }
+    /** Flush trace to disk */
+    flush(status = "ok") {
+        this.trace.durationMs = Date.now() - this.trace.startMs;
+        try {
+            mkdirSync(JELLY_HOME, { recursive: true });
+            appendFileSync(TRACES_FILE, JSON.stringify({ ...this.trace, status, ts: Date.now() }) + "\n", "utf-8");
+        }
+        catch { /* best effort — tracing should never crash the agent */ }
+    }
+    get traceId() { return this.trace.traceId; }
+    // ── Static helpers ────────────────────────────────────────────────────────
+    /** Read last N traces from disk for /traces command */
+    static readRecent(limit = 5) {
+        try {
+            if (!existsSync(TRACES_FILE))
+                return [];
+            const lines = readFileSync(TRACES_FILE, "utf-8")
+                .trim().split("\n").filter(Boolean);
+            return lines.slice(-limit).map(l => JSON.parse(l)).reverse();
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Format traces for REPL display */
+    static formatSummary(traces) {
+        if (traces.length === 0)
+            return "No traces recorded yet.";
+        return traces.map(t => {
+            const duration = t.durationMs ? `${(t.durationMs / 1000).toFixed(1)}s` : "?s";
+            const model = t.modelUsed?.split("/").pop()?.slice(0, 20) ?? "?";
+            const spans = t.spans.length;
+            const tools = t.spans.filter(s => s.name.startsWith("tool:")).length;
+            const cost = t.totalCost ? `$${(t.totalCost / 1_000_000_000).toFixed(4)}` : "?";
+            const prompt = t.prompt.slice(0, 60);
+            const errors = t.spans.filter(s => s.status === "error").length;
+            const lines = [
+                `[${t.traceId}] ${new Date(t.startMs).toLocaleTimeString()} — ${duration} · ${model} · ${cost}`,
+                `  Prompt: "${prompt}"`,
+                `  Spans: ${spans} total, ${tools} tool calls${errors > 0 ? `, ${errors} errors` : ""}`,
+            ];
+            // Show tool spans
+            for (const span of t.spans.filter(s => s.name.startsWith("tool:"))) {
+                const icon = span.status === "ok" ? "✓" : "✗";
+                const dur = span.durationMs ? `${span.durationMs}ms` : "?";
+                lines.push(`    ${icon} ${span.name.slice(5)} (${dur})`);
+            }
+            return lines.join("\n");
+        }).join("\n\n");
+    }
+}
+//# sourceMappingURL=Tracer.js.map

package/dist/tests/ContextStore.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ContextStore.test.d.ts.map

package/dist/tests/ContextStore.test.js

@@ -0,0 +1,74 @@
+/**
+ * ContextStore tests — task lifecycle, findings, auto-delete.
+ */
+import { describe, it, expect, afterEach } from "vitest";
+import { ContextStore } from "../session/ContextStore.js";
+import { existsSync } from "node:fs";
+// Use a temp dir for tests
+process.env.JELLYOS_HOME = `/tmp/jellyos-test-${Date.now()}`;
+describe("ContextStore", () => {
+    let store;
+    afterEach(() => {
+        store = new ContextStore(); // fresh store
+    });
+    it("openTask creates a context.md file", () => {
+        store = new ContextStore();
+        const ctx = store.openTask("Test task");
+        expect(existsSync(ctx.contextMd)).toBe(true);
+        expect(ctx.taskId.length).toBeGreaterThan(0);
+        expect(ctx.findings).toBe(0);
+    });
+    it("appendFinding increments findings count", () => {
+        store = new ContextStore();
+        const ctx = store.openTask("Test");
+        store.appendFinding(ctx.taskId, "Price Data", "BTC: $70,000");
+        store.appendFinding(ctx.taskId, "RSI", "RSI: 67 bullish");
+        expect(store.getTask(ctx.taskId)?.findings).toBe(2);
+    });
+    it("getReference returns path + count info", () => {
+        store = new ContextStore();
+        const ctx = store.openTask("Analysis");
+        store.appendFinding(ctx.taskId, "Data", "some findings");
+        const ref = store.getReference(ctx.taskId);
+        expect(ref).toContain("context.md");
+        expect(ref).toContain("1 findings");
+        expect(ref).toContain(ctx.taskId);
+    });
+    it("getActiveTasks returns open tasks", () => {
+        store = new ContextStore();
+        const t1 = store.openTask("Task 1");
+        const t2 = store.openTask("Task 2");
+        const active = store.getActiveTasks();
+        expect(active.map(t => t.taskId)).toContain(t1.taskId);
+        expect(active.map(t => t.taskId)).toContain(t2.taskId);
+    });
+    it("closeTask removes from active tasks", () => {
+        store = new ContextStore();
+        const ctx = store.openTask("Temp task");
+        store.closeTask(ctx.taskId);
+        expect(store.getTask(ctx.taskId)).toBeUndefined();
+    });
+    it("keepTask prevents deletion", () => {
+        store = new ContextStore();
+        const ctx = store.openTask("Important");
+        store.keepTask(ctx.taskId);
+        expect(store.getTask(ctx.taskId)?.keep).toBe(true);
+    });
+    it("readContextTool returns file contents", async () => {
+        store = new ContextStore();
+        const ctx = store.openTask("Read test");
+        store.appendFinding(ctx.taskId, "Finding", "ETH price is $3000");
+        const result = await store.readContextTool("", { taskId: ctx.taskId });
+        expect(result.content[0]?.text).toContain("ETH price is $3000");
+    });
+    it("caps individual findings at 3000 chars", () => {
+        store = new ContextStore();
+        const ctx = store.openTask("Big task");
+        const bigContent = "x".repeat(5000);
+        store.appendFinding(ctx.taskId, "Big finding", bigContent);
+        // Should not throw and should be capped
+        const result = store.getReference(ctx.taskId);
+        expect(result).toBeTruthy();
+    });
+});
+//# sourceMappingURL=ContextStore.test.js.map

package/dist/tests/ModelRegistry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ModelRegistry.test.d.ts.map

package/dist/tests/ModelRegistry.test.js

@@ -0,0 +1,69 @@
+/**
+ * ModelRegistry tests — tier classification + temperature profiles.
+ */
+import { describe, it, expect } from "vitest";
+import { classifyModel } from "../models/ModelRegistry.js";
+function makeModel(id, promptPrice = "0.000005") {
+    return {
+        id,
+        name: id,
+        created: Date.now(),
+        description: "",
+        context_length: 128_000,
+        architecture: { modality: "text", tokenizer: "cl100k", instruct_type: null },
+        pricing: { prompt: promptPrice, completion: "0.000015" },
+        top_provider: { context_length: 128_000, max_completion_tokens: 4096, is_moderated: false },
+    };
+}
+describe("classifyModel() — 2025 models", () => {
+    // Orchestrator tier
+    it("classifies claude-opus-4.7 as orchestrator", () => {
+        expect(classifyModel(makeModel("anthropic/claude-opus-4.7"))).toBe("orchestrator");
+    });
+    it("classifies claude-opus-4.6 as orchestrator", () => {
+        expect(classifyModel(makeModel("anthropic/claude-opus-4.6"))).toBe("orchestrator");
+    });
+    it("classifies gpt-5.5 as orchestrator", () => {
+        expect(classifyModel(makeModel("openai/gpt-5.5"))).toBe("orchestrator");
+    });
+    it("classifies gpt-5.5-pro as orchestrator", () => {
+        expect(classifyModel(makeModel("openai/gpt-5.5-pro"))).toBe("orchestrator");
+    });
+    it("classifies gemini-3.1-pro as orchestrator", () => {
+        expect(classifyModel(makeModel("google/gemini-3.1-pro-preview"))).toBe("orchestrator");
+    });
+    it("classifies deepseek-v4-pro as orchestrator", () => {
+        expect(classifyModel(makeModel("deepseek/deepseek-v4-pro"))).toBe("orchestrator");
+    });
+    it("classifies grok-4.0 as orchestrator", () => {
+        expect(classifyModel(makeModel("x-ai/grok-4.0"))).toBe("orchestrator");
+    });
+    // Analyst tier
+    it("classifies claude-sonnet-4.6 as analyst", () => {
+        expect(classifyModel(makeModel("anthropic/claude-sonnet-4.6"))).toBe("analyst");
+    });
+    it("classifies claude-sonnet-4.5 as analyst", () => {
+        expect(classifyModel(makeModel("anthropic/claude-sonnet-4.5"))).toBe("analyst");
+    });
+    it("classifies gemini-3.5-flash as analyst", () => {
+        expect(classifyModel(makeModel("google/gemini-3.5-flash"))).toBe("analyst");
+    });
+    it("classifies deepseek-v4 (non-pro) as analyst", () => {
+        expect(classifyModel(makeModel("deepseek/deepseek-v4-flash"))).toBe("analyst");
+    });
+    // Free tier
+    it("classifies :free models as free", () => {
+        expect(classifyModel(makeModel("deepseek/deepseek-v4-flash:free", "0"))).toBe("free");
+    });
+    it("classifies free-priced models as free", () => {
+        expect(classifyModel(makeModel("meta-llama/llama-3.1-8b-instruct:free", "0"))).toBe("free");
+    });
+    // Worker fallback
+    it("classifies unknown model as worker", () => {
+        expect(classifyModel(makeModel("some-unknown/model-v1"))).toBe("worker");
+    });
+    it("classifies small llama as worker", () => {
+        expect(classifyModel(makeModel("meta-llama/llama-3.1-8b-instruct", "0.0002"))).toBe("worker");
+    });
+});
+//# sourceMappingURL=ModelRegistry.test.js.map

package/dist/tests/SessionManager.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=SessionManager.test.d.ts.map

package/dist/tests/SessionManager.test.js

@@ -0,0 +1,108 @@
+/**
+ * SessionManager tests — atomic compaction, context pressure, semantic anchors.
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import { SessionManager } from "../session/SessionManager.js";
+function makeUserTurn(userContent, assistantContent) {
+    return [
+        { role: "user", content: userContent },
+        { role: "assistant", content: assistantContent },
+    ];
+}
+function makeToolTurn(userContent, toolContent) {
+    const tc_id = `call_${Math.random().toString(36).slice(2)}`;
+    return [
+        { role: "user", content: userContent },
+        { role: "assistant", content: null, tool_calls: [{ id: tc_id, type: "function", function: { name: "get_prices", arguments: "{}" } }] },
+        { role: "tool", content: toolContent, name: "get_prices", tool_call_id: tc_id },
+    ];
+}
+describe("SessionManager", () => {
+    let session;
+    beforeEach(() => {
+        session = new SessionManager();
+        session.setSystemPrompt("You are JellyOS.");
+    });
+    it("getMessages() prepends system prompt", () => {
+        session.addMessage({ role: "user", content: "hello" });
+        const msgs = session.getMessages();
+        expect(msgs[0]?.role).toBe("system");
+        expect(msgs[0]?.content).toContain("JellyOS");
+        expect(msgs.length).toBe(2);
+    });
+    it("charCount() counts history chars", () => {
+        session.addMessage({ role: "user", content: "hello" });
+        expect(session.charCount()).toBe(5);
+    });
+    it("getContextPressure() returns green for small history", () => {
+        session.addMessage({ role: "user", content: "hi" });
+        const p = session.getContextPressure();
+        expect(p.level).toBe("green");
+        expect(p.turboReady).toBe(true);
+        expect(p.pct).toBeLessThan(50);
+    });
+    it("getContextPressure() reports yellow at 60%", () => {
+        // Add ~48KB of content (60% of 80KB)
+        const bigMsg = "x".repeat(48_000);
+        session.addMessage({ role: "user", content: bigMsg });
+        const p = session.getContextPressure();
+        expect(p.pct).toBeGreaterThanOrEqual(50);
+    });
+    it("turboReady is false when context >70%", () => {
+        const bigMsg = "x".repeat(60_000);
+        session.addMessage({ role: "user", content: bigMsg });
+        const p = session.getContextPressure();
+        expect(p.turboReady).toBe(false);
+    });
+    it("compaction never orphans tool_call_id pairs", () => {
+        // Add enough turns to trigger compaction
+        for (let i = 0; i < 20; i++) {
+            for (const msg of makeToolTurn(`question ${i}`, `tool result ${i} — ${"data".repeat(200)}`)) {
+                session.addMessage(msg);
+            }
+        }
+        const history = session.getHistory();
+        // Find all assistant messages with tool_calls
+        const toolCallMsgs = history.filter(m => m.tool_calls && m.tool_calls.length > 0);
+        for (const tcMsg of toolCallMsgs) {
+            for (const tc of tcMsg.tool_calls) {
+                // Every tool_call_id must have a corresponding tool result
+                const hasResult = history.some(m => m.role === "tool" && m.tool_call_id === tc.id);
+                expect(hasResult).toBe(true);
+            }
+        }
+    });
+    it("forceCompact() reduces history", () => {
+        for (let i = 0; i < 30; i++) {
+            for (const msg of makeUserTurn(`q${i}`, `a${i}`)) {
+                session.addMessage(msg);
+            }
+        }
+        const before = session.getHistory().length;
+        session.forceCompact();
+        const after = session.getHistory().length;
+        expect(after).toBeLessThanOrEqual(before);
+    });
+    it("clear() empties history", () => {
+        session.addMessage({ role: "user", content: "hello" });
+        session.clear();
+        expect(session.getHistory().length).toBe(0);
+    });
+});
+describe("SessionManager — SwarmRouter integration", () => {
+    it("scoreComplexity returns low score for simple price check", async () => {
+        const { scoreComplexity } = await import("../runner/SwarmRouter.js");
+        expect(scoreComplexity("what is the price of ETH")).toBeLessThan(40);
+    });
+    it("scoreComplexity returns high score for complex multi-chain analysis", async () => {
+        const { scoreComplexity } = await import("../runner/SwarmRouter.js");
+        const score = scoreComplexity("analyze ETH and BTC then compare their RSI and predict which will pump first");
+        expect(score).toBeGreaterThanOrEqual(40);
+    });
+    it("decomposeHeuristic splits on conjunctions", async () => {
+        const { decomposeHeuristic } = await import("../runner/SwarmRouter.js");
+        const tasks = decomposeHeuristic("analyze ETH and check BTC mempool and get SOL TPS", 5);
+        expect(tasks.length).toBeGreaterThanOrEqual(2);
+    });
+});
+//# sourceMappingURL=SessionManager.test.js.map

package/dist/tests/TechnicalAnalysis.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TechnicalAnalysis.test.d.ts.map