@psiclawops/hypermem 0.8.5 → 0.9.1

package/dist/compaction-fence.js

@@ -1,174 +0,0 @@
-/**
- * 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, opts = {}) {
-    const now = new Date().toISOString();
-    const minTailMessages = typeof opts.minTailMessages === 'number' && Number.isFinite(opts.minTailMessages)
-        ? Math.max(1, Math.floor(opts.minTailMessages))
-        : undefined;
-    const oldestRecentRow = minTailMessages != null
-        ? db.prepare(`
-          SELECT id FROM messages
-          WHERE conversation_id = ?
-            AND role != 'system'
-          ORDER BY message_index DESC
-          LIMIT 1 OFFSET ?
-        `).get(conversationId, minTailMessages - 1) ?? db.prepare(`
-          SELECT id FROM messages
-          WHERE conversation_id = ?
-            AND role != 'system'
-          ORDER BY message_index ASC
-          LIMIT 1
-        `).get(conversationId)
-        : undefined;
-    const clampedMessageId = oldestRecentRow
-        ? Math.min(oldestVisibleMessageId, oldestRecentRow.id)
-        : oldestVisibleMessageId;
-    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, clampedMessageId, now);
-        return;
-    }
-    // Monotone progress: fence only moves forward
-    if (clampedMessageId > existing.fence_message_id) {
-        db.prepare('UPDATE compaction_fences SET fence_message_id = ?, updated_at = ? WHERE conversation_id = ?').run(clampedMessageId, 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-utils.d.ts

@@ -1,31 +0,0 @@
-/**
- * compositor-utils.ts — Utility functions for context window composition.
- *
- * Provides ordering strategies that improve LLM attention over retrieved
- * documents placed into a prompt.
- */
-/**
- * Reorder documents using zigzag placement to mitigate
- * "Lost in the Middle" attention degradation in LLMs.
- *
- * LLMs exhibit a U-shaped attention curve: items at the beginning and end
- * of context receive ~30% more attention than items in the middle.
- * This function places the most relevant items at the edges and the least
- * relevant items near the center, maximising effective attention on the
- * information that matters most.
- *
- * Reference: Liu et al., "Lost in the Middle: How Language Models Use Long
- * Contexts", ICLR 2025. https://arxiv.org/abs/2307.03172
- *
- * Input:  [d1, d2, d3, d4, d5]  (sorted by relevance, descending)
- * Output: [d1, d3, d5, d4, d2]  (most relevant at edges, least in middle)
- *
- * Algorithm:
- *   - Items at even positions in the input (0, 2, 4, …) fill from the front.
- *   - Items at odd positions in the input (1, 3, 5, …) fill from the back.
- *
- * @param docs - Array sorted by relevance (most relevant first).
- * @returns A new array reordered so the most relevant items sit at the edges.
- */
-export declare function zigzagOrder<T>(docs: T[]): T[];
-//# sourceMappingURL=compositor-utils.d.ts.map

package/dist/compositor-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compositor-utils.d.ts","sourceRoot":"","sources":["../src/compositor-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAkB7C"}

package/dist/compositor-utils.js

@@ -1,47 +0,0 @@
-/**
- * compositor-utils.ts — Utility functions for context window composition.
- *
- * Provides ordering strategies that improve LLM attention over retrieved
- * documents placed into a prompt.
- */
-/**
- * Reorder documents using zigzag placement to mitigate
- * "Lost in the Middle" attention degradation in LLMs.
- *
- * LLMs exhibit a U-shaped attention curve: items at the beginning and end
- * of context receive ~30% more attention than items in the middle.
- * This function places the most relevant items at the edges and the least
- * relevant items near the center, maximising effective attention on the
- * information that matters most.
- *
- * Reference: Liu et al., "Lost in the Middle: How Language Models Use Long
- * Contexts", ICLR 2025. https://arxiv.org/abs/2307.03172
- *
- * Input:  [d1, d2, d3, d4, d5]  (sorted by relevance, descending)
- * Output: [d1, d3, d5, d4, d2]  (most relevant at edges, least in middle)
- *
- * Algorithm:
- *   - Items at even positions in the input (0, 2, 4, …) fill from the front.
- *   - Items at odd positions in the input (1, 3, 5, …) fill from the back.
- *
- * @param docs - Array sorted by relevance (most relevant first).
- * @returns A new array reordered so the most relevant items sit at the edges.
- */
-export function zigzagOrder(docs) {
-    if (docs.length <= 2) {
-        return docs.slice();
-    }
-    const result = new Array(docs.length);
-    let front = 0;
-    let back = docs.length - 1;
-    for (let i = 0; i < docs.length; i++) {
-        if (i % 2 === 0) {
-            result[front++] = docs[i];
-        }
-        else {
-            result[back--] = docs[i];
-        }
-    }
-    return result;
-}
-//# sourceMappingURL=compositor-utils.js.map

