@psiclawops/hypermem 0.5.0 → 0.5.1

package/dist/compaction-fence.d.ts

@@ -0,0 +1,89 @@
+/**
+ * hypermem Compaction Fence
+ *
+ * Protects the recent conversation tail from being compacted.
+ *
+ * The fence is a per-conversation high-water mark (message ID) that divides
+ * the message timeline into two zones:
+ *
+ *   - ABOVE the fence: messages the LLM can currently see (recent tail).
+ *     These are off-limits to compaction.
+ *   - BELOW the fence: older messages eligible for compaction/summarization.
+ *
+ * The compositor updates the fence every compose cycle by recording the
+ * oldest message ID that was included in the composed context. This means
+ * the fence automatically advances as conversations grow.
+ *
+ * Safety defaults:
+ *   - No fence row = no compaction allowed (explicit opt-in)
+ *   - Fence never moves backward (monotone progress)
+ *   - Fence update is idempotent (same value = no-op)
+ *
+ * Inspired by the continuity model in openclaw-memory-libravdb, which
+ * formally proves that compaction must never touch the recent tail.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+export interface CompactionFence {
+    conversationId: number;
+    /** Message ID of the oldest message currently visible to the LLM */
+    fenceMessageId: number;
+    /** Timestamp of the last fence update */
+    updatedAt: string;
+}
+export interface CompactionEligibility {
+    conversationId: number;
+    /** Total messages below the fence (eligible for compaction) */
+    eligibleCount: number;
+    /** Message ID of the oldest eligible message */
+    oldestEligibleId: number | null;
+    /** Message ID of the newest eligible message (just below fence) */
+    newestEligibleId: number | null;
+    /** The fence itself */
+    fence: CompactionFence | null;
+}
+/**
+ * Add the compaction_fences table to an existing messages.db.
+ * Idempotent — safe to call on every startup.
+ */
+export declare function ensureCompactionFenceSchema(db: DatabaseSync): void;
+/**
+ * Update the compaction fence for a conversation.
+ *
+ * Called by the compositor after assembling context, passing the ID of
+ * the oldest message that was included in the composed history.
+ *
+ * The fence only moves forward (monotone progress). If the new fence
+ * is lower than the existing one, the update is silently ignored.
+ * This prevents a short compose window from accidentally exposing
+ * already-compacted messages.
+ */
+export declare function updateCompactionFence(db: DatabaseSync, conversationId: number, oldestVisibleMessageId: number): void;
+/**
+ * Get the current compaction fence for a conversation.
+ * Returns null if no fence has been set (meaning: no compaction allowed).
+ */
+export declare function getCompactionFence(db: DatabaseSync, conversationId: number): CompactionFence | null;
+/**
+ * Query compaction eligibility for a conversation.
+ *
+ * Returns the count and range of messages that are below the fence
+ * and therefore eligible for compaction. If no fence exists, returns
+ * zero eligible (safe default: no fence = no compaction).
+ *
+ * Excludes messages that are already covered by a summary
+ * (via the summary_messages junction table).
+ */
+export declare function getCompactionEligibility(db: DatabaseSync, conversationId: number): CompactionEligibility;
+/**
+ * Get messages eligible for compaction (below the fence, not yet summarized).
+ *
+ * Returns messages in chronological order, ready for clustering.
+ * Respects the fence boundary and excludes already-summarized messages.
+ */
+export declare function getCompactableMessages(db: DatabaseSync, conversationId: number, limit?: number): Array<{
+    id: number;
+    role: string;
+    textContent: string;
+    createdAt: string;
+}>;
+//# sourceMappingURL=compaction-fence.d.ts.map

