@psiclawops/hypermem 0.9.1 → 0.9.3

package/dist/proactive-pass.js

@@ -0,0 +1,293 @@
+/**
+ * hypermem Proactive Passes
+ *
+ * Background maintenance passes that run between indexer ticks to keep
+ * message storage lean. Two passes:
+ *
+ *   1. Noise Sweep — deletes low/zero-signal messages outside the recent
+ *      window (heartbeats, acks, empty strings, control tokens).
+ *
+ *   2. Tool Decay — truncates oversized tool_results outside the recent
+ *      window in-place, preserving JSON structure but collapsing large
+ *      content blobs into a byte-count placeholder.
+ *
+ * Both passes are:
+ *   - Synchronous (DatabaseSync, no async)
+ *   - Wrapped in transactions (atomic)
+ *   - Best-effort: catch all errors, log, and return a zero-change result
+ *
+ * Ported and adapted from ClawText proactive-pass.ts.
+ * hypermem schema differences vs ClawText:
+ *   - No content_type column — we classify on the fly via classifyContentType()
+ *   - No external payload store — we truncate content inline in tool_results JSON
+ *   - No ClawText-specific dependencies (payload-store, tool-tracker, etc.)
+ */
+import { classifyContentType } from './content-type-classifier.js';
+// ─── Internal helpers ────────────────────────────────────────────
+/**
+ * Resolve the safe window to a finite positive integer.
+ * Mirrors the ClawText resolveSafeWindow() guard.
+ */
+function resolveSafeWindow(recentWindowSize) {
+    if (Number.isFinite(recentWindowSize) && recentWindowSize > 0) {
+        return Math.floor(recentWindowSize);
+    }
+    return 20;
+}
+/**
+ * Get the maximum message_index for a conversation.
+ * Returns -1 if no messages exist.
+ */
+function getMaxMessageIndex(db, conversationId) {
+    const row = db
+        .prepare('SELECT COALESCE(MAX(message_index), -1) AS max_index FROM messages WHERE conversation_id = ?')
+        .get(conversationId);
+    return typeof row.max_index === 'number' ? row.max_index : -1;
+}
+/**
+ * Filter candidate message ids down to rows that are safe to delete without
+ * violating HyperMem's FK edges.
+ *
+ * Current blockers:
+ *   - summary_messages.message_id -> messages.id
+ *   - messages.parent_id -> messages.id (child rows point at parent rows)
+ */
+function getDeletableMessageIds(db, candidateIds) {
+    if (candidateIds.length === 0)
+        return { deletableIds: [], blockedIds: [] };
+    const placeholders = candidateIds.map(() => '?').join(', ');
+    const blocked = db
+        .prepare(`
+      SELECT DISTINCT id
+      FROM (
+        SELECT sm.message_id AS id
+        FROM summary_messages sm
+        WHERE sm.message_id IN (${placeholders})
+
+        UNION
+
+        SELECT parent.id AS id
+        FROM messages child
+        JOIN messages parent ON parent.id = child.parent_id
+        WHERE child.parent_id IN (${placeholders})
+      ) blocked
+    `)
+        .all(...candidateIds, ...candidateIds);
+    if (blocked.length === 0)
+        return { deletableIds: candidateIds, blockedIds: [] };
+    const blockedIds = blocked.map(row => row.id);
+    const blockedSet = new Set(blockedIds);
+    return {
+        deletableIds: candidateIds.filter(id => !blockedSet.has(id)),
+        blockedIds,
+    };
+}
+/**
+ * Decide if a message is noise based on content + is_heartbeat flag.
+ *
+ * A message is noise when:
+ *   - is_heartbeat = 1  (explicit heartbeat marker), OR
+ *   - text_content is NULL or empty (≤3 chars after trimming), OR
+ *   - classifyContentType() returns 'noise' or 'ack'
+ *
+ * We call the classifier rather than duplicating its patterns here.
+ */
+function isNoiseMessage(textContent, isHeartbeat) {
+    if (isHeartbeat === 1)
+        return true;
+    if (textContent === null || textContent.trim().length <= 3)
+        return true;
+    const { type } = classifyContentType(textContent);
+    return type === 'noise' || type === 'ack';
+}
+// ─── Noise Sweep ─────────────────────────────────────────────────
+/**
+ * Delete noise and heartbeat messages outside the recent window.
+ *
+ * "Outside the recent window" means message_index < maxIndex - recentWindowSize.
+ * Messages inside the window are never deleted, even if they are noise —
+ * the model may still reference them in the current turn.
+ *
+ * Deletions are wrapped in a single transaction. The FTS5 trigger handles
+ * index cleanup automatically (msg_fts_ad fires on DELETE).
+ */
+export function runNoiseSweep(db, conversationId, recentWindowSize = 20, maxCandidates = Infinity) {
+    const ZERO = { messagesDeleted: 0, passType: 'noise_sweep' };
+    try {
+        const safeWindow = resolveSafeWindow(recentWindowSize);
+        const maxIndex = getMaxMessageIndex(db, conversationId);
+        if (maxIndex < 0)
+            return ZERO;
+        // Messages with message_index strictly below this value are eligible.
+        const cutoff = maxIndex - safeWindow;
+        if (cutoff <= 0)
+            return ZERO; // Not enough history yet
+        // Fetch all candidate messages outside the recent window.
+        // Exclude messages whose content lives entirely in tool_results — those
+        // are tool result rows handled by runToolDecay(), not noise sweep.
+        // We deliberately avoid a content-based WHERE clause for the classifier
+        // because SQLite can't use the index for JS classification logic;
+        // it's cheaper to fetch a small batch and classify in JS.
+        const candidates = db
+            .prepare(`
+        SELECT id, text_content, is_heartbeat
+        FROM messages
+        WHERE conversation_id = ?
+          AND message_index < ?
+          AND (tool_results IS NULL OR tool_results = '')
+      `)
+            .all(conversationId, cutoff);
+        if (candidates.length === 0)
+            return ZERO;
+        // Filter to noise messages, respecting per-pass candidate cap
+        const toDelete = candidates.filter(row => isNoiseMessage(row.text_content, row.is_heartbeat)).slice(0, Number.isFinite(maxCandidates) ? maxCandidates : undefined);
+        if (toDelete.length === 0) {
+            return ZERO;
+        }
+        const candidateIds = toDelete.map(r => r.id);
+        const { deletableIds: ids, blockedIds } = getDeletableMessageIds(db, candidateIds);
+        if (ids.length === 0) {
+            return ZERO;
+        }
+        // Delete in a transaction; use chunked IN clauses to avoid
+        // SQLite's SQLITE_LIMIT_VARIABLE_NUMBER (default 999).
+        let totalDeleted = 0;
+        const CHUNK = 500;
+        db.prepare('BEGIN').run();
+        try {
+            for (let i = 0; i < ids.length; i += CHUNK) {
+                const chunk = ids.slice(i, i + CHUNK);
+                const placeholders = chunk.map(() => '?').join(', ');
+                const result = db
+                    .prepare(`DELETE FROM messages WHERE id IN (${placeholders})`)
+                    .run(...chunk);
+                totalDeleted += typeof result.changes === 'number' ? result.changes : chunk.length;
+            }
+            db.prepare('COMMIT').run();
+        }
+        catch (innerErr) {
+            db.prepare('ROLLBACK').run();
+            throw innerErr;
+        }
+        if (totalDeleted > 0) {
+            console.log(`[proactive-pass] Noise sweep conversation=${conversationId} candidates=${candidates.length} noise=${candidateIds.length} deleted=${totalDeleted} skippedReferenced=${blockedIds.length} cutoff=${cutoff}`);
+        }
+        return { messagesDeleted: totalDeleted, passType: 'noise_sweep' };
+    }
+    catch (err) {
+        console.warn(`[proactive-pass] Noise sweep failed for conversation ${conversationId}: ${err instanceof Error ? err.message : String(err)}`);
+        return ZERO;
+    }
+}
+// ─── Tool Decay ──────────────────────────────────────────────────
+/**
+ * Truncate oversized tool_results outside the recent window.
+ *
+ * Strategy:
+ *   1. Find messages whose tool_results JSON string is > 2000 chars total,
+ *      outside the recent window.
+ *   2. Parse the JSON array.
+ *   3. For each result entry where the `content` field exceeds 500 chars,
+ *      replace `content` with `[tool result truncated — N bytes]`.
+ *   4. Re-serialize and write back.
+ *
+ * The JSON structure is preserved (array of result objects). Only the
+ * oversized `content` values are collapsed.
+ *
+ * Mutations are committed in a single transaction.
+ */
+export function runToolDecay(db, conversationId, recentWindowSize = 40, maxCandidates = Infinity) {
+    const ZERO = { messagesUpdated: 0, bytesFreed: 0, passType: 'tool_decay' };
+    try {
+        const safeWindow = resolveSafeWindow(recentWindowSize);
+        const maxIndex = getMaxMessageIndex(db, conversationId);
+        if (maxIndex < 0) {
+            return ZERO;
+        }
+        const cutoff = maxIndex - safeWindow;
+        if (cutoff <= 0) {
+            return ZERO;
+        }
+        // Fetch messages with large tool_results outside the recent window.
+        const candidates = db
+            .prepare(`
+        SELECT id, tool_results
+        FROM messages
+        WHERE conversation_id = ?
+          AND message_index < ?
+          AND tool_results IS NOT NULL
+          AND length(tool_results) > 2000
+      `)
+            .all(conversationId, cutoff);
+        if (candidates.length === 0) {
+            return ZERO;
+        }
+        // Build the update list by processing each candidate, respecting per-pass cap.
+        const cappedCandidates = Number.isFinite(maxCandidates) ? candidates.slice(0, maxCandidates) : candidates;
+        const updates = [];
+        for (const row of cappedCandidates) {
+            let parsed;
+            try {
+                parsed = JSON.parse(row.tool_results);
+            }
+            catch {
+                // Corrupt JSON — skip this row
+                continue;
+            }
+            if (!Array.isArray(parsed))
+                continue;
+            let changed = false;
+            const newResults = parsed.map(entry => {
+                const content = entry.content;
+                if (typeof content === 'string' && content.length > 500) {
+                    const originalBytes = Buffer.byteLength(content, 'utf8');
+                    changed = true;
+                    return {
+                        ...entry,
+                        content: `[tool result truncated — ${originalBytes} bytes]`,
+                    };
+                }
+                return entry;
+            });
+            if (!changed)
+                continue;
+            const newJson = JSON.stringify(newResults);
+            const savedBytes = row.tool_results.length - newJson.length;
+            if (savedBytes > 0) {
+                updates.push({ id: row.id, newJson, savedBytes });
+            }
+        }
+        if (updates.length === 0) {
+            return ZERO;
+        }
+        let totalUpdated = 0;
+        let totalBytesFreed = 0;
+        db.prepare('BEGIN').run();
+        try {
+            const stmt = db.prepare('UPDATE messages SET tool_results = ? WHERE id = ?');
+            for (const { id, newJson, savedBytes } of updates) {
+                stmt.run(newJson, id);
+                totalUpdated++;
+                totalBytesFreed += savedBytes;
+            }
+            db.prepare('COMMIT').run();
+        }
+        catch (innerErr) {
+            db.prepare('ROLLBACK').run();
+            throw innerErr;
+        }
+        if (totalUpdated > 0) {
+            console.log(`[proactive-pass] Tool decay conversation=${conversationId} candidates=${candidates.length} updated=${totalUpdated} bytesFreed=${totalBytesFreed} cutoff=${cutoff}`);
+        }
+        return {
+            messagesUpdated: totalUpdated,
+            bytesFreed: totalBytesFreed,
+            passType: 'tool_decay',
+        };
+    }
+    catch (err) {
+        console.warn(`[proactive-pass] Tool decay failed for conversation ${conversationId}: ${err instanceof Error ? err.message : String(err)}`);
+        return ZERO;
+    }
+}
+//# sourceMappingURL=proactive-pass.js.map