package/dist/compositor.d.ts

@@ -1,394 +0,0 @@
-/**
- * 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';
-import { type DegradationReason } from './degradation.js';
-/**
- * Files that OpenClaw's contextInjection injects into the system prompt.
- * HyperMem must not re-inject these via doc chunk retrieval to avoid duplication.
- * Exported so plugin and other consumers can share the same dedup set.
- */
-export declare const OPENCLAW_BOOTSTRAP_FILES: Set<string>;
-/**
- * B4: Compute model-aware lane budget fractions.
- *
- * Resolves the effective historyFraction and memoryFraction for a compose pass
- * given the model and its effective budget. Uses the MECW catalog to blend
- * away from fixed fractions when the budget approaches the MECW ceiling,
- * so the compositor allocates proportionally for what the model can actually use.
- *
- * Returns:
- *   historyFraction — fraction of effective budget to give history
- *   memoryFraction  — fraction of effective budget to give memory pool
- *   mecwProfile     — which MECW entry matched (undefined = no match / full window)
- *   mecwApplied     — true when MECW adjustment changed the fractions
- *   mecwBlend       — 0..1 blend factor (0 = below floor, 1 = at/above ceiling)
- */
-export declare function resolveModelLaneBudgets(model: string | undefined, effectiveBudget: number, configHistoryFraction: number, configMemoryFraction: number): {
-    historyFraction: number;
-    memoryFraction: number;
-    mecwProfile: string | undefined;
-    mecwApplied: boolean;
-    mecwBlend: number;
-};
-/** Session classification labels — used for adaptive depth selection. */
-export type SessionType = 'plain-chat' | 'tool-heavy';
-/**
- * Classify a session based on the ratio of tool messages in the recent sample.
- * 'tool-heavy': >= 20% of sampled messages carry tool calls or tool results.
- * 'plain-chat': below that threshold (text-only or occasional tool use).
- *
- * The 20% threshold is intentionally conservative: most tool-heavy agents
- * have tool messages on every assistant turn, so the ratio quickly exceeds
- * the threshold without false-positive risk for light tool users.
- */
-export declare function classifySessionType(messages: NeutralMessage[]): SessionType;
-/**
- * Estimate the average token cost per message from a recent message sample.
- * Uses the same estimateMessageTokens heuristic as the compositor budget walk
- * so the returned depth is directly comparable to the historyFillCap check.
- *
- * Returns a conservative floor (100 tokens) when the sample is empty to avoid
- * returning Infinity when historyBudget is divided by density.
- */
-export declare function estimateObservedMsgDensity(messages: NeutralMessage[]): number;
-/**
- * Compute an adaptive history depth that pre-fits the session type.
- *
- * For plain-chat sessions: divides historyBudget by observed density to get a
- * depth that fills the budget without overflow, bounded by the default maximum.
- * Recall quality is preserved because the density estimate is honest for
- * text-only turns.
- *
- * For tool-heavy sessions: applies a post-gradient compression factor
- * (TOOL_GRADIENT_DENSITY_FACTOR = 0.30) to the observed pre-gradient density.
- * This accounts for the gradient transform collapsing large tool payloads to
- * prose stubs before the budget-fit walk runs. A tighter depth is chosen so
- * the gradient-compressed messages fit inside historyFillCap without triggering
- * a rescue trim.
- *
- * A 0.85 safety margin is applied to both paths so estimates that are
- * slightly off don't cause immediate overflow on the first warm compose.
- *
- * Min/max bounds ensure the compositor always sees a meaningful window:
- *   - plain-chat min: 20 messages (enough for short recent context)
- *   - tool-heavy min: 15 messages (recent tool context + a few prior turns)
- *   - shared max: config.maxHistoryMessages (never exceed the DB fetch ceiling)
- */
-export declare function computeAdaptiveHistoryDepth(sessionType: SessionType, observedDensity: number, historyBudgetTokens: number, maxHistoryMessages: number): number;
-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[];
-export declare function resolveArtifactOversizeThreshold(effectiveBudget: number): number;
-/**
- * C2: Degrade an oversized doc chunk to a canonical ArtifactRef string.
- *
- * When a retrieved chunk's content exceeds the oversize threshold (in tokens),
- * replace it with a fetchable canonical reference instead of injecting raw content.
- * This preserves headroom in the lane instead of filling it with a large payload.
- *
- * Returns:
- *   - `null`  → content is within the threshold; caller should inject as-is.
- *   - `string` → canonical artifact reference; caller should inject this instead of raw content.
- *
- * The sizeTokens reported in the reference is the ACTUAL estimated size so downstream
- * tooling can make informed decisions about whether to fetch.
- */
-export declare function degradeOversizedDocChunk(chunkId: string, sourcePath: string, content: string, thresholdTokens: number): string | null;
-/**
- * C2: Resolve oversized artifacts in a history message array.
- *
- * Scans the message array and replaces user/assistant messages whose text content
- * exceeds the model-aware artifact oversize threshold with canonical ArtifactRef
- * strings. System messages, tool-call messages, and tool-result messages are always
- * passed through unchanged.
- *
- * @param messages — neutral message array (already-assembled history window)
- * @param effectiveBudget — effective model budget from B4 (drives the threshold)
- * @returns { messages, refCount, tokensSaved }
- */
-export declare function resolveOversizedArtifacts<T extends NeutralMessage>(messages: T[], effectiveBudget: number): {
-    messages: T[];
-    refCount: number;
-    tokensSaved: number;
-};
-/**
- * Result of a single tool-chain ejection pass.
- * Returned by resolveToolChainEjections so callers can accumulate telemetry.
- */
-export interface ToolChainEjectionResult<T extends NeutralMessage> {
-    /** The transformed message array (may contain stubs in place of results). */
-    messages: T[];
-    /** Number of tool-result messages fully co-ejected (removed from the array). */
-    coEjections: number;
-    /** Number of tool-result payloads replaced with a canonical stub string. */
-    stubReplacements: number;
-}
-/**
- * C1: Centralized tool-chain dependency ejection.
- *
- * Given a set of tool-use message indices that are being ejected from the
- * context window, this function ensures that no orphaned tool-results survive:
- *
- *   - For each ejected assistant message carrying toolCalls, collect the set
- *     of call IDs being removed.
- *   - Walk the remaining messages: if a message's toolResults reference any
- *     of those ejected IDs:
- *       a) If the message carries ONLY tool-results and no other text, co-eject
- *          it (remove it entirely). This is the zero-cost path.
- *       b) If the message also carries text content, replace only the dependent
- *          toolResults entries with canonical ToolChainStub strings so the
- *          message is not silently mutilated.
- *
- * The caller is responsible for removing the ejected messages by index BEFORE
- * or AFTER calling this function; this function operates on the full array and
- * marks the ejected indices for removal, returning the cleaned result.
- *
- * @param messages       Full message array (order preserved)
- * @param ejectIndices   Set of indices into `messages` that are being ejected
- *                       (these are the tool-use / assistant messages being removed).
- * @param reason         DegradationReason to embed in any canonical stubs.
- * @returns              Cleaned message array + telemetry counters.
- */
-export declare function resolveToolChainEjections<T extends NeutralMessage>(messages: T[], ejectIndices: Set<number>, reason?: DegradationReason): ToolChainEjectionResult<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;
-    /**
-     * Sprint 2.1: Hydrate tool-artifact stubs in the active turn.
-     *
-     * The active turn is the contiguous trailing block of tool-bearing messages
-     * at the tail of the assembled window (positional, NOT turn_id-based):
-     *   - Walk backward from the last message
-     *   - Collect tool-bearing messages (toolCalls != null OR toolResults != null)
-     *   - Plus the bounding user message that opened the turn
-     *   - Stop at the first plain message once at least one tool message was found
-     *
-     * For every toolResult stub with an `artifact=<id>` pointer, look up the
-     * full payload in ToolArtifactStore and replace the stub content in-place.
-     * Uses a single batched `WHERE id IN (...)` lookup (no N+1 queries).
-     * Touches `last_used_at` on every hydrated artifact in a single batch.
-     *
-     * Failure mode: if a lookup returns null (artifact missing), leave the stub
-     * unchanged and increment hydrationMisses.
-     *
-     * Returns diagnostics counters.
-     */
-    private hydrateActiveTurnArtifacts;
-    /**
-     * 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, historyDepth?: 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;
-    private buildFactSectionsFromDb;
-    /**
-     * 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

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