@remind_ai/remind 0.1.0

package/dist/src/brain/selftest.js

@@ -0,0 +1,229 @@
+// REMind · L1 offline selftest · Owner: Charan
+// Deterministic checks for the Brain — pure helpers + the full sleep cycle via fake LLM/Stores.
+// Run: `npx tsx src/brain/selftest.ts`
+import { cosine, cluster } from './similarity.js';
+import { currentlyValid, activeAt } from './temporal.js';
+import { tierFor } from './tiering.js';
+import { consolidate } from './consolidation.js';
+import { DAY_MS, MERGE_THRESHOLD, HOT_DAYS, WARM_DAYS } from './constants.js';
+let failures = 0;
+function check(name, cond) {
+    console.log(`${cond ? 'PASS' : 'FAIL'} — ${name}`);
+    if (!cond)
+        failures++;
+}
+function rec(id, over = {}) {
+    return {
+        id,
+        agentId: 'a1',
+        type: 'episodic',
+        content: id,
+        trust: 1,
+        confidence: 0.7,
+        provenance: { source: 'test' },
+        tier: 'hot',
+        createdAt: new Date().toISOString(),
+        ...over,
+    };
+}
+// ---------- pure: cosine ----------
+check('cosine identical = 1', Math.abs(cosine([1, 0, 0], [1, 0, 0]) - 1) < 1e-9);
+check('cosine orthogonal = 0', Math.abs(cosine([1, 0], [0, 1])) < 1e-9);
+check('cosine empty = 0', cosine([], [1]) === 0);
+// ---------- pure: clustering ----------
+const recs = [rec('p1'), rec('p2'), rec('q1'), rec('q2'), rec('z')];
+const vecs = new Map([
+    ['p1', [1, 0, 0]],
+    ['p2', [0.99, 0.02, 0]],
+    ['q1', [0, 1, 0]],
+    ['q2', [0.02, 0.99, 0]],
+    ['z', [0, 0, 1]],
+]);
+const groups = cluster(recs, vecs, MERGE_THRESHOLD);
+check('two pairs + outlier ⇒ 3 clusters', groups.length === 3);
+check('a tight pair is grouped', groups.some((g) => g.length === 2));
+// ---------- pure: bi-temporal validity ----------
+const tNow = Date.now();
+const open = rec('open', { validFrom: new Date(tNow - DAY_MS).toISOString() });
+const closed = rec('closed', {
+    validFrom: new Date(tNow - 5 * DAY_MS).toISOString(),
+    validTo: new Date(tNow - DAY_MS).toISOString(),
+});
+const valid = currentlyValid([open, closed]);
+check('currentlyValid keeps the open belief only', valid.length === 1 && valid[0].id === 'open');
+check('activeAt inside closed window', activeAt([closed], new Date(tNow - 3 * DAY_MS).toISOString()).length === 1);
+check('activeAt excludes after validTo', activeAt([closed], new Date(tNow).toISOString()).length === 0);
+// ---------- pure: tiering boundaries (relative to the active constants) ----------
+const ago = (days) => new Date(tNow - days * DAY_MS).toISOString();
+const warmAge = (HOT_DAYS + WARM_DAYS) / 2;
+const coldAge = WARM_DAYS * 2 + 1;
+check('fresh ⇒ hot', tierFor(rec('h', { lastUsedAt: ago(0) }), tNow) === 'hot');
+check('mid ⇒ warm', tierFor(rec('w', { lastUsedAt: ago(warmAge) }), tNow) === 'warm');
+check('beyond warm ⇒ cold', tierFor(rec('c', { lastUsedAt: ago(coldAge) }), tNow) === 'cold');
+// ---------- fakes for the sleep cycle ----------
+function fakeStores() {
+    const records = new Map();
+    const facts = new Map();
+    const upserts = new Set();
+    const triplesWritten = [];
+    const doc = {
+        async pushFact(agentId, fact) {
+            if (!facts.has(agentId))
+                facts.set(agentId, new Set());
+            facts.get(agentId).add(fact);
+        },
+        async getFacts(agentId) {
+            return [...(facts.get(agentId) ?? [])];
+        },
+        async saveRecord(r) {
+            records.set(r.id, { ...r });
+        },
+        async getRecords(agentId, filter = {}) {
+            return [...records.values()].filter((r) => r.agentId === agentId && Object.entries(filter).every(([k, v]) => r[k] === v));
+        },
+    };
+    const vector = {
+        async upsert(r) {
+            upserts.add(r.id);
+        },
+        async search() {
+            return [];
+        },
+    };
+    const graph = {
+        async writeTriples(_a, t) {
+            triplesWritten.push(...t);
+        },
+        async fetchGraph() {
+            return '';
+        },
+    };
+    return { stores: { vector, graph, doc }, records, facts, upserts, triplesWritten };
+}
+function hashVec(s) {
+    let h = 0;
+    const v = [0, 0, 0];
+    for (let i = 0; i < s.length; i++) {
+        h = (h * 31 + s.charCodeAt(i)) >>> 0;
+        v[i % 3] += (h % 97) / 97;
+    }
+    return v.some((x) => x !== 0) ? v : [1, 0, 0];
+}
+function fakeLlm(opts) {
+    return {
+        async complete(prompt) {
+            if (/Distill/.test(prompt)) {
+                if (opts.throwOnDistill)
+                    throw new Error('boom');
+                return JSON.stringify({ belief: opts.belief ?? 'A belief', triples: opts.triples ?? [] });
+            }
+            if (/higher-order insights/.test(prompt))
+                return '[]';
+            return '';
+        },
+        async classify(prompt) {
+            if (/contradict or replace/.test(prompt))
+                return opts.contradict ?? 'no';
+            return 'no'; // surprise probe
+        },
+        async embed(text) {
+            return opts.embedTable?.[text] ?? hashVec(text);
+        },
+    };
+}
+const allow = async () => ({ promote: true });
+const deny = async () => ({ promote: false, reason: 'poison' });
+async function main() {
+    // Scenario 1 — merge + promote + persist (facts, vector, triples) + episodic demotion.
+    {
+        const fx = fakeStores();
+        const llm = fakeLlm({
+            belief: 'User likes pizza',
+            triples: [{ subject: 'User', relation: 'likes', object: 'pizza' }],
+            embedTable: { pa: [1, 0, 0], pb: [0.87, 0.493, 0], 'User likes pizza': [1, 0, 0] },
+        });
+        await fx.stores.doc.saveRecord(rec('pa', { content: 'pa' }));
+        await fx.stores.doc.saveRecord(rec('pb', { content: 'pb' }));
+        const report = await consolidate('a1', fx.stores, allow, llm);
+        const factual = await fx.stores.doc.getRecords('a1', { type: 'factual' });
+        check('merge: two near-dups fold into one cluster', report.merged === 1);
+        check('merge: exactly one belief promoted', report.promoted.length === 1);
+        check('merge: belief persisted to doc store', factual.length === 1 && factual[0].content === 'User likes pizza');
+        check('merge: fact written', (await fx.stores.doc.getFacts('a1')).includes('User likes pizza'));
+        check('merge: belief vector upserted', fx.upserts.has(factual[0].id));
+        check('merge: triples written to graph', fx.triplesWritten.length >= 1);
+        const episodics = await fx.stores.doc.getRecords('a1', { type: 'episodic' });
+        check('merge: consumed episodics demoted to warm', episodics.every((e) => e.tier === 'warm'));
+        // idempotency — re-seed hot + re-run ⇒ same belief id, no duplicate.
+        await fx.stores.doc.saveRecord(rec('pa', { content: 'pa', tier: 'hot' }));
+        await fx.stores.doc.saveRecord(rec('pb', { content: 'pb', tier: 'hot' }));
+        await consolidate('a1', fx.stores, allow, llm);
+        const factual2 = await fx.stores.doc.getRecords('a1', { type: 'factual' });
+        check('idempotent: re-run does not duplicate the belief', factual2.length === 1);
+    }
+    // Scenario 2 — gate denies ⇒ nothing persisted, recorded as blocked.
+    {
+        const fx = fakeStores();
+        const llm = fakeLlm({ belief: 'User likes pizza', embedTable: { pa: [1, 0, 0], pb: [0.87, 0.493, 0] } });
+        await fx.stores.doc.saveRecord(rec('pa', { content: 'pa' }));
+        await fx.stores.doc.saveRecord(rec('pb', { content: 'pb' }));
+        const report = await consolidate('a1', fx.stores, deny, llm);
+        const factual = await fx.stores.doc.getRecords('a1', { type: 'factual' });
+        check('deny: nothing promoted', report.promoted.length === 0);
+        check('deny: candidate recorded as blocked', report.blocked.length >= 1);
+        check('deny: no belief persisted', factual.length === 0);
+    }
+    // Scenario 3 — a contradicting belief supersedes the old one (validTo closed).
+    {
+        const fx = fakeStores();
+        const llm = fakeLlm({
+            belief: 'User lives in Bangalore',
+            triples: [{ subject: 'User', relation: 'livesIn', object: 'Bangalore' }],
+            contradict: 'yes',
+            embedTable: {
+                m1: [0.9, 0.1, 0],
+                m2: [0.92, 0.08, 0],
+                'User lives in Bangalore': [0.9, 0.1, 0],
+                'User lives in Delhi': [1, 0, 0],
+            },
+        });
+        await fx.stores.doc.saveRecord({
+            ...rec('delhi', { content: 'User lives in Delhi', type: 'factual', validFrom: ago(30) }),
+            triples: [{ subject: 'User', relation: 'livesIn', object: 'Delhi' }],
+        });
+        await fx.stores.doc.saveRecord(rec('m1', { content: 'm1' }));
+        await fx.stores.doc.saveRecord(rec('m2', { content: 'm2' }));
+        const report = await consolidate('a1', fx.stores, allow, llm);
+        const delhi = (await fx.stores.doc.getRecords('a1', { type: 'factual' })).find((r) => r.id === 'delhi');
+        check('supersede: new belief promoted', report.promoted.some((p) => p.content === 'User lives in Bangalore'));
+        check('supersede: old belief got a validTo', !!delhi?.validTo);
+        check('supersede: old belief no longer currently-valid', currentlyValid([delhi]).length === 0);
+    }
+    // Scenario 4 — a failing LLM call is isolated; the cycle still resolves.
+    {
+        const fx = fakeStores();
+        const llm = fakeLlm({ throwOnDistill: true });
+        await fx.stores.doc.saveRecord(rec('x1', { content: 'x1' }));
+        await fx.stores.doc.saveRecord(rec('x2', { content: 'x2' }));
+        let threw = false;
+        let report;
+        try {
+            report = await consolidate('a1', fx.stores, allow, llm);
+        }
+        catch {
+            threw = true;
+        }
+        check('robust: a distill failure does not crash the cycle', !threw);
+        check('robust: nothing promoted on failure', report?.promoted.length === 0);
+        check('robust: failure recorded as blocked', (report?.blocked.length ?? 0) >= 1);
+    }
+}
+main()
+    .then(() => {
+    console.log(failures ? `\n${failures} check(s) FAILED` : '\nAll checks passed');
+    process.exit(failures ? 1 : 0);
+})
+    .catch((err) => {
+    console.error('selftest crashed:', err);
+    process.exit(1);
+});