package/dist/profiles.d.ts

@@ -0,0 +1,46 @@
+/**
+ * hypermem configuration profiles
+ *
+ * Pre-built configs for common deployment patterns. Pass to createHyperMem()
+ * directly or use as a base for custom configs via mergeProfile().
+ *
+ * Profiles:
+ *   minimal  — 64k context, single agent, low resource usage
+ *   standard — 128k context, fleet default, balanced
+ *   rich     — 200k+ context, multi-agent, full feature set
+ */
+import type { HyperMemConfig, EmbeddingProviderConfig } from './types.js';
+/** Gemini embedding preset — use with mergeProfile() when switching fleet to Gemini. */
+export declare const GEMINI_EMBEDDING: Partial<EmbeddingProviderConfig>;
+export declare const lightProfile: HyperMemConfig;
+export declare const standardProfile: HyperMemConfig;
+export declare const fullProfile: HyperMemConfig;
+export type ProfileName = 'light' | 'standard' | 'full';
+export declare const minimalProfile: HyperMemConfig;
+export declare const extendedProfile: HyperMemConfig;
+export declare const richProfile: HyperMemConfig;
+export declare const PROFILES: Record<ProfileName, HyperMemConfig>;
+/**
+ * Load a named profile.
+ *
+ * @example
+ * const config = getProfile('light');
+ * const hm = createHyperMem(config);
+ */
+export declare function getProfile(name: ProfileName | 'extended'): HyperMemConfig;
+/**
+ * Merge a partial config on top of a named profile.
+ * Deep-merges compositor and indexer; top-level fields are replaced.
+ *
+ * @example
+ * const config = mergeProfile('light', {
+ *   cache: { keyPrefix: 'myapp:' },
+ *   compositor: { hyperformProfile: 'standard', memoryFraction: 0.50 },  // upgrade tier + more memory
+ * });
+ */
+export declare function mergeProfile(name: ProfileName | 'extended', overrides: DeepPartial<HyperMemConfig>): HyperMemConfig;
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+export {};
+//# sourceMappingURL=profiles.d.ts.map

