@jellyos/agent 0.1.3 → 0.1.5

package/dist/session/GoalManager.d.ts

@@ -0,0 +1,101 @@
+/**
+ * GoalManager — cross-session persistent goal tracking. (#12)
+ *
+ * Goals set in one session survive restarts and are injected into the
+ * system prompt on every subsequent session. This gives the agent
+ * continuity — it knows what it was asked to watch or do.
+ *
+ * Stored in ~/.jelly/goals.json
+ * Tools: set_goal, complete_goal, list_goals, update_goal_notes
+ * Commands: /goals, /goal add <text>, /goal done <id>
+ */
+import { type Static } from "@sinclair/typebox";
+export interface Goal {
+    id: string;
+    text: string;
+    createdAt: number;
+    updatedAt: number;
+    status: "active" | "completed" | "paused";
+    notes: string[];
+}
+export declare class GoalManager {
+    private goals;
+    constructor();
+    private load;
+    private save;
+    add(text: string): Goal;
+    complete(id: string): boolean;
+    pause(id: string): boolean;
+    addNote(id: string, note: string): boolean;
+    getActive(): Goal[];
+    getAll(): Goal[];
+    get(id: string): Goal | undefined;
+    /** Build an active goals block for injection into the system prompt */
+    buildContextBlock(): string;
+    readonly setGoalParams: import("@sinclair/typebox").TObject<{
+        text: import("@sinclair/typebox").TString;
+    }>;
+    setGoalTool(_id: string, params: Static<typeof this.setGoalParams>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            goalId: string;
+            text: string;
+        };
+    }>;
+    readonly completeGoalParams: import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        note: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    completeGoalTool(_id: string, params: Static<typeof this.completeGoalParams>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            goalId: string;
+            success: boolean;
+        };
+    }>;
+    readonly listGoalsParams: import("@sinclair/typebox").TObject<{
+        status: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    listGoalsTool(_id: string, params: Static<typeof this.listGoalsParams>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            count?: undefined;
+            goals?: undefined;
+        };
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            count: number;
+            goals: Goal[];
+        };
+    }>;
+    readonly addGoalNoteParams: import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        note: import("@sinclair/typebox").TString;
+    }>;
+    addGoalNoteTool(_id: string, params: Static<typeof this.addGoalNoteParams>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            goalId: string;
+            success: boolean;
+        };
+    }>;
+}
+/** Singleton */
+export declare const goalManager: GoalManager;
+//# sourceMappingURL=GoalManager.d.ts.map

package/dist/session/GoalManager.js