package/dist/src/brain/similarity.d.ts

@@ -0,0 +1,10 @@
+import type { MemoryRecord } from '../types.js';
+export type Vec = number[];
+/**
+ * Embed every record once into `cache` (reusing a record's own embedding when present).
+ * Pass the same `cache` across calls in a sleep cycle to avoid paying for an embedding twice.
+ */
+export declare function embedAll(records: MemoryRecord[], cache?: Map<string, Vec>, embedFn?: (text: string) => Promise<Vec>): Promise<Map<string, Vec>>;
+export declare function cosine(a: Vec, b: Vec): number;
+/** Greedy single-pass clustering; deterministic in input order. */
+export declare function cluster(records: MemoryRecord[], vecs: Map<string, Vec>, threshold: number): MemoryRecord[][];

package/dist/src/brain/similarity.js

@@ -0,0 +1,65 @@
+// REMind · L1 embedding/similarity utils · Owner: Charan
+// Shared cosine + greedy clustering used by encoding, consolidation and forgetting.
+import { embed as defaultEmbed } from '../llm.js';
+const keyOf = (r) => r.id || r.content;
+/**
+ * Embed every record once into `cache` (reusing a record's own embedding when present).
+ * Pass the same `cache` across calls in a sleep cycle to avoid paying for an embedding twice.
+ */
+export async function embedAll(records, cache = new Map(), embedFn = defaultEmbed) {
+    for (const r of records) {
+        const key = keyOf(r);
+        if (cache.has(key))
+            continue;
+        cache.set(key, r.embedding ?? (await embedFn(r.content)));
+    }
+    return cache;
+}
+export function cosine(a, b) {
+    if (!a?.length || !b?.length || a.length !== b.length)
+        return 0;
+    let dot = 0;
+    let na = 0;
+    let nb = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        na += a[i] * a[i];
+        nb += b[i] * b[i];
+    }
+    if (na === 0 || nb === 0)
+        return 0;
+    return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+/** Greedy single-pass clustering; deterministic in input order. */
+export function cluster(records, vecs, threshold) {
+    const clusters = [];
+    for (const r of records) {
+        const v = vecs.get(keyOf(r));
+        if (!v) {
+            clusters.push({ centroid: [], items: [r] });
+            continue;
+        }
+        let best = null;
+        for (const c of clusters) {
+            const sim = cosine(v, c.centroid);
+            if (sim >= threshold && (!best || sim > best.sim))
+                best = { c, sim };
+        }
+        if (best) {
+            best.c.items.push(r);
+            best.c.centroid = recenter(best.c.centroid, v, best.c.items.length);
+        }
+        else {
+            clusters.push({ centroid: v.slice(), items: [r] });
+        }
+    }
+    return clusters.map((c) => c.items);
+}
+function recenter(centroid, v, n) {
+    if (!centroid.length)
+        return v.slice();
+    const out = centroid.slice();
+    for (let i = 0; i < out.length; i++)
+        out[i] += (v[i] - out[i]) / n;
+    return out;
+}