package/dist/profiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profiles.d.ts","sourceRoot":"","sources":["../src/profiles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAmC,uBAAuB,EAAe,MAAM,YAAY,CAAC;AAoBxH,wFAAwF;AACxF,eAAO,MAAM,gBAAgB,EAAE,OAAO,CAAC,uBAAuB,CAM7D,CAAC;AAwDF,eAAO,MAAM,YAAY,EAAE,cAa1B,CAAC;AAsDF,eAAO,MAAM,eAAe,EAAE,cAO7B,CAAC;AAuDF,eAAO,MAAM,WAAW,EAAE,cAWzB,CAAC;AAMF,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,UAAU,GAAG,MAAM,CAAC;AAGxD,eAAO,MAAM,cAAc,gBAAe,CAAC;AAC3C,eAAO,MAAM,eAAe,gBAAc,CAAC;AAC3C,eAAO,MAAM,WAAW,gBAAc,CAAC;AAEvC,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,WAAW,EAAE,cAAc,CAIxD,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,cAAc,CAIzE;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,WAAW,GAAG,UAAU,EAC9B,SAAS,EAAE,WAAW,CAAC,cAAc,CAAC,GACrC,cAAc,CAUhB;AAMD,KAAK,WAAW,CAAC,CAAC,IAAI;KACnB,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAChE,CAAC"}