@@ -0,0 +1,167 @@
+/**
+ * GoalManager — cross-session persistent goal tracking. (#12)
+ *
+ * Goals set in one session survive restarts and are injected into the
+ * system prompt on every subsequent session. This gives the agent
+ * continuity — it knows what it was asked to watch or do.
+ *
+ * Stored in ~/.jelly/goals.json
+ * Tools: set_goal, complete_goal, list_goals, update_goal_notes
+ * Commands: /goals, /goal add <text>, /goal done <id>
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { Type } from "@sinclair/typebox";
+const JELLY_HOME = process.env.JELLYOS_HOME ?? join(homedir(), ".jelly");
+const GOALS_FILE = join(JELLY_HOME, "goals.json");
+export class GoalManager {
+    goals = [];
+    constructor() {
+        this.load();
+    }
+    // ── Persistence ────────────────────────────────────────────────────────────
+    load() {
+        try {
+            if (!existsSync(GOALS_FILE))
+                return;
+            const raw = JSON.parse(readFileSync(GOALS_FILE, "utf-8"));
+            if (Array.isArray(raw))
+                this.goals = raw;
+        }
+        catch { /* start fresh */ }
+    }
+    save() {
+        try {
+            mkdirSync(JELLY_HOME, { recursive: true });
+            writeFileSync(GOALS_FILE, JSON.stringify(this.goals, null, 2), "utf-8");
+        }
+        catch { /* best effort */ }
+    }
+    // ── CRUD ───────────────────────────────────────────────────────────────────
+    add(text) {
+        const goal = {
+            id: randomUUID().slice(0, 8),
+            text: text.trim().slice(0, 500),
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            status: "active",
+            notes: [],
+        };
+        this.goals.push(goal);
+        this.save();
+        return goal;
+    }
+    complete(id) {
+        const goal = this.goals.find(g => g.id === id);
+        if (!goal)
+            return false;
+        goal.status = "completed";
+        goal.updatedAt = Date.now();
+        this.save();
+        return true;
+    }
+    pause(id) {
+        const goal = this.goals.find(g => g.id === id);
+        if (!goal)
+            return false;
+        goal.status = "paused";
+        goal.updatedAt = Date.now();
+        this.save();
+        return true;
+    }
+    addNote(id, note) {
+        const goal = this.goals.find(g => g.id === id);
+        if (!goal)
+            return false;
+        goal.notes.push(`[${new Date().toLocaleDateString()}] ${note.slice(0, 300)}`);
+        goal.updatedAt = Date.now();
+        if (goal.notes.length > 20)
+            goal.notes = goal.notes.slice(-20); // keep last 20
+        this.save();
+        return true;
+    }
+    getActive() {
+        return this.goals.filter(g => g.status === "active");
+    }
+    getAll() {
+        return [...this.goals];
+    }
+    get(id) {
+        return this.goals.find(g => g.id === id);
+    }
+    // ── System Prompt Block ────────────────────────────────────────────────────
+    /** Build an active goals block for injection into the system prompt */
+    buildContextBlock() {
+        const active = this.getActive();
+        if (active.length === 0)
+            return "";
+        const lines = ["\n## Active Goals (set by user — monitor and act on these)"];
+        for (const g of active) {
+            lines.push(`- [${g.id}] ${g.text}`);
+            if (g.notes.length > 0) {
+                lines.push(`  Last note: ${g.notes[g.notes.length - 1]}`);
+            }
+        }
+        lines.push("");
+        return lines.join("\n");
+    }
+    // ── Tools ──────────────────────────────────────────────────────────────────
+    setGoalParams = Type.Object({
+        text: Type.String({ description: "Goal text e.g. 'Watch ETH for breakout above $4000'" }),
+    });
+    async setGoalTool(_id, params) {
+        const goal = this.add(params.text);
+        return {
+            content: [{ type: "text", text: `Goal set: [${goal.id}] ${goal.text}` }],
+            details: { goalId: goal.id, text: goal.text },
+        };
+    }
+    completeGoalParams = Type.Object({
+        id: Type.String({ description: "Goal ID to mark complete" }),
+        note: Type.Optional(Type.String({ description: "Completion note" })),
+    });
+    async completeGoalTool(_id, params) {
+        if (params.note)
+            this.addNote(params.id, params.note);
+        const ok = this.complete(params.id);
+        return {
+            content: [{ type: "text", text: ok ? `Goal ${params.id} marked complete.` : `Goal ${params.id} not found.` }],
+            details: { goalId: params.id, success: ok },
+        };
+    }
+    listGoalsParams = Type.Object({
+        status: Type.Optional(Type.String({ description: "Filter: active | completed | paused | all (default: active)" })),
+    });
+    async listGoalsTool(_id, params) {
+        const filter = params.status ?? "active";
+        const goals = filter === "all" ? this.getAll() : this.goals.filter(g => g.status === filter);
+        if (goals.length === 0) {
+            return { content: [{ type: "text", text: `No ${filter} goals.` }], details: {} };
+        }
+        const lines = goals.map(g => {
+            const icon = g.status === "active" ? "🎯" : g.status === "completed" ? "✅" : "⏸";
+            const notes = g.notes.length > 0 ? `\n  Notes: ${g.notes[g.notes.length - 1]}` : "";
+            return `${icon} [${g.id}] ${g.text}${notes}`;
+        });
+        return {
+            content: [{ type: "text", text: `Goals (${filter}):\n${lines.join("\n")}` }],
+            details: { count: goals.length, goals },
+        };
+    }
+    addGoalNoteParams = Type.Object({
+        id: Type.String({ description: "Goal ID" }),
+        note: Type.String({ description: "Progress note to add" }),
+    });
+    async addGoalNoteTool(_id, params) {
+        const ok = this.addNote(params.id, params.note);
+        return {
+            content: [{ type: "text", text: ok ? `Note added to goal ${params.id}.` : `Goal ${params.id} not found.` }],
+            details: { goalId: params.id, success: ok },
+        };
+    }
+}
+/** Singleton */
+export const goalManager = new GoalManager();
+//# sourceMappingURL=GoalManager.js.map

package/dist/session/MemoryStore.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 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.
+ */
+export interface MemoryEntry {
+    id: number;
+    sessionId: string;
+    role: string;
+    content: string;
+    tokens: number;
+    ts: number;
+    tags: string[];
+}
+export interface RecentSession {
+    sessionId: string;
+    summary: string;
+    msgCount: number;
+    ts: number;
+}
+export declare class MemoryStore {
+    private db;
+    private available;
+    constructor();
+    private init;
+    get isAvailable(): boolean;
+    save(sessionId: string, role: string, content: string, tags?: string[]): void;
+    /** Keyword search across all sessions */
+    search(query: string, limit?: number): MemoryEntry[];
+    /** Get summaries of recent sessions (for system prompt injection) */
+    getRecentSessions(limit?: number): RecentSession[];
+    /** Get all messages for a specific session */
+    getSession(sessionId: string): MemoryEntry[];
+    /** Build a short memory context block for system prompt injection */
+    buildContextBlock(currentSessionId: string): string;
+    getStats(): {
+        totalMessages: number;
+        totalSessions: number;
+    };
+}
+/** Singleton */
+export declare const memoryStore: MemoryStore;
+//# sourceMappingURL=MemoryStore.d.ts.map

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_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
  */
 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