package/dist/src/brain/temporal.d.ts

@@ -0,0 +1,9 @@
+import type { MemoryRecord, Stores } from '../types.js';
+import { type Vec } from './similarity.js';
+import { type LlmDeps } from './llm-deps.js';
+/** Records whose valid-time window is still open. */
+export declare function currentlyValid(records: MemoryRecord[]): MemoryRecord[];
+/** Records whose valid-time window contains the instant `at` (ISO). */
+export declare function activeAt(records: MemoryRecord[], at: string): MemoryRecord[];
+/** Close the valid-time of active beliefs that `newRecord` contradicts. Returns the retired records. */
+export declare function supersede(newRecord: MemoryRecord, existing: MemoryRecord[], stores: Stores, llm?: LlmDeps, cache?: Map<string, Vec>): Promise<MemoryRecord[]>;

package/dist/src/brain/temporal.js

@@ -0,0 +1,65 @@
+// REMind · L1 temporal · Owner: Charan
+// supersede(newRecord, existing, stores): set validTo on contradicted beliefs, validFrom on new ones; time-bounded query helpers (bi-temporal validity).
+import { embedAll, cosine } from './similarity.js';
+import { defaultLlm } from './llm-deps.js';
+import { SUPERSEDE_SIM_THRESHOLD } from './constants.js';
+const nowIso = () => new Date().toISOString();
+const keyOf = (r) => r.id || r.content;
+/** Records whose valid-time window is still open. */
+export function currentlyValid(records) {
+    const t = Date.now();
+    return records.filter((r) => !r.validTo || Date.parse(r.validTo) > t);
+}
+/** Records whose valid-time window contains the instant `at` (ISO). */
+export function activeAt(records, at) {
+    const t = Date.parse(at);
+    return records.filter((r) => {
+        const from = r.validFrom ? Date.parse(r.validFrom) : 0;
+        const to = r.validTo ? Date.parse(r.validTo) : Infinity;
+        return from <= t && t < to;
+    });
+}
+/** Close the valid-time of active beliefs that `newRecord` contradicts. Returns the retired records. */
+export async function supersede(newRecord, existing, stores, llm = defaultLlm, cache = new Map()) {
+    if (!newRecord.validFrom)
+        newRecord.validFrom = nowIso();
+    const candidates = currentlyValid(existing).filter((r) => r.id !== newRecord.id);
+    if (!candidates.length)
+        return [];
+    // Embedding prefilter: only spend an LLM call on beliefs that are topically related,
+    // so this stays O(related) instead of O(every belief).
+    await embedAll([newRecord, ...candidates], cache, llm.embed);
+    const nv = cache.get(keyOf(newRecord));
+    const retired = [];
+    for (const old of candidates) {
+        const ov = cache.get(keyOf(old));
+        const sim = nv && ov ? cosine(nv, ov) : 1; // missing vectors ⇒ fail safe and check
+        if (!sharesSubject(newRecord, old) && sim < SUPERSEDE_SIM_THRESHOLD)
+            continue;
+        const ans = await llm.classify(`OLD belief: "${old.content}"\nNEW belief: "${newRecord.content}"\n` +
+            `Does NEW contradict or replace OLD about the same subject? Answer 'yes' or 'no'.`);
+        if (ans.startsWith('yes')) {
+            const closed = { ...old, validTo: newRecord.validFrom };
+            await stores.doc.saveRecord(closed);
+            retired.push(closed);
+        }
+    }
+    return retired;
+}
+function sharesSubject(a, b) {
+    const sa = subjects(a);
+    const sb = subjects(b);
+    if (!sa.size || !sb.size)
+        return false; // no triples ⇒ rely on the embedding prefilter
+    for (const s of sa)
+        if (sb.has(s))
+            return true;
+    return false;
+}
+function subjects(r) {
+    const out = new Set();
+    for (const t of r.triples ?? [])
+        if (t.subject)
+            out.add(t.subject.toLowerCase());
+    return out;
+}