package/dist/profiles.js

@@ -0,0 +1,262 @@
+/**
+ * hypermem configuration profiles
+ *
+ * Pre-built configs for common deployment patterns. Pass to createHyperMem()
+ * directly or use as a base for custom configs via mergeProfile().
+ *
+ * Profiles:
+ *   minimal  — 64k context, single agent, low resource usage
+ *   standard — 128k context, fleet default, balanced
+ *   rich     — 200k+ context, multi-agent, full feature set
+ */
+// ---------------------------------------------------------------------------
+// Shared base (fields common across all profiles)
+// ---------------------------------------------------------------------------
+const BASE_CACHE = {
+    keyPrefix: 'hm:',
+    sessionTTL: 3600,
+    historyTTL: 86400,
+};
+const BASE_EMBEDDING = {
+    ollamaUrl: 'http://localhost:11434',
+    model: 'nomic-embed-text',
+    dimensions: 768,
+    timeout: 10000,
+    batchSize: 32,
+};
+/** Gemini embedding preset — use with mergeProfile() when switching fleet to Gemini. */
+export const GEMINI_EMBEDDING = {
+    provider: 'gemini',
+    model: 'gemini-embedding-2-preview',
+    dimensions: 3072,
+    timeout: 15000,
+    batchSize: 100,
+};
+// ---------------------------------------------------------------------------
+// light — 64k context window, single agent, constrained resources
+//
+// Design intent:
+//   - Small local models (Mistral 7B, Phi-3, Llama 3 8B) at 64k context
+//   - Single agent — no cross-session context needed
+//   - Minimal ACA stack — no dreaming, no background indexing overhead
+//   - Low Redis churn — longer flush intervals, shorter history window
+//   - hyperformProfile: 'light' — ~100 token standalone directives, no fleet concepts
+//   - No parallel operations — sequential fact extraction only
+// ---------------------------------------------------------------------------
+const LIGHT_COMPOSITOR = {
+    // ── Primary budget controls ──
+    budgetFraction: 0.625, // 40k effective at 64k window
+    reserveFraction: 0.35, // generous — small systems do heavy tool work
+    historyFraction: 0.35, // ~14k tokens of conversation history
+    memoryFraction: 0.30, // ~12k tokens for facts/wiki/semantic
+    // ── Absolute fallback ──
+    defaultTokenBudget: 40000,
+    // ── History internals ──
+    maxHistoryMessages: 200,
+    warmHistoryBudgetFraction: 0.35,
+    keystoneHistoryFraction: 0.1,
+    keystoneMaxMessages: 5,
+    keystoneMinSignificance: 0.7,
+    // ── Memory internals ──
+    maxFacts: 15,
+    maxCrossSessionContext: 0,
+    maxTotalTriggerTokens: 1500,
+    wikiTokenCap: 300,
+    // ── Tool gradient (internal — safe floor enforced automatically) ──
+    maxRecentToolPairs: 2,
+    maxProseToolPairs: 4,
+    // ── Dynamic reserve ──
+    dynamicReserveEnabled: true,
+    dynamicReserveTurnHorizon: 3,
+    dynamicReserveMax: 0.50,
+    // ── HyperForm ──
+    hyperformProfile: 'light',
+};
+const LIGHT_INDEXER = {
+    enabled: true,
+    factExtractionMode: 'pattern', // pattern only — tiered extraction is heavier
+    topicDormantAfter: '12h', // faster dormancy — small systems don't need long windows
+    topicClosedAfter: '48h',
+    factDecayRate: 0.05, // slightly faster decay — fewer facts, keep them fresh
+    episodeSignificanceThreshold: 0.6, // higher bar — only store meaningful episodes
+    periodicInterval: 120000, // 2min — less frequent background work on small systems
+    batchSize: 64,
+    maxMessagesPerTick: 200,
+};
+export const lightProfile = {
+    enabled: true,
+    dataDir: './hypermem-data',
+    cache: BASE_CACHE,
+    compositor: LIGHT_COMPOSITOR,
+    indexer: LIGHT_INDEXER,
+    embedding: {
+        ...BASE_EMBEDDING,
+        batchSize: 8, // smaller batches — don't spike memory on embed
+        timeout: 15000, // more generous timeout — local hardware can be slow
+    },
+    // dreaming: disabled (default) — don't run background promotion on small systems
+    // obsidian: disabled (default)
+};
+// ---------------------------------------------------------------------------
+// standard — 128k context window, fleet default, balanced
+//
+// Design intent:
+//   - Mid-range models (Sonnet, GPT-5-mini, Gemini Flash) at 128k
+//   - Small multi-agent setups or single power-user agents
+//   - Full ACA stack — dreaming optional, background indexing on
+//   - hyperformProfile: 'standard' — full FOS, no MOD
+// ---------------------------------------------------------------------------
+const STANDARD_COMPOSITOR = {
+    // ── Primary budget controls ──
+    budgetFraction: 0.703, // 90k effective at 128k window
+    reserveFraction: 0.25, // balanced — leaves room for large tool results
+    historyFraction: 0.40, // ~27k tokens of conversation history
+    memoryFraction: 0.40, // ~27k tokens for facts/wiki/semantic
+    // ── Absolute fallback ──
+    defaultTokenBudget: 90000,
+    // ── History internals ──
+    maxHistoryMessages: 500,
+    warmHistoryBudgetFraction: 0.40,
+    keystoneHistoryFraction: 0.20,
+    keystoneMaxMessages: 15,
+    keystoneMinSignificance: 0.5,
+    // ── Memory internals ──
+    maxFacts: 30,
+    maxCrossSessionContext: 4000,
+    maxTotalTriggerTokens: 4000,
+    wikiTokenCap: 600,
+    // ── Tool gradient (internal — safe floor enforced automatically) ──
+    maxRecentToolPairs: 3,
+    maxProseToolPairs: 10,
+    // ── Dynamic reserve ──
+    dynamicReserveEnabled: true,
+    dynamicReserveTurnHorizon: 5,
+    dynamicReserveMax: 0.50,
+    // ── HyperForm ──
+    hyperformProfile: 'standard',
+};
+const STANDARD_INDEXER = {
+    enabled: true,
+    factExtractionMode: 'tiered',
+    topicDormantAfter: '24h',
+    topicClosedAfter: '72h',
+    factDecayRate: 0.02,
+    episodeSignificanceThreshold: 0.5,
+    periodicInterval: 60000, // 1min — standard background cadence
+    batchSize: 128,
+    maxMessagesPerTick: 500,
+};
+export const standardProfile = {
+    enabled: true,
+    dataDir: './hypermem-data',
+    cache: BASE_CACHE,
+    compositor: STANDARD_COMPOSITOR,
+    indexer: STANDARD_INDEXER,
+    embedding: BASE_EMBEDDING,
+};
+// ---------------------------------------------------------------------------
+// extended — 200k+ context window, multi-agent, full feature set
+//
+// Design intent:
+//   - Large context models (Opus, GPT-5.4, Gemini Pro) at 200k+
+//   - Council / multi-agent fleet deployments
+//   - Full ACA stack including dreaming, background indexing, cross-session
+//   - hyperformProfile: 'full' — FOS + MOD, full spec
+//   - Higher keystone threshold — more historical context worth surfacing
+// ---------------------------------------------------------------------------
+const EXTENDED_COMPOSITOR = {
+    // ── Primary budget controls ──
+    budgetFraction: 0.588, // 160k effective at 272k window
+    reserveFraction: 0.20, // tighter — large windows have natural headroom
+    historyFraction: 0.45, // ~72k tokens of conversation history
+    memoryFraction: 0.40, // ~64k tokens for facts/wiki/semantic
+    // ── Absolute fallback ──
+    defaultTokenBudget: 160000,
+    // ── History internals ──
+    maxHistoryMessages: 1000,
+    warmHistoryBudgetFraction: 0.45,
+    keystoneHistoryFraction: 0.25,
+    keystoneMaxMessages: 30,
+    keystoneMinSignificance: 0.4,
+    // ── Memory internals ──
+    maxFacts: 60,
+    maxCrossSessionContext: 12000,
+    maxTotalTriggerTokens: 10000,
+    wikiTokenCap: 800,
+    // ── Tool gradient (internal — safe floor enforced automatically) ──
+    maxRecentToolPairs: 5,
+    maxProseToolPairs: 15,
+    // ── Dynamic reserve ──
+    dynamicReserveEnabled: true,
+    dynamicReserveTurnHorizon: 7,
+    dynamicReserveMax: 0.45,
+    // ── HyperForm ──
+    hyperformProfile: 'full',
+};
+const EXTENDED_INDEXER = {
+    enabled: true,
+    factExtractionMode: 'tiered',
+    topicDormantAfter: '48h',
+    topicClosedAfter: '168h', // 7 days — long-running council topics stay warm
+    factDecayRate: 0.01, // slow decay — preserve more institutional memory
+    episodeSignificanceThreshold: 0.4,
+    periodicInterval: 30000, // 30s — frequent background work for fleet throughput
+    batchSize: 256,
+    maxMessagesPerTick: 1000,
+};
+export const fullProfile = {
+    enabled: true,
+    dataDir: './hypermem-data',
+    cache: BASE_CACHE,
+    compositor: EXTENDED_COMPOSITOR,
+    indexer: EXTENDED_INDEXER,
+    embedding: {
+        ...BASE_EMBEDDING,
+        batchSize: 64, // larger batches — more throughput for fleet ingest
+        timeout: 8000, // tighter timeout — expect capable hardware
+    },
+};
+// Legacy aliases — kept for backward compat, removed in 1.0
+export const minimalProfile = lightProfile;
+export const extendedProfile = fullProfile;
+export const richProfile = fullProfile;
+export const PROFILES = {
+    light: lightProfile,
+    standard: standardProfile,
+    full: fullProfile,
+};
+/**
+ * Load a named profile.
+ *
+ * @example
+ * const config = getProfile('light');
+ * const hm = createHyperMem(config);
+ */
+export function getProfile(name) {
+    // backward compat
+    if (name === 'extended')
+        return structuredClone(fullProfile);
+    return structuredClone(PROFILES[name]);
+}
+/**
+ * Merge a partial config on top of a named profile.
+ * Deep-merges compositor and indexer; top-level fields are replaced.
+ *
+ * @example
+ * const config = mergeProfile('light', {
+ *   cache: { keyPrefix: 'myapp:' },
+ *   compositor: { hyperformProfile: 'standard', memoryFraction: 0.50 },  // upgrade tier + more memory
+ * });
+ */
+export function mergeProfile(name, overrides) {
+    const base = getProfile(name);
+    return {
+        ...base,
+        ...overrides,
+        compositor: { ...base.compositor, ...(overrides.compositor ?? {}) },
+        indexer: { ...base.indexer, ...(overrides.indexer ?? {}) },
+        embedding: { ...base.embedding, ...(overrides.embedding ?? {}) },
+        cache: { ...base.cache, ...(overrides.cache ?? {}) },
+    };
+}
+//# sourceMappingURL=profiles.js.map