package/dist/compaction-fence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction-fence.d.ts","sourceRoot":"","sources":["../src/compaction-fence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIhD,MAAM,WAAW,eAAe;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,oEAAoE;IACpE,cAAc,EAAE,MAAM,CAAC;IACvB,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB,+DAA+D;IAC/D,aAAa,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,mEAAmE;IACnE,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,uBAAuB;IACvB,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;CAC/B;AAID;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAQlE;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,YAAY,EAChB,cAAc,EAAE,MAAM,EACtB,sBAAsB,EAAE,MAAM,GAC7B,IAAI,CAqBN;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,YAAY,EAChB,cAAc,EAAE,MAAM,GACrB,eAAe,GAAG,IAAI,CAYxB;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,EAAE,EAAE,YAAY,EAChB,cAAc,EAAE,MAAM,GACrB,qBAAqB,CAwCvB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,YAAY,EAChB,cAAc,EAAE,MAAM,EACtB,KAAK,GAAE,MAAY,GAClB,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CA8B7E"}

package/dist/compaction-fence.js

@@ -0,0 +1,153 @@
+/**
+ * hypermem Compaction Fence
+ *
+ * Protects the recent conversation tail from being compacted.
+ *
+ * The fence is a per-conversation high-water mark (message ID) that divides
+ * the message timeline into two zones:
+ *
+ *   - ABOVE the fence: messages the LLM can currently see (recent tail).
+ *     These are off-limits to compaction.
+ *   - BELOW the fence: older messages eligible for compaction/summarization.
+ *
+ * The compositor updates the fence every compose cycle by recording the
+ * oldest message ID that was included in the composed context. This means
+ * the fence automatically advances as conversations grow.
+ *
+ * Safety defaults:
+ *   - No fence row = no compaction allowed (explicit opt-in)
+ *   - Fence never moves backward (monotone progress)
+ *   - Fence update is idempotent (same value = no-op)
+ *
+ * Inspired by the continuity model in openclaw-memory-libravdb, which
+ * formally proves that compaction must never touch the recent tail.
+ */
+// ─── Schema ─────────────────────────────────────────────────────
+/**
+ * Add the compaction_fences table to an existing messages.db.
+ * Idempotent — safe to call on every startup.
+ */
+export function ensureCompactionFenceSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS compaction_fences (
+      conversation_id INTEGER PRIMARY KEY REFERENCES conversations(id),
+      fence_message_id INTEGER NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
+}
+// ─── Fence Operations ───────────────────────────────────────────
+/**
+ * Update the compaction fence for a conversation.
+ *
+ * Called by the compositor after assembling context, passing the ID of
+ * the oldest message that was included in the composed history.
+ *
+ * The fence only moves forward (monotone progress). If the new fence
+ * is lower than the existing one, the update is silently ignored.
+ * This prevents a short compose window from accidentally exposing
+ * already-compacted messages.
+ */
+export function updateCompactionFence(db, conversationId, oldestVisibleMessageId) {
+    const now = new Date().toISOString();
+    const existing = db.prepare('SELECT fence_message_id FROM compaction_fences WHERE conversation_id = ?').get(conversationId);
+    if (!existing) {
+        // First fence for this conversation
+        db.prepare('INSERT INTO compaction_fences (conversation_id, fence_message_id, updated_at) VALUES (?, ?, ?)').run(conversationId, oldestVisibleMessageId, now);
+        return;
+    }
+    // Monotone progress: fence only moves forward
+    if (oldestVisibleMessageId > existing.fence_message_id) {
+        db.prepare('UPDATE compaction_fences SET fence_message_id = ?, updated_at = ? WHERE conversation_id = ?').run(oldestVisibleMessageId, now, conversationId);
+    }
+}
+/**
+ * Get the current compaction fence for a conversation.
+ * Returns null if no fence has been set (meaning: no compaction allowed).
+ */
+export function getCompactionFence(db, conversationId) {
+    const row = db.prepare('SELECT conversation_id, fence_message_id, updated_at FROM compaction_fences WHERE conversation_id = ?').get(conversationId);
+    if (!row)
+        return null;
+    return {
+        conversationId: row.conversation_id,
+        fenceMessageId: row.fence_message_id,
+        updatedAt: row.updated_at,
+    };
+}
+/**
+ * Query compaction eligibility for a conversation.
+ *
+ * Returns the count and range of messages that are below the fence
+ * and therefore eligible for compaction. If no fence exists, returns
+ * zero eligible (safe default: no fence = no compaction).
+ *
+ * Excludes messages that are already covered by a summary
+ * (via the summary_messages junction table).
+ */
+export function getCompactionEligibility(db, conversationId) {
+    const fence = getCompactionFence(db, conversationId);
+    if (!fence) {
+        return {
+            conversationId,
+            eligibleCount: 0,
+            oldestEligibleId: null,
+            newestEligibleId: null,
+            fence: null,
+        };
+    }
+    // Messages below the fence that haven't been summarized yet
+    const stats = db.prepare(`
+    SELECT
+      COUNT(*) AS cnt,
+      MIN(m.id) AS oldest_id,
+      MAX(m.id) AS newest_id
+    FROM messages m
+    WHERE m.conversation_id = ?
+      AND m.id < ?
+      AND m.id NOT IN (
+        SELECT sm.message_id FROM summary_messages sm
+        JOIN summaries s ON sm.summary_id = s.id
+        WHERE s.conversation_id = ?
+      )
+  `).get(conversationId, fence.fenceMessageId, conversationId);
+    return {
+        conversationId,
+        eligibleCount: stats.cnt,
+        oldestEligibleId: stats.oldest_id,
+        newestEligibleId: stats.newest_id,
+        fence,
+    };
+}
+/**
+ * Get messages eligible for compaction (below the fence, not yet summarized).
+ *
+ * Returns messages in chronological order, ready for clustering.
+ * Respects the fence boundary and excludes already-summarized messages.
+ */
+export function getCompactableMessages(db, conversationId, limit = 100) {
+    const fence = getCompactionFence(db, conversationId);
+    if (!fence)
+        return [];
+    const rows = db.prepare(`
+    SELECT m.id, m.role, m.text_content, m.created_at
+    FROM messages m
+    WHERE m.conversation_id = ?
+      AND m.id < ?
+      AND m.text_content IS NOT NULL
+      AND m.id NOT IN (
+        SELECT sm.message_id FROM summary_messages sm
+        JOIN summaries s ON sm.summary_id = s.id
+        WHERE s.conversation_id = ?
+      )
+    ORDER BY m.id ASC
+    LIMIT ?
+  `).all(conversationId, fence.fenceMessageId, conversationId, limit);
+    return rows.map(r => ({
+        id: r.id,
+        role: r.role,
+        textContent: r.text_content,
+        createdAt: r.created_at,
+    }));
+}
+//# sourceMappingURL=compaction-fence.js.map

