verybot 0.1.3

package/dist/brain/queue.js

@@ -0,0 +1,84 @@
+export class MessageQueue {
+    lanes = new Map();
+    mode;
+    processMessage;
+    constructor(opts) {
+        this.mode = opts.mode ?? "collect";
+        this.processMessage = opts.processMessage;
+    }
+    /** Enqueue a message. Returns a promise that resolves with the agent reply. */
+    enqueue(sessionKey, text) {
+        const lane = this.getOrCreateLane(sessionKey);
+        return new Promise((resolve, reject) => {
+            lane.queue.push({ text, resolve, reject });
+            // If idle, start draining
+            if (!lane.running) {
+                this.drain(sessionKey);
+            }
+        });
+    }
+    /** Abort the current run for a session. */
+    abort(sessionKey) {
+        const lane = this.lanes.get(sessionKey);
+        if (!lane?.abort)
+            return false;
+        lane.abort.abort();
+        return true;
+    }
+    /** Remove the lane for a cleared session. Aborts any in-flight run first. */
+    deleteLane(sessionKey) {
+        const lane = this.lanes.get(sessionKey);
+        if (lane?.abort)
+            lane.abort.abort();
+        this.lanes.delete(sessionKey);
+    }
+    async drain(sessionKey) {
+        const lane = this.lanes.get(sessionKey);
+        if (!lane || lane.running)
+            return;
+        lane.running = true;
+        while (lane.queue.length > 0) {
+            const batch = lane.queue.splice(0);
+            const controller = new AbortController();
+            lane.abort = controller;
+            try {
+                if (this.mode === "collect") {
+                    const combined = batch.map((m) => m.text).join("\n");
+                    const reply = await this.processMessage(sessionKey, combined, controller.signal);
+                    // Only the last message gets the reply; earlier ones resolve empty (no Telegram send)
+                    for (let i = 0; i < batch.length - 1; i++)
+                        batch[i].resolve("");
+                    batch[batch.length - 1].resolve(reply);
+                }
+                else {
+                    for (const msg of batch) {
+                        if (controller.signal.aborted) {
+                            msg.reject(new Error("Aborted"));
+                            continue;
+                        }
+                        const reply = await this.processMessage(sessionKey, msg.text, controller.signal);
+                        msg.resolve(reply);
+                    }
+                }
+            }
+            catch (err) {
+                for (const msg of batch)
+                    msg.reject(err);
+            }
+            lane.abort = null;
+            // Loop continues if new messages arrived during processing
+        }
+        lane.running = false;
+        // Remove idle lane to prevent unbounded growth
+        if (lane.queue.length === 0)
+            this.lanes.delete(sessionKey);
+    }
+    getOrCreateLane(sessionKey) {
+        let lane = this.lanes.get(sessionKey);
+        if (!lane) {
+            lane = { queue: [], running: false, abort: null };
+            this.lanes.set(sessionKey, lane);
+        }
+        return lane;
+    }
+}

package/dist/brain/run-tools.d.ts

@@ -0,0 +1,47 @@
+import type { ToolSet } from "ai";
+import type { Config } from "../config.js";
+import type { MemoryStore } from "../memory/store.js";
+import type { EmbeddingProvider } from "../memory/embedding.js";
+import type { DockerSandbox } from "../security/docker-sandbox.js";
+import type { SkillManager } from "../skills/loader.js";
+import type { IntegrationRegistry } from "../integrations/registry.js";
+import type { ScheduleStore } from "../scheduler/store.js";
+import type { DesktopAdapter } from "../computer/desktop/adapter.js";
+import type { BrowserManager } from "../computer/browser/manager.js";
+import type { AgentRegistry } from "./agent-registry.js";
+import type { ChannelStore } from "./channel-store.js";
+import type { DelegationStore } from "./delegation-store.js";
+import type { SessionStore } from "./session-store.js";
+import type { TaskStore } from "../tasks/store.js";
+import type { TeamStore } from "../teams/store.js";
+import type { ChannelManager } from "../channels/manager.js";
+/** All dependencies needed to build per-run tools. */
+export interface RunToolsDeps {
+    baseTools: ToolSet;
+    config: Config;
+    memoryStore: MemoryStore | null;
+    embeddingProvider: EmbeddingProvider | null;
+    memoryMaxResults: number;
+    sandbox: DockerSandbox | null;
+    skillManager: SkillManager;
+    integrationRegistry: IntegrationRegistry;
+    scheduleStore: ScheduleStore | null;
+    taskStore: TaskStore | null;
+    teamStore: TeamStore | null;
+    desktopAdapter: DesktopAdapter | null;
+    browserManager: BrowserManager | null;
+    /** Effective model string ("provider:id") for the current run — may differ from global config when inside a team. */
+    effectiveModel: string;
+    agentRegistry: AgentRegistry | null;
+    delegationStore: DelegationStore | null;
+    channelStore: ChannelStore | null;
+    channelManager: ChannelManager | null;
+    sessionStore: SessionStore;
+    modelId: string;
+    onWorkerComplete: (sessionKey: string, channelId: string) => void;
+}
+/** Build the per-run tool set based on current session state. */
+export declare function buildRunTools(deps: RunToolsDeps, sessionKey: string, activeIntegrations: Set<string>, channelInfo?: {
+    channelType: string;
+    channelId: string;
+}, agentId?: string, teamId?: string, scheduleTeamId?: string, sessionLabel?: string): ToolSet;

