@jellyos/agent 0.1.4 → 0.1.6

package/dist/session/MemoryStore.js

@@ -0,0 +1,166 @@
+/**
+ * MemoryStore — persistent long-term memory using Node 22+ built-in SQLite.
+ * (#7 — cross-session memory)
+ *
+ * Stores all conversation messages, searchable by keyword and session.
+ * Injected into system prompt at session_start to give the agent awareness
+ * of past decisions, prices seen, strategies discussed.
+ *
+ * Uses node:sqlite (experimental in Node 22, stable in Node 24) — zero deps.
+ */
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const JELLY_HOME = process.env.JELLYOS_HOME ?? join(homedir(), ".jelly");
+export class MemoryStore {
+    db = null;
+    available = false;
+    constructor() {
+        this.init();
+    }
+    init() {
+        try {
+            // node:sqlite is available in Node 22+ (experimental) and Node 24 (stable)
+            // We import it dynamically to avoid a hard crash on older Node versions
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const sqlite = require("node:sqlite");
+            mkdirSync(JELLY_HOME, { recursive: true });
+            this.db = new sqlite.DatabaseSync(join(JELLY_HOME, "memory.db"));
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS messages (
+          id        INTEGER PRIMARY KEY AUTOINCREMENT,
+          sessionId TEXT    NOT NULL,
+          role      TEXT    NOT NULL,
+          content   TEXT    NOT NULL,
+          tokens    INTEGER DEFAULT 0,
+          ts        INTEGER NOT NULL,
+          tags      TEXT    DEFAULT '[]'
+        );
+        CREATE INDEX IF NOT EXISTS idx_session ON messages(sessionId);
+        CREATE INDEX IF NOT EXISTS idx_ts      ON messages(ts);
+        -- Prune old entries automatically (keep last 10k messages)
+        CREATE TRIGGER IF NOT EXISTS prune_old_messages
+          AFTER INSERT ON messages
+          WHEN (SELECT COUNT(*) FROM messages) > 10000
+          BEGIN
+            DELETE FROM messages WHERE id IN (
+              SELECT id FROM messages ORDER BY ts ASC LIMIT 500
+            );
+          END;
+      `);
+            this.available = true;
+        }
+        catch {
+            // SQLite not available (Node <22) — memory store degrades gracefully
+            this.available = false;
+        }
+    }
+    get isAvailable() { return this.available; }
+    // ── Write ──────────────────────────────────────────────────────────────────
+    save(sessionId, role, content, tags = []) {
+        if (!this.available)
+            return;
+        try {
+            const tokens = Math.ceil(content.length / 4);
+            // Cap content at 2KB per entry to keep DB lean
+            const capped = content.length > 2000 ? content.slice(0, 2000) + "…" : content;
+            this.db.prepare(`INSERT INTO messages (sessionId, role, content, tokens, ts, tags)
+         VALUES (?, ?, ?, ?, ?, ?)`).run(sessionId, role, capped, tokens, Date.now(), JSON.stringify(tags));
+        }
+        catch { /* best effort */ }
+    }
+    // ── Read ───────────────────────────────────────────────────────────────────
+    /** Keyword search across all sessions */
+    search(query, limit = 8) {
+        if (!this.available)
+            return [];
+        try {
+            const rows = this.db.prepare(`SELECT * FROM messages WHERE content LIKE ? ORDER BY ts DESC LIMIT ?`).all(`%${query}%`, limit);
+            return rows.map((r) => ({
+                ...r,
+                tags: JSON.parse(r["tags"] ?? "[]"),
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Get summaries of recent sessions (for system prompt injection) */
+    getRecentSessions(limit = 5) {
+        if (!this.available)
+            return [];
+        try {
+            const rows = this.db.prepare(`
+        SELECT
+          sessionId,
+          COUNT(*) as msgCount,
+          MAX(ts)  as ts,
+          GROUP_CONCAT(
+            CASE WHEN role = 'user'      THEN SUBSTR(content, 1, 120)
+                 WHEN role = 'assistant' THEN SUBSTR(content, 1, 120)
+                 END,
+            ' | '
+          ) as summary
+        FROM messages
+        GROUP BY sessionId
+        ORDER BY ts DESC
+        LIMIT ?
+      `).all(limit);
+            return rows.map((r) => ({
+                sessionId: r["sessionId"],
+                summary: (r["summary"] ?? "").slice(0, 400),
+                msgCount: r["msgCount"],
+                ts: r["ts"],
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Get all messages for a specific session */
+    getSession(sessionId) {
+        if (!this.available)
+            return [];
+        try {
+            const rows = this.db.prepare(`SELECT * FROM messages WHERE sessionId = ? ORDER BY ts ASC`).all(sessionId);
+            return rows.map((r) => ({
+                ...r,
+                tags: JSON.parse(r["tags"] ?? "[]"),
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Build a short memory context block for system prompt injection */
+    buildContextBlock(currentSessionId) {
+        if (!this.available)
+            return "";
+        const recent = this.getRecentSessions(3).filter(s => s.sessionId !== currentSessionId);
+        if (recent.length === 0)
+            return "";
+        const lines = ["\n## Memory from Past Sessions"];
+        for (const s of recent) {
+            const ago = Math.round((Date.now() - s.ts) / 60_000);
+            const agoStr = ago < 60 ? `${ago}m ago` : ago < 1440 ? `${Math.round(ago / 60)}h ago` : `${Math.round(ago / 1440)}d ago`;
+            lines.push(`- [${agoStr}] ${s.summary.slice(0, 200)}`);
+        }
+        lines.push("");
+        return lines.join("\n");
+    }
+    getStats() {
+        if (!this.available)
+            return { totalMessages: 0, totalSessions: 0 };
+        try {
+            const { count } = this.db.prepare(`SELECT COUNT(*) as count FROM messages`).get();
+            const { sessions } = this.db.prepare(`SELECT COUNT(DISTINCT sessionId) as sessions FROM messages`).get();
+            return { totalMessages: count, totalSessions: sessions };
+        }
+        catch {
+            return { totalMessages: 0, totalSessions: 0 };
+        }
+    }
+}
+/** Singleton */
+export const memoryStore = new MemoryStore();
+//# sourceMappingURL=MemoryStore.js.map

package/dist/session/SessionManager.d.ts

@@ -1,10 +1,22 @@
 /**
  * SessionManager — manages conversation history, compaction, and persistence.
  *
- * History is kept in memory. If it exceeds MAX_HISTORY_CHARS worth of rough char count,
- * older messages are dropped, keeping only the most recent 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
  */
 import type { Message } from "../runner/ModelClient.js";
+/** Context pressure levels for UI display and swarm gating */
+export interface ContextPressure {
+    chars: number;
+    pct: number;
+    level: "green" | "yellow" | "red" | "critical";
+    turboReady: boolean;
+}
 export declare class SessionManager {
     private history;
     private systemPrompt;
@@ -14,10 +26,39 @@ export declare class SessionManager {
     addMessages(msgs: Message[]): void;
     /** Returns messages ready to send to the model — system prompt prepended */
     getMessages(): Message[];
-    /** Full raw history (no system) */
+    /** Full raw history (no system prompt) */
     getHistory(): Message[];
     clear(): void;
+    charCount(): number;
+    getContextPressure(): ContextPressure;
     private buildSystemContent;
-    private maybeCompact;
+    /**
+     * Split history into atomic turns.
+     * A turn = [user_msg, assistant_msg, ...tool_result_msgs]
+     * Keeping turns atomic prevents orphaned tool_call_id errors.
+     */
+    private splitIntoTurns;
+    /**
+     * Tier 1: Trim long tool results in-place. No messages dropped.
+     * Replaces content >TOOL_RESULT_CAP chars with a 1-line summary.
+     */
+    private trimToolResults;
+    /**
+     * Tier 2: Drop oldest turns, but ANCHOR high-value messages (prices, signals,
+     * decisions) so they survive compaction. (#36 semantic anchor compaction)
+     */
+    private dropOldTurns;
+    /** #36: Score a message's semantic importance (0-10) */
+    private messageWeight;
+    maybeCompact(): void;
+    /** Force compaction */
+    forceCompact(): void;
+    /**
+     * #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
+     */
+    summarizeOldTurns(summarizeCallback: (messages: Message[]) => Promise<string>): Promise<void>;
 }
 //# sourceMappingURL=SessionManager.d.ts.map

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_HISTORY_CHARS worth of rough char count,
- * older messages are dropped, keeping only the most recent 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;
-        // Drop oldest messages; keep only the most recent KEEP_RECENT
-        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