package/dist/compositor.d.ts

@@ -0,0 +1,226 @@
+/**
+ * hypermem Compositor
+ *
+ * Assembles context for LLM calls by orchestrating all four memory layers:
+ *   L1 Redis    — hot session working memory (system, identity, recent msgs)
+ *   L2 Messages — conversation history from messages.db
+ *   L3 Vectors  — semantic search across all indexed content
+ *   L4 Library  — structured knowledge (facts, preferences, knowledge, episodes)
+ *
+ * Token-budgeted: never exceeds the budget, prioritizes by configured order.
+ * Provider-neutral internally, translates at the output boundary.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+import type { ComposeRequest, ComposeResult, NeutralMessage, CompositorConfig } from './types.js';
+import { CollectionTrigger } from './trigger-registry.js';
+import { CacheLayer } from './cache.js';
+type AnyCache = CacheLayer;
+import { VectorStore } from './vector-store.js';
+import { type OrgRegistry } from './cross-agent.js';
+export { CollectionTrigger, DEFAULT_TRIGGERS, matchTriggers } from './trigger-registry.js';
+export { getTurnAge, applyToolGradient, appendToolSummary, truncateWithHeadTail, applyTierPayloadCap, evictLargeToolResults };
+/**
+ * Public reshape helper: apply tool gradient then trim to fit within a token budget.
+ *
+ * Used by the plugin's budget-downshift pass to pre-process a Redis history window
+ * after a model switch to a smaller context window, before the full compose pipeline
+ * runs. Trims from oldest to newest until estimated token cost fits within
+ * tokenBudget * 0.65 (using the standard char/4 heuristic).
+ *
+ * @param messages     NeutralMessage array from the Redis hot window
+ * @param tokenBudget  Effective token budget for this session
+ * @returns            Trimmed message array ready for setWindow()
+ */
+export declare function applyToolGradientToWindow(messages: NeutralMessage[], tokenBudget: number, totalWindowTokens?: number): NeutralMessage[];
+/**
+ * Canonical history must remain lossless for tool turns.
+ *
+ * If a window contains any structured tool calls or tool results, the caller
+ * should treat applyToolGradientToWindow() as a view-only transform for the
+ * current compose pass and avoid writing the reshaped messages back into the
+ * canonical cache/history store.
+ */
+export declare function canPersistReshapedHistory(messages: NeutralMessage[]): boolean;
+declare function truncateWithHeadTail(content: string, maxChars: number, maxTailChars?: number): string;
+declare function appendToolSummary(textContent: string | null, summary: string): string;
+declare function getTurnAge(messages: NeutralMessage[], index: number): number;
+declare function applyTierPayloadCap(msg: NeutralMessage, perResultCap: number, perTurnCap?: number, usedSoFar?: number, maxTailChars?: number): {
+    msg: NeutralMessage;
+    usedChars: number;
+};
+declare function evictLargeToolResults<T extends NeutralMessage>(messages: T[]): T[];
+/**
+ * Apply gradient tool treatment to a message array.
+ *
+ * Tiers are based on turn age, where turn age is the number of newer user
+ * messages after the current message.
+ */
+declare function applyToolGradient<T extends NeutralMessage>(messages: T[], opts?: {
+    totalWindowTokens?: number;
+}): T[];
+export interface CompositorDeps {
+    cache: AnyCache;
+    vectorStore?: VectorStore | null;
+    libraryDb?: DatabaseSync | null;
+    /** Custom trigger registry; defaults to DEFAULT_TRIGGERS if not provided */
+    triggerRegistry?: CollectionTrigger[];
+}
+export declare class Compositor {
+    private readonly config;
+    private readonly cache;
+    private vectorStore;
+    private readonly libraryDb;
+    private readonly triggerRegistry;
+    /** Cached org registry loaded from fleet_agents at construction time. */
+    private _orgRegistry;
+    constructor(deps: CompositorDeps, config?: Partial<CompositorConfig>);
+    /**
+     * Set or replace the vector store after construction.
+     * Called by hypermem.create() once sqlite-vec is confirmed available.
+     */
+    setVectorStore(vs: VectorStore): void;
+    /**
+     * Hot-reload the org registry from the fleet_agents table.
+     * Call after fleet membership changes (new agent, org restructure)
+     * to pick up the latest without a full restart.
+     * Falls back to the current cached registry if the DB is unavailable.
+     */
+    refreshOrgRegistry(): OrgRegistry;
+    /**
+     * Return the currently cached org registry.
+     */
+    get orgRegistry(): OrgRegistry;
+    /**
+     * Compose a complete message array for sending to an LLM.
+     *
+     * Orchestrates all four memory layers:
+     *   1. System prompt + identity (never truncated)
+     *   2. Conversation history (L1 Redis → L2 messages.db)
+     *   3. Active facts from library (L4)
+     *   4. Knowledge entries relevant to conversation (L4)
+     *   5. User preferences (L4)
+     *   6. Semantic recall via vector search (L3)
+     *   7. Cross-session context (L2)
+     *
+     * Each slot respects the remaining token budget.
+     */
+    compose(request: ComposeRequest, db: DatabaseSync, libraryDb?: DatabaseSync): Promise<ComposeResult>;
+    /**
+     * Warm a session from SQLite into Redis.
+     * Called on session start or Redis cache miss.
+     */
+    warmSession(agentId: string, sessionKey: string, db: DatabaseSync, opts?: {
+        systemPrompt?: string;
+        identity?: string;
+        libraryDb?: DatabaseSync;
+        /** Model string for budget resolution. If omitted, falls back to defaultTokenBudget. */
+        model?: string;
+    }): Promise<void>;
+    refreshRedisGradient(agentId: string, sessionKey: string, db: DatabaseSync, tokenBudget?: number): Promise<void>;
+    /**
+     * Get slot content: try Redis first, fall back to SQLite.
+     */
+    private getSlotContent;
+    /**
+     * Get conversation history: try Redis first, fall back to SQLite.
+     *
+     * When topicId is provided (P3.4), the SQLite path filters to messages
+     * matching that topic OR with topic_id IS NULL (Option B transition safety).
+     * The Redis path is unaffected — Redis doesn't index by topic, so topic
+     * filtering only applies to the SQLite fallback.
+     */
+    private getHistory;
+    /**
+     * Build facts content from library DB.
+     */
+    /**
+     * Build facts content from library DB.
+     * Applies filterByScope (W1) to enforce retrieval access control.
+     * Returns [content, factCount, scopeFilteredCount] or null if DB unavailable.
+     */
+    private buildFactsFromDb;
+    /**
+     * Build knowledge content from library DB.
+     * Prioritizes high-confidence, non-superseded entries.
+     */
+    private buildKnowledgeFromDb;
+    /**
+     * Build wiki page context for the active topic.
+     * Queries the knowledge table for a synthesized topic page and returns it
+     * wrapped with a header. Capped at 600 tokens.
+     */
+    private buildWikiPageContext;
+    /**
+     * Build preferences content from library DB.
+     * Shows user/operator preferences relevant to this agent.
+     */
+    private buildPreferencesFromDb;
+    /**
+     * Build semantic recall content using hybrid FTS5+KNN retrieval.
+     *
+     * Uses Reciprocal Rank Fusion to merge keyword and vector results.
+     * Gracefully degrades: FTS5-only when no vector store, KNN-only
+     * when FTS query is empty (all stop words), both when available.
+     *
+     * @param precomputedEmbedding — optional pre-computed embedding for the query.
+     *   When provided, the Ollama call inside VectorStore.search() is skipped.
+     */
+    private buildSemanticRecall;
+    /**
+     * Format a hybrid search result for injection into context.
+     * Shows retrieval source(s) and relevance score.
+     */
+    private formatHybridResult;
+    /**
+     * Format a vector-only search result (legacy fallback).
+     */
+    private formatVectorResult;
+    /**
+     * Build cross-session context by finding recent activity
+     * in other sessions for this agent.
+     */
+    private buildCrossSessionContext;
+    /**
+     * Extract the last user message text from the composed messages.
+     */
+    private getLastUserMessage;
+    /**
+     * Truncate text to approximately fit within a token budget.
+     * Truncates at line boundaries when possible.
+     */
+    private truncateToTokens;
+    /**
+     * Query and score keystone candidates from before the current history window.
+     *
+     * Trims the oldest messages from includedHistory to free a keystone budget,
+     * then queries the DB for older messages scored by episode significance,
+     * FTS5 relevance, and recency.
+     *
+     * Returns null if keystones cannot be injected (no cutoff ID found,
+     * no candidates, or all errors).
+     */
+    private buildKeystones;
+    /**
+     * Pull high-signal messages from OTHER topics in this session when their
+     * content is semantically relevant to the current active topic.
+     *
+     * Heuristic-only: no model calls. Token overlap between the current topic
+     * name + last 3 user messages and candidate message content.
+     *
+     * @param agentId      - The agent's ID
+     * @param sessionKey   - Current session key
+     * @param activeTopic  - The current active topic (id + name)
+     * @param currentMessages - Recently included history messages for query extraction
+     * @param db           - The messages database
+     * @param maxKeystones - Max cross-topic keystones to return (default 3)
+     * @returns Scored keystones sorted by score DESC, deduplicated by message id
+     */
+    private getKeystonesByTopic;
+    /**
+     * Extract lowercase key terms from a topic name and the last 3 user messages.
+     * Terms are: tokens with ≥4 characters (skip short stop words).
+     * Returns a Set for O(1) lookup.
+     */
+    private extractQueryTerms;
+}
+//# sourceMappingURL=compositor.d.ts.map

package/dist/compositor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compositor.d.ts","sourceRoot":"","sources":["../src/compositor.ts"],"names":[],"mappings":"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"}