package/dist/src/brain/tiering.d.ts

@@ -0,0 +1,9 @@
+import type { MemoryRecord, Stores, Tier } from '../types.js';
+/** Tier a record should occupy given how recently it was used. */
+export declare function tierFor(record: MemoryRecord, nowMs?: number): Tier;
+/**
+ * Re-place records by access recency. Demotions (hot→warm→cold) always apply.
+ * A cold record only climbs back out on a strong recent-access signal (used within HOT_DAYS),
+ * so forgetting's archival decisions are not silently undone. Returns #changed.
+ */
+export declare function retier(agentId: string, stores: Stores): Promise<number>;

package/dist/src/brain/tiering.js

@@ -0,0 +1,39 @@
+// REMind · L1 tiering · Owner: Charan
+// retier(agentId, stores): move records hot -> warm -> cold based on access patterns.
+import { DAY_MS, HOT_DAYS, WARM_DAYS } from './constants.js';
+/** Tier a record should occupy given how recently it was used. */
+export function tierFor(record, nowMs = Date.now()) {
+    const last = Date.parse(record.lastUsedAt ?? record.createdAt);
+    const ageDays = (nowMs - (Number.isNaN(last) ? nowMs : last)) / DAY_MS;
+    if (ageDays <= HOT_DAYS)
+        return 'hot';
+    if (ageDays <= WARM_DAYS)
+        return 'warm';
+    return 'cold';
+}
+/**
+ * Re-place records by access recency. Demotions (hot→warm→cold) always apply.
+ * A cold record only climbs back out on a strong recent-access signal (used within HOT_DAYS),
+ * so forgetting's archival decisions are not silently undone. Returns #changed.
+ */
+export async function retier(agentId, stores) {
+    const records = await stores.doc.getRecords(agentId);
+    const nowMs = Date.now();
+    let changed = 0;
+    for (const r of records) {
+        const next = tierFor(r, nowMs);
+        if (next === r.tier)
+            continue;
+        if (r.tier === 'cold' && !recentlyUsed(r, nowMs))
+            continue;
+        await stores.doc.saveRecord({ ...r, tier: next });
+        changed++;
+    }
+    return changed;
+}
+function recentlyUsed(record, nowMs) {
+    if (!record.lastUsedAt)
+        return false;
+    const last = Date.parse(record.lastUsedAt);
+    return !Number.isNaN(last) && nowMs - last <= HOT_DAYS * DAY_MS;
+}