package/dist/brain/run-tools.js

@@ -0,0 +1,84 @@
+import { createBashTool } from "../tools/bash.js";
+import { createMemorySearchTool, createMemorySaveTool } from "../tools/memory.js";
+import { createDesktopTool } from "../computer/desktop/tools.js";
+import { createSpeakTools } from "../tools/speak.js";
+import { createDelegationTools } from "../tools/delegate.js";
+import { createIntegrationToggleTools } from "../tools/integration-toggle.js";
+import { createScheduleTools } from "../tools/schedule.js";
+import { createTaskTools } from "../tools/tasks.js";
+import { createTeamManagementTools } from "../tools/teams.js";
+import { createChannelHistoryTool } from "../tools/channel-history.js";
+import { DEFAULT_TEAM_ID } from "../config/agent-config.js";
+/** Build the per-run tool set based on current session state. */
+export function buildRunTools(deps, sessionKey, activeIntegrations, channelInfo, agentId, teamId, scheduleTeamId, sessionLabel) {
+    const tools = { ...deps.baseTools };
+    // Session-scoped bash tool (needs sessionKey for sandbox container routing)
+    const bashTool = createBashTool(deps.config.bash, {
+        sessionKey,
+        sandbox: deps.sandbox,
+    });
+    if (bashTool)
+        tools.bash = bashTool;
+    // When sandbox is enabled, remove fs tools — bash inside the container covers these
+    if (deps.sandbox) {
+        for (const name of ["read", "write", "edit", "grep", "find", "ls"]) {
+            delete tools[name];
+        }
+    }
+    if (deps.memoryStore) {
+        // Scope memory to team when talking to a non-default team
+        const memoryTeamId = teamId && teamId !== DEFAULT_TEAM_ID ? teamId : undefined;
+        tools.memory_search = createMemorySearchTool(deps.memoryStore, deps.embeddingProvider, deps.memoryMaxResults, memoryTeamId);
+        tools.memory_save = createMemorySaveTool(deps.memoryStore, deps.embeddingProvider, sessionKey, memoryTeamId);
+    }
+    // Desktop tool — rebuilt per-run to track model/config changes
+    if (deps.config.desktop.enabled && deps.desktopAdapter) {
+        tools.computer = createDesktopTool(deps.desktopAdapter, deps.modelId);
+    }
+    // TTS tools — rebuilt per-run so enabling/disabling takes effect immediately
+    const ttsTools = createSpeakTools(deps.config.tts);
+    if (ttsTools)
+        Object.assign(tools, ttsTools);
+    // Dynamic read_skill tool (reflects latest SkillManager state after hot-reload)
+    const readSkill = deps.skillManager.readTool;
+    if (readSkill)
+        tools.read_skill = readSkill;
+    // Integration tools (only for active integrations)
+    Object.assign(tools, deps.integrationRegistry.getToolsFor(activeIntegrations));
+    // Enable/disable integration tools (always present if integrations exist)
+    if (deps.integrationRegistry.names.length > 0) {
+        Object.assign(tools, createIntegrationToggleTools(deps.integrationRegistry, activeIntegrations));
+    }
+    // Delegation tools (only for orchestrators with workers)
+    if (agentId && deps.agentRegistry && deps.delegationStore && deps.channelStore) {
+        const workers = deps.agentRegistry.delegatableWorkers();
+        if (workers.length > 0) {
+            Object.assign(tools, createDelegationTools(deps.agentRegistry, deps.channelStore, deps.delegationStore, deps.sessionStore, agentId, sessionKey, deps.memoryStore, deps.embeddingProvider, deps.memoryMaxResults, deps.onWorkerComplete, deps.browserManager
+                ? { headless: deps.config.browserHeadless, userAgent: deps.config.browserUserAgent || undefined }
+                : null, sessionLabel));
+        }
+    }
+    // Task tools — scoped to team when talking to a specific team
+    if (deps.taskStore) {
+        Object.assign(tools, createTaskTools(deps.taskStore, teamId));
+    }
+    // Team management tools — only for the default team orchestrator
+    if (deps.teamStore && (!teamId || teamId === DEFAULT_TEAM_ID)) {
+        Object.assign(tools, createTeamManagementTools(deps.teamStore));
+    }
+    // Schedule management tools (team-scoped — uses separate scheduleTeamId to avoid default-team regression)
+    const effectiveScheduleTeamId = scheduleTeamId ?? teamId;
+    if (deps.scheduleStore && effectiveScheduleTeamId) {
+        Object.assign(tools, createScheduleTools(deps.scheduleStore, effectiveScheduleTeamId, deps.integrationRegistry.names));
+    }
+    // Channel history tool — lets the LLM read recent messages on demand.
+    // Uses a resolver callback so the channelId is read fresh at execution time,
+    // not captured in a stale closure at tool creation time.
+    if (channelInfo && deps.channelManager) {
+        const { channelType, channelId } = channelInfo;
+        const historyTool = createChannelHistoryTool(deps.channelManager, channelType, () => channelId);
+        if (historyTool)
+            tools.read_channel_history = historyTool;
+    }
+    return tools;
+}

