praana 0.5.0

package/dist/memory/openai-summarizer.js

@@ -0,0 +1,51 @@
+// ============================================================
+// ARIA Memory — OpenAI/OpenRouter Summarizer Adapter
+// ============================================================
+export class OpenAISummarizer {
+    name;
+    baseUrl;
+    apiKey;
+    model;
+    constructor(opts) {
+        this.baseUrl = opts.baseUrl.replace(/\/$/, "");
+        this.apiKey = opts.apiKey;
+        this.model = opts.model;
+        this.name = `openai:${opts.model}`;
+    }
+    async available() {
+        return this.apiKey.length > 0;
+    }
+    async complete(opts) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), opts.timeoutMs ?? 60_000);
+        try {
+            const messages = [];
+            if (opts.system)
+                messages.push({ role: "system", content: opts.system });
+            messages.push({ role: "user", content: opts.prompt });
+            const body = { model: this.model, messages };
+            if (opts.temperature !== undefined)
+                body.temperature = opts.temperature;
+            if (opts.maxTokens !== undefined)
+                body.max_tokens = opts.maxTokens;
+            if (opts.json)
+                body.response_format = { type: "json_object" };
+            const res = await fetch(`${this.baseUrl}/chat/completions`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (!res.ok)
+                throw new Error(`Summarizer ${res.status}: ${await res.text()}`);
+            const json = (await res.json());
+            return json.choices[0]?.message?.content ?? "";
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}

package/dist/memory/store.d.ts

@@ -0,0 +1,61 @@
+import type { Embedder } from "./types.js";
+import type { Digest, MemoryEntry, RecallOptions, RecallResult, RememberOptions, SessionContext, SessionEvent, SummarizerLLM } from "./types.js";
+export declare class MemoryStore {
+    private db;
+    private embedder;
+    private summarizer;
+    private defaultScopes;
+    private sessionId;
+    /** True while a background re-embed migration is running. */
+    private reembedding;
+    private reembedPromise;
+    constructor(opts: {
+        dbPath: string;
+        embedder: Embedder;
+        summarizer?: SummarizerLLM | null;
+        /**
+         * Override the auto-detected needsReembed flag from openMemoryDb.
+         * Intended for tests that use :memory: DBs with explicit control.
+         */
+        needsReembed?: boolean;
+    });
+    close(): void;
+    /** Get the summarizer LLM (may be null if summarizer is disabled). */
+    getSummarizer(): SummarizerLLM | null;
+    getEntryCount(): number;
+    sessionStart(ctx: SessionContext): Promise<Digest>;
+    sessionEnd(reason: string, events?: SessionEvent[]): Promise<void>;
+    /**
+     * Compress a batch of old turns into episodic facts.
+     * Returns the number of facts stored.
+     */
+    compressTurns(events: SessionEvent[]): Promise<number>;
+    remember(content: string, opts?: RememberOptions): Promise<{
+        id: string;
+    }>;
+    private storeLearning;
+    recall(query: string, opts?: RecallOptions): Promise<RecallResult>;
+    pin(id: string): Promise<void>;
+    unpin(id: string): Promise<void>;
+    reinforceFromSuccessfulToolOutcome(entryIds: string[], alpha?: number): void;
+    getAllEntries(): MemoryEntry[];
+    /** Promote an entry from Layer 1 to Layer 2 (deep memory). */
+    promoteToLayer2(id: string): void;
+    /** Weaken an entry's confidence by a beta factor (0–1). */
+    weakenEntry(id: string, beta?: number): void;
+    /**
+     * Remove stale Layer 1 entries with effective confidence below 0.05
+     * that have not been seen in 30+ days. Never prunes pinned or Layer 2 entries.
+     */
+    prune(): Promise<number>;
+    /** Re-embed all entries after vector dimension migration. Runs in the background. */
+    reembedAllEntries(): Promise<void>;
+    private waitForReembed;
+    private buildDefaultScopes;
+    private buildDigest;
+    private buildScopeQueries;
+    private getEntriesForScopeQueries;
+    private entryMatchesScopeQuery;
+    retractMemory(id: string): void;
+    hasEntry(id: string): boolean;
+}

package/dist/memory/store.js

@@ -0,0 +1,502 @@
+// ============================================================
+// ARIA Memory — Store
+//
+// Unified API: remember, recall, digest, pin, session lifecycle.
+// ============================================================
+import { ulid } from "ulid";
+import { clearReembedNeeded, endSessionRow, flushReinforcements, getAllEntries, getEntriesByScope, getEntryById, insertEntry, deleteEntry, retractMemory as retractMemoryDb, openMemoryDb, reinforceEntry, searchByFts, searchByVector, stampReinforcement, startSessionRow, touchEntry, upsertEmbedding, weakenEntry, } from "./db.js";
+import { extractLearnings, summarizeTurns } from "./summarizer.js";
+import { CONTRADICTION_MATCH_THRESHOLD, isContradiction, isNearDuplicate, } from "./dedup.js";
+import { isMemoryKind, MEMORY_KINDS } from "./types.js";
+import { effectiveConfidence, digestScore } from "./confidence.js";
+import { getAppLogger } from "../logger.js";
+import { APP_AGENT_ID, LEGACY_APP_AGENT_ID } from "../app-identity.js";
+function certaintyToConfidence(c) {
+    return c === "high" ? 0.8 : c === "medium" ? 0.5 : 0.3;
+}
+function queryTerms(query) {
+    return query.toLowerCase().match(/[a-z0-9_]+/g) ?? [];
+}
+function isAbortLikeError(err) {
+    if (!(err instanceof Error))
+        return false;
+    if (err.name === "AbortError")
+        return true;
+    return /\babort(ed)?\b/i.test(err.message);
+}
+function lexicalMatchScore(entry, terms, rankScore) {
+    if (terms.length === 0)
+        return 0;
+    const content = entry.content.toLowerCase();
+    const matched = terms.filter((term) => content.includes(term)).length;
+    const coverage = matched / terms.length;
+    return 0.6 + coverage * 0.3 + rankScore * 0.1;
+}
+export class MemoryStore {
+    db;
+    embedder;
+    summarizer;
+    defaultScopes = [];
+    sessionId = "";
+    /** True while a background re-embed migration is running. */
+    reembedding = false;
+    reembedPromise = null;
+    constructor(opts) {
+        const opened = openMemoryDb(opts.dbPath, opts.embedder.dim);
+        this.db = opened.db;
+        this.embedder = opts.embedder;
+        this.summarizer = opts.summarizer ?? null;
+        if (opts.needsReembed ?? opened.needsReembed) {
+            this.reembedPromise = this.reembedAllEntries();
+        }
+    }
+    close() {
+        this.db.close();
+    }
+    /** Get the summarizer LLM (may be null if summarizer is disabled). */
+    getSummarizer() {
+        return this.summarizer;
+    }
+    getEntryCount() {
+        return getAllEntries(this.db).length;
+    }
+    // ---- Session lifecycle ----
+    async sessionStart(ctx) {
+        await this.waitForReembed();
+        this.sessionId = ulid();
+        this.defaultScopes = this.buildDefaultScopes(ctx);
+        const pruned = await this.prune();
+        if (pruned > 0) {
+            getAppLogger().child("memory").info(`Pruned ${pruned} stale Layer 1 ${pruned === 1 ? "entry" : "entries"}`);
+        }
+        startSessionRow(this.db, {
+            id: this.sessionId,
+            agent: ctx.agent,
+            user_id: ctx.user_id,
+            context_id: ctx.context_id,
+            started_at: ctx.time,
+        });
+        return this.buildDigest(ctx, ctx.recall_min_score);
+    }
+    async sessionEnd(reason, events) {
+        flushReinforcements(this.db, this.sessionId);
+        const now = Date.now();
+        endSessionRow(this.db, this.sessionId, now, reason);
+        if (events && events.length > 0 && this.summarizer) {
+            try {
+                const learnings = await extractLearnings(this.summarizer, events);
+                for (const l of learnings) {
+                    await this.storeLearning(l);
+                }
+            }
+            catch (err) {
+                if (isAbortLikeError(err)) {
+                    getAppLogger().child("memory").warn("Session-end summarizer aborted; skipping learnings for this session");
+                    return;
+                }
+                throw err;
+            }
+        }
+    }
+    /**
+     * Compress a batch of old turns into episodic facts.
+     * Returns the number of facts stored.
+     */
+    async compressTurns(events) {
+        if (!this.summarizer)
+            return 0;
+        try {
+            const facts = await summarizeTurns(this.summarizer, events);
+            for (const fact of facts) {
+                await this.remember(fact.content, {
+                    kind: fact.kind,
+                    certainty: fact.certainty,
+                    pinned: false,
+                });
+            }
+            return facts.length;
+        }
+        catch (err) {
+            if (isAbortLikeError(err)) {
+                getAppLogger().child("memory").warn("Turn compression aborted; skipping");
+                return 0;
+            }
+            throw err;
+        }
+    }
+    // ---- Core operations ----
+    async remember(content, opts = {}) {
+        const id = ulid();
+        const now = Date.now();
+        const kind = opts.kind ?? "fact";
+        if (!isMemoryKind(kind)) {
+            throw new Error(`Invalid memory kind: '${kind}'. Valid kinds: ${MEMORY_KINDS.join(", ")}`);
+        }
+        const confidence = certaintyToConfidence(opts.certainty ?? "medium");
+        const scopes = opts.scope ?? this.defaultScopes;
+        const entry = {
+            id,
+            kind,
+            content: content.slice(0, 1000),
+            confidence,
+            pinned: opts.pinned ?? false,
+            layer: 1,
+            confirmation_count: 0,
+            created_at: now,
+            last_seen_at: now,
+            session_id: this.sessionId,
+            scopes,
+            retracted: false,
+        };
+        insertEntry(this.db, entry);
+        // Embedding (fire-and-forget)
+        this.embedder.embed(content).then((vec) => {
+            upsertEmbedding(this.db, id, vec);
+        }).catch(() => { });
+        return { id };
+    }
+    async storeLearning(learning) {
+        const similar = await this.recall(learning.content, {
+            limit: 3,
+            kinds: [learning.kind],
+        });
+        const duplicate = similar.entries.find((e) => {
+            const existing = getEntryById(this.db, e.id);
+            if (!existing)
+                return false;
+            return isNearDuplicate(existing.content, learning.content, Math.max(e.match, e.score));
+        });
+        if (duplicate) {
+            reinforceEntry(this.db, duplicate.id, 0.08);
+            this.db
+                .prepare("UPDATE entries SET confirmation_count = confirmation_count + 1 WHERE id = ?")
+                .run(duplicate.id);
+            return;
+        }
+        for (const candidate of similar.entries) {
+            if (candidate.match < CONTRADICTION_MATCH_THRESHOLD && candidate.score < CONTRADICTION_MATCH_THRESHOLD) {
+                continue;
+            }
+            const existing = getEntryById(this.db, candidate.id);
+            if (!existing)
+                continue;
+            if (await isContradiction(existing.content, learning.content, this.summarizer)) {
+                weakenEntry(this.db, candidate.id, 0.15);
+            }
+        }
+        await this.remember(learning.content, {
+            kind: learning.kind,
+            certainty: learning.certainty,
+            scope: learning.scope_hints ?? this.defaultScopes,
+        });
+    }
+    async recall(query, opts = {}) {
+        const limit = opts.limit ?? 10;
+        const queryScopes = opts.scope ?? this.defaultScopes;
+        const scopeQueries = this.buildScopeQueries(queryScopes);
+        const now = Date.now();
+        if (this.reembedding) {
+            getAppLogger().child("memory").warn("Vector migration in progress — recall quality may be reduced until re-embed completes");
+        }
+        // Strategy: merge reliable keyword hits with vector candidates, then filter + re-rank.
+        const candidateScores = new Map();
+        const terms = queryTerms(query);
+        const addCandidate = (entry, matchScore) => {
+            const existing = candidateScores.get(entry.id);
+            if (!existing || matchScore > existing.matchScore) {
+                candidateScores.set(entry.id, { entry, matchScore });
+            }
+        };
+        const matchesAnyScopeQuery = (entry) => {
+            if (scopeQueries.length === 0)
+                return true;
+            return scopeQueries.some((scopes) => this.entryMatchesScopeQuery(entry, scopes));
+        };
+        const matchesRequestedFilters = (entry) => {
+            if (!matchesAnyScopeQuery(entry))
+                return false;
+            if (opts.kinds && opts.kinds.length > 0 && !opts.kinds.includes(entry.kind)) {
+                return false;
+            }
+            return true;
+        };
+        const ftsHits = scopeQueries.flatMap((scopes) => searchByFts(this.db, query, limit * 4, {
+            scopes,
+            kinds: opts.kinds,
+        }));
+        const ftsRanks = ftsHits.map((h) => h.rank);
+        const bestFtsRank = Math.min(...ftsRanks);
+        const worstFtsRank = Math.max(...ftsRanks);
+        for (const h of ftsHits) {
+            const e = getEntryById(this.db, h.entry_id);
+            if (e) {
+                const rankScore = bestFtsRank === worstFtsRank
+                    ? 1
+                    : 1 - ((h.rank - bestFtsRank) / (worstFtsRank - bestFtsRank));
+                addCandidate(e, lexicalMatchScore(e, terms, rankScore));
+            }
+        }
+        try {
+            const qvec = await this.embedder.embed(query);
+            const hits = searchByVector(this.db, qvec, limit * 4);
+            for (const h of hits) {
+                const e = getEntryById(this.db, h.entry_id);
+                if (e) {
+                    const similarity = Math.max(0, 1 - h.distance);
+                    addCandidate(e, Math.min(similarity, 0.75));
+                }
+            }
+        }
+        catch {
+            // Vector search failed — fall back to scope-only
+        }
+        // If neither search path returned candidates, fall back to all entries in scope.
+        if (candidateScores.size === 0) {
+            for (const e of this.getEntriesForScopeQueries(scopeQueries)) {
+                addCandidate(e, 0);
+            }
+        }
+        let candidates = Array.from(candidateScores.values());
+        // Filter out retracted (tombstoned) entries
+        candidates = candidates.filter(({ entry }) => !entry.retracted);
+        // Enforce strict scope isolation: entry must include ALL requested scopes.
+        // This keeps vector and fallback paths consistent.
+        candidates = candidates.filter(({ entry }) => matchesAnyScopeQuery(entry));
+        // Filter by kind
+        if (opts.kinds && opts.kinds.length > 0) {
+            const kindSet = new Set(opts.kinds);
+            candidates = candidates.filter(({ entry }) => kindSet.has(entry.kind));
+        }
+        // Vector search is limited before scope filtering by sqlite-vec. If its top
+        // hits are outside the requested scopes, preserve the old scoped fallback.
+        if (candidates.length === 0 && candidateScores.size > 0) {
+            for (const e of this.getEntriesForScopeQueries(scopeQueries)) {
+                if (!opts.kinds || opts.kinds.includes(e.kind)) {
+                    addCandidate(e, 0);
+                }
+            }
+            candidates = Array.from(candidateScores.values()).filter(({ entry }) => {
+                return matchesRequestedFilters(entry);
+            });
+        }
+        // Score & rank
+        const scored = candidates.map(({ entry: e, matchScore }) => {
+            const conf = effectiveConfidence(e, now);
+            const match = matchScore;
+            // Recency bonus: 0–0.2 based on days since last seen (max at 0 days)
+            const daysSince = (now - e.last_seen_at) / (1000 * 60 * 60 * 24);
+            const recency = Math.max(0, 0.2 - daysSince * 0.02);
+            // Pin bonus
+            const pin = e.pinned ? 0.3 : 0;
+            const score = matchScore + conf * 0.2 + recency + pin;
+            return { entry: e, score, match, conf };
+        });
+        scored.sort((a, b) => {
+            if (b.score !== a.score)
+                return b.score - a.score;
+            return b.conf - a.conf;
+        });
+        // Touch recalled entries
+        const top = scored.slice(0, limit);
+        for (const s of top) {
+            touchEntry(this.db, s.entry.id, now);
+            stampReinforcement(this.db, s.entry.id, this.sessionId);
+        }
+        return {
+            entries: top.map((s) => ({
+                id: s.entry.id,
+                kind: s.entry.kind,
+                content: s.entry.content,
+                confidence: s.entry.confidence,
+                match: Math.round(s.match * 1000) / 1000,
+                scopes: s.entry.scopes,
+                score: Math.round(s.score * 1000) / 1000,
+            })),
+        };
+    }
+    async pin(id) {
+        this.db.prepare("UPDATE entries SET pinned = 1 WHERE id = ?").run(id);
+    }
+    async unpin(id) {
+        this.db.prepare("UPDATE entries SET pinned = 0 WHERE id = ?").run(id);
+    }
+    reinforceFromSuccessfulToolOutcome(entryIds, alpha = 0.08) {
+        const uniqueIds = new Set(entryIds);
+        for (const id of uniqueIds) {
+            const entry = getEntryById(this.db, id);
+            if (!entry)
+                continue;
+            reinforceEntry(this.db, id, alpha);
+        }
+    }
+    getAllEntries() {
+        return getAllEntries(this.db);
+    }
+    /** Promote an entry from Layer 1 to Layer 2 (deep memory). */
+    promoteToLayer2(id) {
+        this.db.prepare("UPDATE entries SET layer = 2 WHERE id = ? AND layer = 1").run(id);
+    }
+    /** Weaken an entry's confidence by a beta factor (0–1). */
+    weakenEntry(id, beta = 0.3) {
+        weakenEntry(this.db, id, beta);
+    }
+    /**
+     * Remove stale Layer 1 entries with effective confidence below 0.05
+     * that have not been seen in 30+ days. Never prunes pinned or Layer 2 entries.
+     */
+    async prune() {
+        const now = Date.now();
+        const minAgeMs = 30 * 86_400_000;
+        const toDelete = getAllEntries(this.db).filter((e) => {
+            if (e.pinned || e.layer === 2)
+                return false;
+            const ageMs = now - e.last_seen_at;
+            if (ageMs <= minAgeMs)
+                return false;
+            return effectiveConfidence(e, now) < 0.05;
+        });
+        for (const entry of toDelete) {
+            deleteEntry(this.db, entry.id);
+        }
+        return toDelete.length;
+    }
+    /** Re-embed all entries after vector dimension migration. Runs in the background. */
+    async reembedAllEntries() {
+        this.reembedding = true;
+        const entries = getAllEntries(this.db);
+        const log = getAppLogger().child("memory");
+        log.info(`Re-embedding ${entries.length} entries after dimension migration…`);
+        let failed = 0;
+        for (const e of entries) {
+            try {
+                const vec = await this.embedder.embed(e.content);
+                upsertEmbedding(this.db, e.id, vec);
+            }
+            catch (err) {
+                failed++;
+                log.warn(`Failed to re-embed entry ${e.id}`, {
+                    cause: err instanceof Error ? err : new Error(String(err)),
+                });
+            }
+        }
+        this.reembedding = false;
+        if (failed > 0) {
+            log.warn(`Re-embed migration complete — ${failed}/${entries.length} entries failed. Recall quality may be degraded`);
+        }
+        else {
+            clearReembedNeeded(this.db);
+            log.info(`Re-embed migration complete — ${entries.length} entries updated`);
+        }
+    }
+    // ---- Internal ----
+    async waitForReembed() {
+        if (this.reembedPromise) {
+            await this.reembedPromise;
+            this.reembedPromise = null;
+        }
+    }
+    buildDefaultScopes(ctx) {
+        return [
+            `user:${ctx.user_id}`,
+            `agent:${ctx.agent}`,
+            `context:${ctx.context_id}`,
+        ];
+    }
+    async buildDigest(ctx, minScore = 0.35) {
+        const now = Date.now();
+        const entries = this.getEntriesForScopeQueries(this.buildScopeQueries(this.defaultScopes));
+        // Score all entries — Layer 2 first, then digestScore within layer
+        const scored = entries.map((e) => ({
+            entry: e,
+            score: digestScore(e, now) + (e.pinned ? 0.3 : 0),
+        }));
+        scored.sort((a, b) => {
+            if (a.entry.layer !== b.entry.layer)
+                return b.entry.layer - a.entry.layer;
+            return b.score - a.score;
+        });
+        const filtered = scored.filter((s) => s.score >= minScore);
+        // Build markdown
+        const lines = [];
+        const included = [];
+        const kindOrder = ["constraint", "preference", "fact", "pattern", "decision", "mistake"];
+        for (const kind of kindOrder) {
+            const bucket = filtered
+                .filter((s) => s.entry.kind === kind)
+                .sort((a, b) => b.score - a.score);
+            if (bucket.length === 0)
+                continue;
+            const title = kind.charAt(0).toUpperCase() + kind.slice(1) + (kind === "mistake" ? "s to avoid" : "s");
+            lines.push(`## ${title}`);
+            for (const s of bucket) {
+                lines.push(`- ${s.entry.content}`);
+                included.push(s.entry.id);
+            }
+            lines.push("");
+        }
+        if (lines.length > 0) {
+            lines.push("Use recall(\"...\") for anything not shown.");
+        }
+        const markdown = lines.join("\n").trimEnd();
+        return {
+            markdown: markdown || "_No memories for this scope yet._",
+            empty: included.length === 0,
+            entriesIncluded: included,
+        };
+    }
+    buildScopeQueries(scopes) {
+        if (scopes.length === 0)
+            return [scopes];
+        const queries = [scopes];
+        const legacyAgentScopes = scopes.map((scope) => scope === `agent:${APP_AGENT_ID}` ? `agent:${LEGACY_APP_AGENT_ID}` : scope);
+        if (legacyAgentScopes.some((scope, index) => scope !== scopes[index])) {
+            queries.push(legacyAgentScopes);
+        }
+        const hasContextScope = scopes.some((scope) => scope.startsWith("context:"));
+        if (!hasContextScope)
+            return queries;
+        const globalScopes = scopes.filter((scope) => !scope.startsWith("context:"));
+        if (globalScopes.length === scopes.length || globalScopes.length === 0) {
+            return queries;
+        }
+        queries.push(globalScopes);
+        return queries;
+    }
+    getEntriesForScopeQueries(scopeQueries) {
+        const byId = new Map();
+        for (const scopes of scopeQueries) {
+            const entries = scopes.length > 0
+                ? getEntriesByScope(this.db, scopes)
+                : getAllEntries(this.db);
+            for (const entry of entries) {
+                if (entry.retracted)
+                    continue;
+                if (!this.entryMatchesScopeQuery(entry, scopes))
+                    continue;
+                if (!byId.has(entry.id))
+                    byId.set(entry.id, entry);
+            }
+        }
+        return Array.from(byId.values());
+    }
+    entryMatchesScopeQuery(entry, scopes) {
+        const entryScopeSet = new Set(entry.scopes);
+        for (const scope of scopes) {
+            if (!entryScopeSet.has(scope))
+                return false;
+        }
+        const queryHasContext = scopes.some((scope) => scope.startsWith("context:"));
+        if (!queryHasContext) {
+            const entryHasContext = entry.scopes.some((scope) => scope.startsWith("context:"));
+            if (entryHasContext)
+                return false;
+        }
+        return true;
+    }
+    retractMemory(id) {
+        retractMemoryDb(this.db, id);
+    }
+    hasEntry(id) {
+        return getEntryById(this.db, id) !== undefined;
+    }
+}

package/dist/memory/summarizer-factory.d.ts

@@ -0,0 +1,3 @@
+import type { MemoryConfig } from "../types.js";
+import type { SummarizerLLM } from "./types.js";
+export declare function createSummarizer(config: MemoryConfig): Promise<SummarizerLLM | null>;

package/dist/memory/summarizer-factory.js

@@ -0,0 +1,69 @@
+// ============================================================
+// ARIA Memory — Summarizer factory
+// ============================================================
+import { getAppLogger } from "../logger.js";
+import { envOverride } from "../app-identity.js";
+import { OllamaEmbedder } from "./embeddings.js";
+import { OllamaSummarizer, listOllamaModelNames, pickDefaultChatModel, } from "./ollama-summarizer.js";
+import { OpenAISummarizer } from "./openai-summarizer.js";
+export async function createSummarizer(config) {
+    const log = getAppLogger().child("memory");
+    const mode = (config.summarizer ?? "openrouter").toLowerCase();
+    if (mode === "disabled")
+        return null;
+    if (mode === "ollama") {
+        const url = config.ollama_url ?? "http://localhost:11434";
+        const configured = config.ollama_summarizer_model?.trim() ||
+            envOverride("PRAANA_SUMMARIZER_MODEL", "ARIA_SUMMARIZER_MODEL")?.trim() ||
+            "";
+        let model = configured;
+        if (!model) {
+            const names = await listOllamaModelNames(url);
+            model = pickDefaultChatModel(names) ?? "";
+            if (model) {
+                log.notice(`summarizer model unset — using: ${model}`);
+            }
+        }
+        if (!model) {
+            log.warn("Ollama summarizer enabled but no chat model found. Set memory.ollama_summarizer_model or run: ollama pull <model>");
+            return null;
+        }
+        if (!(await OllamaEmbedder.isAvailable(url, model))) {
+            log.warn(`Ollama model '${model}' is not available at ${url}. Run: ollama pull ${model.split(":")[0]}`);
+            return null;
+        }
+        log.notice(`summarizer: ${model}`);
+        return new OllamaSummarizer(url, model);
+    }
+    if (mode === "openai") {
+        const apiKey = process.env.OPENAI_API_KEY ?? "";
+        const model = envOverride("PRAANA_SUMMARIZER_MODEL", "ARIA_SUMMARIZER_MODEL") ?? "gpt-4o-mini";
+        if (!apiKey) {
+            log.warn("summarizer=openai but OPENAI_API_KEY is not set");
+            return null;
+        }
+        return new OpenAISummarizer({
+            baseUrl: "https://api.openai.com/v1",
+            apiKey,
+            model,
+        });
+    }
+    // openrouter (default) and legacy "openrouter" spelling
+    if (mode === "openrouter" || mode === "openai-compatible") {
+        const openRouterKey = process.env.OPENROUTER_API_KEY ?? "";
+        const openAiKey = process.env.OPENAI_API_KEY ?? "";
+        const apiKey = openRouterKey || openAiKey;
+        const baseUrl = openRouterKey
+            ? "https://openrouter.ai/api/v1"
+            : "https://api.openai.com/v1";
+        const model = envOverride("PRAANA_SUMMARIZER_MODEL", "ARIA_SUMMARIZER_MODEL") ??
+            "google/gemini-2.5-flash";
+        if (!apiKey) {
+            log.warn("summarizer=openrouter but OPENROUTER_API_KEY / OPENAI_API_KEY is not set");
+            return null;
+        }
+        return new OpenAISummarizer({ baseUrl, apiKey, model });
+    }
+    log.warn(`Unknown memory.summarizer '${config.summarizer}' — session-end summarization disabled`);
+    return null;
+}