package/dist/provider-translator.d.ts

@@ -0,0 +1,50 @@
+/**
+ * hypermem Provider Translator
+ *
+ * Converts between provider-neutral (NeutralMessage) and provider-specific formats.
+ * This is the ONLY place where provider-specific formatting exists.
+ * Storage is always neutral. Translation happens at the send/receive boundary.
+ *
+ * This eliminates grafting/stripping entirely — tool calls are stored as structured
+ * data, and each provider gets the format it expects at send time.
+ */
+import type { NeutralMessage, NeutralToolResult, ProviderMessage } from './types.js';
+/**
+ * Final pair-integrity sweep before provider translation.
+ *
+ * Invariant: never emit a tool_result unless its matching tool_use/tool_call
+ * exists in the immediately prior assistant message with the same ID.
+ *
+ * If the pair is broken, degrade the orphan tool_result into plain user text
+ * so providers never see an invalid tool_result block.
+ */
+export declare function repairToolCallPairs(messages: NeutralMessage[]): NeutralMessage[];
+/**
+ * Generate a hypermem-native tool call ID.
+ * These are provider-neutral and deterministic within a session.
+ */
+export declare function generateToolCallId(): string;
+/**
+ * Convert a provider-specific tool call ID to a hypermem ID.
+ * Deterministic: same input always produces same output.
+ */
+export declare function normalizeToolCallId(providerId: string): string;
+export type ProviderType = 'anthropic' | 'openai' | 'openai-responses' | 'unknown';
+export declare function detectProvider(providerString: string | null | undefined): ProviderType;
+/**
+ * Convert neutral messages to provider-specific format.
+ */
+export declare function toProviderFormat(messages: NeutralMessage[], provider: string | null | undefined): ProviderMessage[];
+/**
+ * Convert a provider-specific response to neutral format.
+ */
+export declare function fromProviderFormat(response: Record<string, unknown>, provider: string): NeutralMessage;
+/**
+ * Convert a user message (from chat input) to neutral format.
+ */
+export declare function userMessageToNeutral(content: string, metadata?: Record<string, unknown>): NeutralMessage;
+/**
+ * Convert tool results to a neutral user message.
+ */
+export declare function toolResultsToNeutral(results: NeutralToolResult[]): NeutralMessage;
+//# sourceMappingURL=provider-translator.d.ts.map

package/dist/provider-translator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-translator.d.ts","sourceRoot":"","sources":["../src/provider-translator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,cAAc,EAEd,iBAAiB,EACjB,eAAe,EAChB,MAAM,YAAY,CAAC;AAYpB;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,cAAc,EAAE,CA4ChF;AAOD;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAK3C;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAI9D;AAID,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,QAAQ,GAAG,kBAAkB,GAAG,SAAS,CAAC;AAEnF,wBAAgB,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,YAAY,CAOtF;AAgMD;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EAAE,EAC1B,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAClC,eAAe,EAAE,CAenB;AA8ED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,QAAQ,EAAE,MAAM,GACf,cAAc,CAYhB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,cAAc,CAQxG;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,iBAAiB,EAAE,GAAG,cAAc,CAOjF"}