package/dist/brain/session-key.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Build a session key: `{teamId}:{channelType}:{channelId}`.
+ */
+export declare function buildSessionKey(teamId: string, channelType: string, channelId: string): string;
+/**
+ * Extract a non-default teamId from a session key for memory scoping.
+ * Returns undefined for the default team (global memory).
+ */
+export declare function deriveMemoryTeamId(sessionKey: string): string | undefined;
+export interface ParsedSessionKey {
+    teamId?: string;
+    channelType?: string;
+    /** Agent name (for worker sessions only, extracted from key). */
+    agentName?: string;
+    isWorker: boolean;
+}
+/**
+ * Parse a session key into its components.
+ *
+ * Standard key: `{teamId}:{channelType}:{channelId}`
+ * Worker  key: `{teamId}:{parentChannel}:{channelId}:{agentName}:{timestamp}`
+ */
+export declare function parseSessionKey(key: string): ParsedSessionKey;

package/dist/brain/session-key.js

@@ -0,0 +1,41 @@
+import { DEFAULT_TEAM_ID } from "../config/agent-config.js";
+/**
+ * Build a session key: `{teamId}:{channelType}:{channelId}`.
+ */
+export function buildSessionKey(teamId, channelType, channelId) {
+    return `${teamId}:${channelType}:${channelId}`;
+}
+/**
+ * Extract a non-default teamId from a session key for memory scoping.
+ * Returns undefined for the default team (global memory).
+ */
+export function deriveMemoryTeamId(sessionKey) {
+    const { teamId } = parseSessionKey(sessionKey);
+    return teamId && teamId !== DEFAULT_TEAM_ID ? teamId : undefined;
+}
+/**
+ * Parse a session key into its components.
+ *
+ * Standard key: `{teamId}:{channelType}:{channelId}`
+ * Worker  key: `{teamId}:{parentChannel}:{channelId}:{agentName}:{timestamp}`
+ */
+export function parseSessionKey(key) {
+    const parts = key.split(":");
+    // Worker keys have 5+ parts with a numeric timestamp at the end
+    if (parts.length >= 5 && /^\d+$/.test(parts[parts.length - 1])) {
+        return {
+            isWorker: true,
+            teamId: parts[0],
+            channelType: "worker",
+            agentName: parts[parts.length - 2],
+        };
+    }
+    if (parts.length >= 3) {
+        return {
+            isWorker: false,
+            teamId: parts[0],
+            channelType: parts[1],
+        };
+    }
+    return { isWorker: false };
+}

package/dist/brain/session-state.d.ts