package/dist/src/config.d.ts

@@ -0,0 +1,36 @@
+import 'dotenv/config';
+export declare const config: {
+    azureOpenAI: {
+        endpoint: string;
+        apiKey: string;
+        apiVersion: string;
+        chatDeployment: string;
+        embedDeployment: string;
+        embedDimensions: number;
+    };
+    search: {
+        endpoint: string;
+        apiKey: string;
+        index: string;
+    };
+    gremlin: {
+        endpoint: string;
+        key: string;
+        database: string;
+        graph: string;
+    };
+    mongo: {
+        uri: string;
+        db: string;
+    };
+    redis: {
+        url: string;
+    };
+    sync: boolean;
+};
+export type Config = typeof config;
+/**
+ * Fail fast with a clear, actionable message when a credential needed to actually run is
+ * missing — call this at process entry points (demo, server) before touching Azure.
+ */
+export declare function requireConfig(): void;

package/dist/src/config.js

@@ -0,0 +1,61 @@
+// REMind · Config · Owner: Yasho
+// Loads .env and exposes the Azure / Microsoft service settings every layer reads.
+import 'dotenv/config';
+function opt(name, fallback = '') {
+    return process.env[name] ?? fallback;
+}
+export const config = {
+    azureOpenAI: {
+        endpoint: opt('AZURE_OPENAI_ENDPOINT'),
+        apiKey: opt('AZURE_OPENAI_API_KEY'),
+        apiVersion: opt('AZURE_OPENAI_API_VERSION', '2024-10-21'),
+        chatDeployment: opt('AZURE_OPENAI_CHAT_DEPLOYMENT', 'gpt-4o-mini'),
+        embedDeployment: opt('AZURE_OPENAI_EMBED_DEPLOYMENT', 'text-embedding-3-large'),
+        embedDimensions: Number(opt('AZURE_OPENAI_EMBED_DIMENSIONS', '3072')),
+    },
+    // Azure AI Search — vector store (replaces Qdrant)
+    search: {
+        endpoint: opt('AZURE_SEARCH_ENDPOINT'),
+        apiKey: opt('AZURE_SEARCH_API_KEY'),
+        index: opt('AZURE_SEARCH_INDEX', 'remind-memory'),
+    },
+    // Azure Cosmos DB for Apache Gremlin — knowledge graph (replaces Neo4j)
+    gremlin: {
+        endpoint: opt('COSMOS_GREMLIN_ENDPOINT'),
+        key: opt('COSMOS_GREMLIN_KEY'),
+        database: opt('COSMOS_GREMLIN_DB', 'remind'),
+        graph: opt('COSMOS_GREMLIN_GRAPH', 'memory'),
+    },
+    // Azure Cosmos DB for MongoDB — facts/records (Mongoose drop-in)
+    mongo: {
+        uri: opt('COSMOS_MONGO_URI'),
+        db: opt('COSMOS_MONGO_DB', 'remind'),
+    },
+    // Azure Cache for Redis — queues (Layer 0 does not use this yet)
+    redis: { url: opt('REDIS_URL') },
+    sync: opt('SYNC', '1') === '1',
+};
+/**
+ * Fail fast with a clear, actionable message when a credential needed to actually run is
+ * missing — call this at process entry points (demo, server) before touching Azure.
+ */
+export function requireConfig() {
+    const missing = [];
+    const need = (value, name) => {
+        if (!value)
+            missing.push(name);
+    };
+    need(config.azureOpenAI.endpoint, 'AZURE_OPENAI_ENDPOINT');
+    need(config.azureOpenAI.apiKey, 'AZURE_OPENAI_API_KEY');
+    need(config.search.endpoint, 'AZURE_SEARCH_ENDPOINT');
+    need(config.search.apiKey, 'AZURE_SEARCH_API_KEY');
+    need(config.gremlin.endpoint, 'COSMOS_GREMLIN_ENDPOINT');
+    need(config.gremlin.key, 'COSMOS_GREMLIN_KEY');
+    need(config.mongo.uri, 'COSMOS_MONGO_URI');
+    if (!config.sync)
+        need(config.redis.url, 'REDIS_URL');
+    if (missing.length > 0) {
+        throw new Error(`REMind is missing required environment variables:\n  - ${missing.join('\n  - ')}\n` +
+            `Copy .env.example to .env and fill these in.`);
+    }
+}

package/dist/src/core/index.d.ts

@@ -0,0 +1,12 @@
+import type { IngestInput, MemoryEngineCore, MemoryRecord, RetrievalResult, Stores } from '../types.js';
+import { vectorStore } from './stores/vector.store.js';
+import { graphStore } from './stores/graph.store.js';
+import { docStore } from './stores/doc.store.js';
+export declare const stores: Stores;
+export declare class CoreMemory implements MemoryEngineCore {
+    draft(input: IngestInput): Promise<MemoryRecord | null>;
+    /** Idempotent: vector/graph/doc writes key on deterministic ids. */
+    persist(record: MemoryRecord): Promise<MemoryRecord>;
+    fetchMemory(agentId: string, query: string, sourceId?: string): Promise<RetrievalResult>;
+}
+export { vectorStore, graphStore, docStore };

package/dist/src/core/index.js

@@ -0,0 +1,31 @@
+// REMind · L0 Foundation export · Owner: Bibhas
+// CoreMemory implements MemoryEngineCore over the three Azure stores. The single public seam of core/.
+import { draft as draftFn } from './ingest.js';
+import { fetchMemory as fetchFn } from './retrieval.js';
+import { vectorStore } from './stores/vector.store.js';
+import { graphStore } from './stores/graph.store.js';
+import { docStore } from './stores/doc.store.js';
+export const stores = { vector: vectorStore, graph: graphStore, doc: docStore };
+export class CoreMemory {
+    async draft(input) {
+        return draftFn(input);
+    }
+    /** Idempotent: vector/graph/doc writes key on deterministic ids. */
+    async persist(record) {
+        if (record.type === 'factual') {
+            await stores.doc.pushFact(record.agentId, record.content);
+        }
+        else {
+            await stores.vector.upsert(record);
+            if (record.triples?.length) {
+                await stores.graph.writeTriples(record.agentId, record.triples);
+            }
+        }
+        await stores.doc.saveRecord(record);
+        return record;
+    }
+    async fetchMemory(agentId, query, sourceId) {
+        return fetchFn(stores, agentId, query, sourceId);
+    }
+}
+export { vectorStore, graphStore, docStore };

package/dist/src/core/ingest.d.ts

@@ -0,0 +1,2 @@
+import type { IngestInput, MemoryRecord } from '../types.js';
+export declare function draft(input: IngestInput): Promise<MemoryRecord | null>;