@@ -0,0 +1,36 @@
+import type { Session } from "./session.js";
+/** Consolidated per-session state (replaces 8 separate Maps). */
+export interface SessionState {
+    session: Session;
+    agentId?: string;
+    teamId?: string;
+    channelType?: string;
+    channelId?: string;
+    integrations?: Set<string>;
+    messagesSinceExtraction: number;
+    delegationDepth: number;
+    /** Running estimate of message tokens (chars / 4). Updated on append, reset on compaction. */
+    estimatedMsgTokens: number;
+    replyCallback?: (reply: string) => Promise<void>;
+    workerTriggerTimer?: ReturnType<typeof setTimeout>;
+    workerPendingChannels?: Set<string>;
+    /** Integrations for the next scheduled task run (consumed once by main()). */
+    scheduledIntegrations?: string[];
+}
+/**
+ * Type-safe wrapper around a Map<string, SessionState>.
+ * Provides convenient accessors and cleanup helpers.
+ */
+export declare class SessionStateMap {
+    private map;
+    get(key: string): SessionState | undefined;
+    /** Get existing state or create a new entry with the given session. */
+    getOrCreate(key: string, session: Session): SessionState;
+    /** Set a session state (used when loading from store). */
+    set(key: string, state: SessionState): void;
+    has(key: string): boolean;
+    delete(key: string): void;
+    entries(): IterableIterator<[string, SessionState]>;
+    /** Cancel all pending debounce timers (e.g. on shutdown). */
+    clearAllTimers(): void;
+}

package/dist/brain/session-state.js

@@ -0,0 +1,51 @@
+/**
+ * Type-safe wrapper around a Map<string, SessionState>.
+ * Provides convenient accessors and cleanup helpers.
+ */
+export class SessionStateMap {
+    map = new Map();
+    get(key) {
+        return this.map.get(key);
+    }
+    /** Get existing state or create a new entry with the given session. */
+    getOrCreate(key, session) {
+        let state = this.map.get(key);
+        if (!state) {
+            state = {
+                session,
+                messagesSinceExtraction: 0,
+                delegationDepth: 0,
+                estimatedMsgTokens: 0,
+            };
+            this.map.set(key, state);
+        }
+        return state;
+    }
+    /** Set a session state (used when loading from store). */
+    set(key, state) {
+        this.map.set(key, state);
+    }
+    has(key) {
+        return this.map.has(key);
+    }
+    delete(key) {
+        const state = this.map.get(key);
+        if (state?.workerTriggerTimer) {
+            clearTimeout(state.workerTriggerTimer);
+        }
+        this.map.delete(key);
+    }
+    entries() {
+        return this.map.entries();
+    }
+    /** Cancel all pending debounce timers (e.g. on shutdown). */
+    clearAllTimers() {
+        for (const state of this.map.values()) {
+            if (state.workerTriggerTimer) {
+                clearTimeout(state.workerTriggerTimer);
+                state.workerTriggerTimer = undefined;
+            }
+            state.workerPendingChannels = undefined;
+        }
+    }
+}

package/dist/brain/session-store.d.ts

@@ -0,0 +1,50 @@
+import { Session } from "./session.js";
+export interface SessionIndexEntry {
+    key: string;
+    file: string;
+    messageCount: number;
+    updatedAt: number;
+    /** Human-readable title — auto-set from first user message, editable via rename. */
+    title?: string;
+    /** Team UUID (stable reference, survives renames). */
+    teamId?: string;
+    /** Team name snapshot at save time (denormalized for fast display). */
+    teamName?: string;
+    /** Channel type: "gateway", "worker", "scheduler", "telegram", etc. */
+    channelType?: string;
+    /** Worker agent ID (stable reference for worker sessions). */
+    agentId?: string;
+    /** Worker agent name snapshot at save time (denormalized for display). */
+    agentName?: string;
+}
+export declare class SessionStore {
+    private dataDir;
+    private indexPath;
+    private index;
+    constructor(dataDir: string);
+    /** Save session to JSONL. Three modes: compaction marker, full rewrite, or append. */
+    save(session: Session): Promise<void>;
+    /** Load a session from its JSONL file. Respects compaction markers. */
+    load(sessionKey: string): Promise<Session | null>;
+    /** List all session keys with metadata. */
+    list(): SessionIndexEntry[];
+    /** Rename a session (update its title in the index). */
+    rename(sessionKey: string, title: string): boolean;
+    /**
+     * Update session metadata (team name, agent info). Only writes to disk if something changed.
+     * Note: teamName and agentName are denormalized snapshots — they may become stale if
+     * the team or agent is renamed after the session was last active.
+     */
+    updateMetadata(sessionKey: string, meta: {
+        teamId?: string;
+        teamName?: string;
+        channelType?: string;
+        agentId?: string;
+        agentName?: string;
+    }): void;
+    /** Clear a session — deletes the JSONL file and removes the index entry. */
+    clear(sessionKey: string): Promise<void>;
+    private getOrCreateEntry;
+    private loadIndex;
+    private saveIndex;
+}

package/dist/brain/session-store.js

@@ -0,0 +1,207 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Session } from "./session.js";
+import { parseSessionKey } from "./session-key.js";
+const MAX_TITLE_LEN = 30;
+function isCompaction(entry) {
+    return "type" in entry && entry.type === "compaction";
+}
+export class SessionStore {
+    dataDir;
+    indexPath;
+    index;
+    constructor(dataDir) {
+        this.dataDir = dataDir;
+        this.indexPath = path.join(dataDir, "index.json");
+        // Ensure directory exists
+        fs.mkdirSync(dataDir, { recursive: true });
+        // Load existing index
+        this.index = this.loadIndex();
+    }
+    /** Save session to JSONL. Three modes: compaction marker, full rewrite, or append. */
+    async save(session) {
+        const entry = this.getOrCreateEntry(session.key);
+        const filePath = path.join(this.dataDir, entry.file);
+        if (session.pendingCompaction) {
+            // Compaction: append marker + re-append kept messages (append-only, preserves history)
+            const marker = {
+                type: "compaction",
+                ts: Date.now(),
+                summary: session.pendingCompaction.summary,
+            };
+            const kept = session.getCompactionMessages();
+            const lines = JSON.stringify(marker) +
+                "\n" +
+                kept.map((msg) => JSON.stringify({ ts: Date.now(), message: msg })).join("\n") +
+                "\n";
+            fs.appendFileSync(filePath, lines, "utf-8");
+        }
+        else if (session.needsFullRewrite) {
+            // Emergency truncate: overwrite entire file
+            const all = session.getMessages();
+            const lines = all.map((msg) => JSON.stringify({ ts: Date.now(), message: msg })).join("\n") + "\n";
+            fs.writeFileSync(filePath, lines, "utf-8");
+        }
+        else {
+            // Normal: append only new messages
+            const newMessages = session.getNewMessages();
+            if (newMessages.length === 0)
+                return;
+            const lines = newMessages.map((msg) => JSON.stringify({ ts: Date.now(), message: msg })).join("\n") + "\n";
+            fs.appendFileSync(filePath, lines, "utf-8");
+        }
+        session.markPersisted();
+        // Update index
+        entry.messageCount = session.messageCount;
+        entry.updatedAt = Date.now();
+        // Auto-set title from first user message (once)
+        if (!entry.title) {
+            const firstUserMsg = session
+                .getMessages()
+                .find((m) => m.role === "user" && typeof m.content === "string" && m.content.trim());
+            if (firstUserMsg && typeof firstUserMsg.content === "string") {
+                const raw = firstUserMsg.content.trim().split("\n")[0];
+                entry.title = raw.length > MAX_TITLE_LEN ? raw.slice(0, MAX_TITLE_LEN - 1) + "\u2026" : raw;
+            }
+        }
+        this.saveIndex();
+    }
+    /** Load a session from its JSONL file. Respects compaction markers. */
+    async load(sessionKey) {
+        const entry = this.index.get(sessionKey);
+        if (!entry)
+            return null;
+        const filePath = path.join(this.dataDir, entry.file);
+        if (!fs.existsSync(filePath))
+            return null;
+        const content = fs.readFileSync(filePath, "utf-8");
+        const entries = [];
+        for (const line of content.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                entries.push(JSON.parse(line));
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+        // Find the last compaction marker
+        let lastCompactionIdx = -1;
+        for (let i = entries.length - 1; i >= 0; i--) {
+            if (isCompaction(entries[i])) {
+                lastCompactionIdx = i;
+                break;
+            }
+        }
+        const messages = [];
+        if (lastCompactionIdx >= 0) {
+            // Compacted: summary message + all message entries after the marker
+            const marker = entries[lastCompactionIdx];
+            messages.push({
+                role: "user",
+                content: `[Prior conversation summary]\n${marker.summary}`,
+            });
+            for (let i = lastCompactionIdx + 1; i < entries.length; i++) {
+                const e = entries[i];
+                if (!isCompaction(e)) {
+                    messages.push(e.message);
+                }
+            }
+        }
+        else {
+            // No compaction: load all messages
+            for (const e of entries) {
+                if (!isCompaction(e)) {
+                    messages.push(e.message);
+                }
+            }
+        }
+        return new Session(sessionKey, messages);
+    }
+    /** List all session keys with metadata. */
+    list() {
+        return [...this.index.values()].sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    /** Rename a session (update its title in the index). */
+    rename(sessionKey, title) {
+        if (typeof title !== "string")
+            return false;
+        const entry = this.index.get(sessionKey);
+        if (!entry)
+            return false;
+        // Strip control characters and trim
+        const sanitized = title.replace(/[\x00-\x1F\x7F-\x9F]/g, "").trim();
+        if (sanitized.length === 0)
+            return false;
+        entry.title = sanitized.length > MAX_TITLE_LEN ? sanitized.slice(0, MAX_TITLE_LEN - 1) + "\u2026" : sanitized;
+        this.saveIndex();
+        return true;
+    }
+    /**
+     * Update session metadata (team name, agent info). Only writes to disk if something changed.
+     * Note: teamName and agentName are denormalized snapshots — they may become stale if
+     * the team or agent is renamed after the session was last active.
+     */
+    updateMetadata(sessionKey, meta) {
+        const entry = this.index.get(sessionKey);
+        if (!entry)
+            return;
+        const FIELDS = ["teamId", "teamName", "channelType", "agentId", "agentName"];
+        let changed = false;
+        for (const field of FIELDS) {
+            if (meta[field] !== undefined && entry[field] !== meta[field]) {
+                entry[field] = meta[field];
+                changed = true;
+            }
+        }
+        if (changed)
+            this.saveIndex();
+    }
+    /** Clear a session — deletes the JSONL file and removes the index entry. */
+    async clear(sessionKey) {
+        const entry = this.index.get(sessionKey);
+        if (!entry)
+            return;
+        const filePath = path.join(this.dataDir, entry.file);
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+        this.index.delete(sessionKey);
+        this.saveIndex();
+    }
+    // --- internal ---
+    getOrCreateEntry(key) {
+        let entry = this.index.get(key);
+        if (!entry) {
+            const safeKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
+            const parsed = parseSessionKey(key);
+            entry = {
+                key,
+                file: `${safeKey}.jsonl`,
+                messageCount: 0,
+                updatedAt: Date.now(),
+                teamId: parsed.teamId,
+                channelType: parsed.channelType,
+            };
+            this.index.set(key, entry);
+        }
+        return entry;
+    }
+    loadIndex() {
+        if (!fs.existsSync(this.indexPath)) {
+            return new Map();
+        }
+        try {
+            const raw = JSON.parse(fs.readFileSync(this.indexPath, "utf-8"));
+            return new Map(Object.entries(raw));
+        }
+        catch {
+            return new Map();
+        }
+    }
+    saveIndex() {
+        const obj = Object.fromEntries(this.index);
+        fs.writeFileSync(this.indexPath, JSON.stringify(obj, null, 2), "utf-8");
+    }
+}

package/dist/brain/session.d.ts

@@ -0,0 +1,32 @@
+import type { LanguageModel, ModelMessage } from "ai";
+export interface PendingCompaction {
+    summary: string;
+}
+export declare class Session {
+    readonly key: string;
+    private messages;
+    private persistedCount;
+    private _pendingCompaction;
+    private _needsFullRewrite;
+    constructor(key: string, messages?: ModelMessage[]);
+    append(msg: ModelMessage): void;
+    getMessages(): ModelMessage[];
+    /** Returns only messages not yet written to disk (normal append path). */
+    getNewMessages(): ModelMessage[];
+    /** After compaction: returns kept + new messages (everything except the summary at index 0). */
+    getCompactionMessages(): ModelMessage[];
+    /** Mark all current messages as persisted. */
+    markPersisted(): void;
+    /** Pending compaction info for the store to persist as a marker. */
+    get pendingCompaction(): PendingCompaction | null;
+    /** True when the file must be fully overwritten (emergency truncate). */
+    get needsFullRewrite(): boolean;
+    /** LLM-based compaction — summarizes old messages when tokens exceed context budget. */
+    compact(model: LanguageModel, contextWindow: number, systemPrompt: string): Promise<boolean>;
+    /** Replace the internal messages array (e.g. after programmatic compaction). Marks full rewrite. */
+    replaceMessages(messages: ModelMessage[]): void;
+    /** Emergency truncation — drop oldest messages, keeping last N. */
+    truncate(keep: number): void;
+    get messageCount(): number;
+    get updatedAt(): number;
+}