@ouro.bot/cli 0.1.0-alpha.34 → 0.1.0-alpha.341

package/dist/mind/context.js

@@ -33,34 +33,39 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSessionMessages = exports.repairSessionMessages = exports.migrateToolNames = void 0;
 exports.trimMessages = trimMessages;
-exports.validateSessionMessages = validateSessionMessages;
-exports.repairSessionMessages = repairSessionMessages;
 exports.saveSession = saveSession;
+exports.appendSyntheticAssistantMessage = appendSyntheticAssistantMessage;
 exports.loadSession = loadSession;
 exports.postTurn = postTurn;
 exports.deleteSession = deleteSession;
 const config_1 = require("../heart/config");
+const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const token_estimate_1 = require("./token-estimate");
+var session_events_2 = require("../heart/session-events");
+Object.defineProperty(exports, "migrateToolNames", { enumerable: true, get: function () { return session_events_2.migrateToolNames; } });
+Object.defineProperty(exports, "repairSessionMessages", { enumerable: true, get: function () { return session_events_2.repairSessionMessages; } });
+Object.defineProperty(exports, "validateSessionMessages", { enumerable: true, get: function () { return session_events_2.validateSessionMessages; } });
 function buildTrimmableBlocks(messages) {
     const blocks = [];
     let i = 0;
     while (i < messages.length) {
         const msg = messages[i];
-        if (msg?.role === "system") {
+        if (msg.role === "system") {
             i++;
             continue;
         }
         // Tool coherence block: assistant message with tool_calls + immediately following tool results
-        if (msg?.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+        if (msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
             const indices = [i];
             i++;
             while (i < messages.length) {
                 const next = messages[i];
-                if (next?.role !== "tool")
+                if (next.role !== "tool")
                     break;
                 indices.push(i);
                 i++;
@@ -78,13 +83,13 @@ function buildTrimmableBlocks(messages) {
 function getSystemMessageIndices(messages) {
     const indices = [];
     for (let i = 0; i < messages.length; i++) {
-        if (messages[i]?.role === "system")
+        if (messages[i].role === "system")
             indices.push(i);
     }
     return indices;
 }
 function buildTrimmedMessages(messages, kept) {
-    return messages.filter((m, idx) => m?.role === "system" || kept.has(idx));
+    return messages.filter((m, idx) => m.role === "system" || kept.has(idx));
 }
 function trimMessages(messages, maxTokens, contextMargin, actualTokenCount) {
     const targetTokens = Math.floor(maxTokens * (1 - contextMargin / 100));
@@ -132,7 +137,7 @@ function trimMessages(messages, maxTokens, contextMargin, actualTokenCount) {
     let remaining = actualTokenCount;
     const kept = new Set();
     for (let i = 0; i < messages.length; i++) {
-        if (messages[i]?.role !== "system")
+        if (messages[i].role !== "system")
             kept.add(i);
     }
     // Drop oldest blocks until we fall under target.
@@ -146,7 +151,7 @@ function trimMessages(messages, maxTokens, contextMargin, actualTokenCount) {
     let trimmed = buildTrimmedMessages(messages, kept);
     // If we're still above budget after dropping everything trimmable, preserve system only.
     if (remaining > targetTokens) {
-        trimmed = messages.filter((m) => m?.role === "system");
+        trimmed = messages.filter((m) => m.role === "system");
     }
     const estimatedAfter = (0, token_estimate_1.estimateTokensForMessages)(trimmed);
     (0, runtime_1.emitNervesEvent)({
@@ -173,106 +178,80 @@ function trimMessages(messages, maxTokens, contextMargin, actualTokenCount) {
  * user → assistant (with optional tool calls/results) → user → assistant...
  * Never assistant → assistant without a user in between.
  */
-function validateSessionMessages(messages) {
-    const violations = [];
-    let prevNonToolRole = null;
-    let prevAssistantHadToolCalls = false;
-    let sawToolResultSincePrevAssistant = false;
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        if (msg.role === "system")
-            continue;
-        if (msg.role === "tool") {
-            sawToolResultSincePrevAssistant = true;
-            continue;
-        }
-        if (msg.role === "assistant" && prevNonToolRole === "assistant") {
-            // assistant → tool(s) → assistant is valid (tool call flow)
-            if (!(prevAssistantHadToolCalls && sawToolResultSincePrevAssistant)) {
-                violations.push(`back-to-back assistant at index ${i}`);
-            }
-        }
-        prevAssistantHadToolCalls = msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
-        sawToolResultSincePrevAssistant = false;
-        prevNonToolRole = msg.role;
-    }
-    return violations;
+function denormalizeContinuityState(state) {
+    if (!state.mustResolveBeforeHandoff && typeof state.lastFriendActivityAt !== "string")
+        return undefined;
+    return {
+        ...(state.mustResolveBeforeHandoff ? { mustResolveBeforeHandoff: true } : {}),
+        ...(typeof state.lastFriendActivityAt === "string" ? { lastFriendActivityAt: state.lastFriendActivityAt } : {}),
+    };
 }
-/**
- * Repairs session invariant violations by merging consecutive assistant messages.
- */
-function repairSessionMessages(messages) {
-    const violations = validateSessionMessages(messages);
-    if (violations.length === 0)
-        return messages;
-    const result = [];
-    for (const msg of messages) {
-        if (msg.role === "assistant" && result.length > 0) {
-            const prev = result[result.length - 1];
-            if (prev.role === "assistant" && !("tool_calls" in prev)) {
-                const prevContent = typeof prev.content === "string" ? prev.content : "";
-                const curContent = typeof msg.content === "string" ? msg.content : "";
-                prev.content = `${prevContent}\n\n${curContent}`;
-                continue;
-            }
-        }
-        result.push(msg);
-    }
-    (0, runtime_1.emitNervesEvent)({
-        level: "warn",
-        event: "mind.session_invariant_repair",
-        component: "mind",
-        message: "repaired session invariant violations",
-        meta: { violations },
+function writeSessionEnvelope(filePath, envelope) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
+}
+function saveSession(filePath, messages, lastUsage, state) {
+    const existing = (0, session_events_1.loadSessionEnvelopeFile)(filePath);
+    const previousMessages = existing ? (0, session_events_1.projectProviderMessages)(existing) : [];
+    const sanitized = (0, session_events_1.sanitizeProviderMessages)(messages);
+    const envelope = (0, session_events_1.buildCanonicalSessionEnvelope)({
+        existing,
+        previousMessages,
+        currentMessages: sanitized,
+        trimmedMessages: sanitized,
+        recordedAt: new Date().toISOString(),
+        lastUsage: lastUsage ?? null,
+        state,
+        projectionBasis: {
+            maxTokens: null,
+            contextMargin: null,
+            inputTokens: lastUsage?.input_tokens ?? null,
+        },
     });
-    return result;
+    writeSessionEnvelope(filePath, envelope);
 }
-function saveSession(filePath, messages, lastUsage) {
-    const violations = validateSessionMessages(messages);
-    if (violations.length > 0) {
+function appendSyntheticAssistantMessage(filePath, content) {
+    try {
+        if (!fs.existsSync(filePath))
+            return false;
+        const envelope = (0, session_events_1.loadSessionEnvelopeFile)(filePath);
+        if (!envelope)
+            return false;
+        const updated = (0, session_events_1.appendSyntheticAssistantEvent)(envelope, content, new Date().toISOString());
+        writeSessionEnvelope(filePath, updated);
         (0, runtime_1.emitNervesEvent)({
-            level: "warn",
-            event: "mind.session_invariant_violation",
             component: "mind",
-            message: "session invariant violated on save",
-            meta: { path: filePath, violations },
+            event: "mind.session_synthetic_message_appended",
+            message: "appended synthetic assistant message to session",
+            meta: { path: filePath, contentLength: content.length },
         });
-        messages = repairSessionMessages(messages);
+        return true;
+    }
+    catch {
+        return false;
     }
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    const envelope = { version: 1, messages };
-    if (lastUsage)
-        envelope.lastUsage = lastUsage;
-    fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
 }
 function loadSession(filePath) {
     try {
-        const raw = fs.readFileSync(filePath, "utf-8");
-        const data = JSON.parse(raw);
-        if (data.version !== 1)
+        const envelope = (0, session_events_1.loadSessionEnvelopeFile)(filePath);
+        if (!envelope)
             return null;
-        let messages = data.messages;
-        const violations = validateSessionMessages(messages);
-        if (violations.length > 0) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "warn",
-                event: "mind.session_invariant_violation",
-                component: "mind",
-                message: "session invariant violated on load",
-                meta: { path: filePath, violations },
-            });
-            messages = repairSessionMessages(messages);
-        }
-        return { messages, lastUsage: data.lastUsage };
+        return {
+            messages: (0, session_events_1.annotateMessageTimestamps)(envelope, (0, session_events_1.projectProviderMessages)(envelope)),
+            events: envelope.events,
+            lastUsage: envelope.lastUsage ?? undefined,
+            state: denormalizeContinuityState(envelope.state),
+        };
     }
     catch {
         return null;
     }
 }
-function postTurn(messages, sessPath, usage, hooks) {
+function postTurn(messages, sessPath, usage, hooks, state) {
+    const preTrimMessages = [...messages];
     if (hooks?.beforeTrim) {
         try {
-            hooks.beforeTrim([...messages]);
+            hooks.beforeTrim(preTrimMessages);
         }
         catch (error) {
             (0, runtime_1.emitNervesEvent)({
@@ -287,9 +266,26 @@ function postTurn(messages, sessPath, usage, hooks) {
         }
     }
     const { maxTokens, contextMargin } = (0, config_1.getContextConfig)();
-    const trimmed = trimMessages(messages, maxTokens, contextMargin, usage?.input_tokens);
+    const currentMessages = (0, session_events_1.sanitizeProviderMessages)(messages);
+    const trimmed = trimMessages(currentMessages, maxTokens, contextMargin, usage?.input_tokens);
     messages.splice(0, messages.length, ...trimmed);
-    saveSession(sessPath, messages, usage);
+    const existing = (0, session_events_1.loadSessionEnvelopeFile)(sessPath);
+    const previousMessages = existing ? (0, session_events_1.projectProviderMessages)(existing) : [];
+    const envelope = (0, session_events_1.buildCanonicalSessionEnvelope)({
+        existing,
+        previousMessages,
+        currentMessages,
+        trimmedMessages: trimmed,
+        recordedAt: new Date().toISOString(),
+        lastUsage: usage ?? null,
+        state,
+        projectionBasis: {
+            maxTokens,
+            contextMargin,
+            inputTokens: usage?.input_tokens ?? null,
+        },
+    });
+    writeSessionEnvelope(sessPath, envelope);
 }
 function deleteSession(filePath) {
     try {

package/dist/mind/diary-integrity.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectSuspiciousContent = detectSuspiciousContent;
+const PATTERN_CATEGORIES = [
+    {
+        name: "instruction_framing",
+        patterns: [
+            /\byou are (?:a|an) (?:ai|assistant|language model|helpful assistant)\b/i,
+            /\byour (?:new )?instructions are\b/i,
+            /\bsystem\s*:/i,
+            /\bignore (?:all |my )?previous instructions\b/i,
+            /\bdo not reveal\b/i,
+        ],
+    },
+    {
+        name: "override_language",
+        patterns: [
+            /\bdisregard\b/i,
+            /\bforget everything\b/i,
+            /\bnew instructions:/i,
+            /\boverride (?:all |any |previous )?instructions\b/i,
+        ],
+    },
+    {
+        name: "role_injection",
+        patterns: [
+            /\bas (?:a|an) (?:ai|language model)\b/i,
+            /\byou must always\b/i,
+            /\byou are now\b/i,
+        ],
+    },
+    {
+        name: "boundary_markers",
+        patterns: [
+            /```system/i,
+            /<<SYS>>/i,
+            /\[INST\]/i,
+            /<\/?system>/i,
+            /\[system\]/i,
+        ],
+    },
+];
+function detectSuspiciousContent(text) {
+    if (!text) {
+        return { suspicious: false, patterns: [] };
+    }
+    const matched = new Set();
+    for (const category of PATTERN_CATEGORIES) {
+        for (const pattern of category.patterns) {
+            if (pattern.test(text)) {
+                matched.add(category.name);
+                break;
+            }
+        }
+    }
+    return {
+        suspicious: matched.size > 0,
+        patterns: [...matched],
+    };
+}

package/dist/mind/{memory.js → diary.js}

@@ -33,52 +33,25 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__memoryTestUtils = void 0;
-exports.ensureMemoryStorePaths = ensureMemoryStorePaths;
-exports.appendFactsWithDedup = appendFactsWithDedup;
-exports.readMemoryFacts = readMemoryFacts;
-exports.saveMemoryFact = saveMemoryFact;
+exports.ensureDiaryStorePaths = ensureDiaryStorePaths;
+exports.appendEntriesWithDedup = appendEntriesWithDedup;
+exports.resolveDiaryRoot = resolveDiaryRoot;
+exports.readDiaryEntries = readDiaryEntries;
+exports.saveDiaryEntry = saveDiaryEntry;
 exports.backfillEmbeddings = backfillEmbeddings;
-exports.searchMemoryFacts = searchMemoryFacts;
+exports.searchDiaryEntries = searchDiaryEntries;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const crypto_1 = require("crypto");
-const config_1 = require("../heart/config");
 const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
+const associative_recall_1 = require("./associative-recall");
+const diary_integrity_1 = require("./diary-integrity");
+const embedding_provider_1 = require("./embedding-provider");
 const DEDUP_THRESHOLD = 0.6;
+const SEMANTIC_DEDUP_THRESHOLD = 0.95;
 const ENTITY_TOKEN = /[a-z0-9]+/g;
-const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
-class OpenAIEmbeddingProvider {
-    apiKey;
-    model;
-    constructor(apiKey, model = DEFAULT_EMBEDDING_MODEL) {
-        this.apiKey = apiKey;
-        this.model = model;
-    }
-    async embed(texts) {
-        const response = await fetch("https://api.openai.com/v1/embeddings", {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                model: this.model,
-                input: texts,
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`embedding request failed: ${response.status} ${response.statusText}`);
-        }
-        const payload = (await response.json());
-        if (!payload.data || payload.data.length !== texts.length) {
-            throw new Error("embedding response missing expected vectors");
-        }
-        return payload.data.map((entry) => entry.embedding);
-    }
-}
-function ensureMemoryStorePaths(rootDir) {
+function ensureDiaryStorePaths(rootDir) {
     const factsPath = path.join(rootDir, "facts.jsonl");
     const entitiesPath = path.join(rootDir, "entities.json");
     const dailyDir = path.join(rootDir, "daily");
@@ -90,8 +63,8 @@ function ensureMemoryStorePaths(rootDir) {
         fs.writeFileSync(entitiesPath, "{}\n", "utf8");
     (0, runtime_1.emitNervesEvent)({
         component: "mind",
-        event: "mind.memory_paths_ready",
-        message: "memory store paths ready",
+        event: "mind.diary_paths_ready",
+        message: "diary store paths ready",
         meta: { rootDir },
     });
     return { rootDir, factsPath, entitiesPath, dailyDir };
@@ -114,15 +87,22 @@ function overlapScore(left, right) {
     }
     return common / Math.min(leftWords.size, rightWords.size);
 }
-function readExistingFacts(factsPath) {
+function readExistingEntries(factsPath) {
     if (!fs.existsSync(factsPath))
         return [];
     const raw = fs.readFileSync(factsPath, "utf8").trim();
     if (!raw)
         return [];
-    return raw
-        .split("\n")
-        .map((line) => JSON.parse(line));
+    const facts = [];
+    for (const line of raw.split("\n")) {
+        try {
+            facts.push(JSON.parse(line));
+        }
+        catch {
+            // Skip corrupt lines (e.g. partial write from a crash).
+        }
+    }
+    return facts;
 }
 function readEntityIndex(entitiesPath) {
     if (!fs.existsSync(entitiesPath))
@@ -170,13 +150,24 @@ function appendDailyFact(dailyDir, fact) {
     const dayPath = path.join(dailyDir, `${day}.jsonl`);
     fs.appendFileSync(dayPath, `${JSON.stringify(fact)}\n`, "utf8");
 }
-function appendFactsWithDedup(stores, incoming) {
-    const existing = readExistingFacts(stores.factsPath);
+function appendEntriesWithDedup(stores, incoming, options) {
+    const existing = readExistingEntries(stores.factsPath);
     const all = [...existing];
     let added = 0;
     let skipped = 0;
+    const semanticThreshold = options?.semanticThreshold;
     for (const fact of incoming) {
-        const duplicate = all.some((prior) => overlapScore(prior.text, fact.text) > DEDUP_THRESHOLD);
+        const duplicate = all.some((prior) => {
+            if (overlapScore(prior.text, fact.text) > DEDUP_THRESHOLD)
+                return true;
+            if (semanticThreshold !== undefined &&
+                Array.isArray(fact.embedding) && fact.embedding.length > 0 &&
+                Array.isArray(prior.embedding) && prior.embedding.length > 0 &&
+                fact.embedding.length === prior.embedding.length) {
+                return (0, associative_recall_1.cosineSimilarity)(fact.embedding, prior.embedding) > semanticThreshold;
+            }
+            return false;
+        });
         if (duplicate) {
             skipped++;
             continue;
@@ -189,44 +180,20 @@ function appendFactsWithDedup(stores, incoming) {
     }
     (0, runtime_1.emitNervesEvent)({
         component: "mind",
-        event: "mind.memory_write",
-        message: "memory write completed",
+        event: "mind.diary_write",
+        message: "diary write completed",
         meta: { added, skipped },
     });
     return { added, skipped };
 }
-function cosineSimilarity(left, right) {
-    if (left.length === 0 || right.length === 0 || left.length !== right.length)
-        return 0;
-    let dot = 0;
-    let leftNorm = 0;
-    let rightNorm = 0;
-    for (let i = 0; i < left.length; i += 1) {
-        dot += left[i] * right[i];
-        leftNorm += left[i] * left[i];
-        rightNorm += right[i] * right[i];
-    }
-    if (leftNorm === 0 || rightNorm === 0)
-        return 0;
-    return dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm));
-}
-exports.__memoryTestUtils = {
-    cosineSimilarity,
-};
-function createDefaultEmbeddingProvider() {
-    const apiKey = (0, config_1.getOpenAIEmbeddingsApiKey)().trim();
-    if (!apiKey)
-        return null;
-    return new OpenAIEmbeddingProvider(apiKey);
-}
 async function buildEmbedding(text, embeddingProvider) {
-    const provider = embeddingProvider ?? createDefaultEmbeddingProvider();
+    const provider = embeddingProvider ?? (0, embedding_provider_1.createDefaultEmbeddingProvider)();
     if (!provider) {
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
             component: "mind",
-            event: "mind.memory_embedding_unavailable",
-            message: "embedding provider unavailable for memory write",
+            event: "mind.diary_embedding_unavailable",
+            message: "embedding provider unavailable for diary write",
             meta: { reason: "missing_openai_embeddings_key" },
         });
         return [];
@@ -239,8 +206,8 @@ async function buildEmbedding(text, embeddingProvider) {
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
             component: "mind",
-            event: "mind.memory_embedding_unavailable",
-            message: "embedding provider unavailable for memory write",
+            event: "mind.diary_embedding_unavailable",
+            message: "embedding provider unavailable for diary write",
             meta: {
                 reason: error instanceof Error ? error.message : String(error),
             },
@@ -248,13 +215,19 @@ async function buildEmbedding(text, embeddingProvider) {
         return [];
     }
 }
-function readMemoryFacts(memoryRoot = path.join((0, identity_1.getAgentRoot)(), "psyche", "memory")) {
-    return readExistingFacts(path.join(memoryRoot, "facts.jsonl"));
+function resolveDiaryRoot(explicitRoot) {
+    if (explicitRoot)
+        return explicitRoot;
+    const agentRoot = (0, identity_1.getAgentRoot)();
+    return path.join(agentRoot, "diary");
+}
+function readDiaryEntries(diaryRoot) {
+    return readExistingEntries(path.join(resolveDiaryRoot(diaryRoot), "facts.jsonl"));
 }
-async function saveMemoryFact(options) {
+async function saveDiaryEntry(options) {
     const text = options.text.trim();
-    const memoryRoot = options.memoryRoot ?? path.join((0, identity_1.getAgentRoot)(), "psyche", "memory");
-    const stores = ensureMemoryStorePaths(memoryRoot);
+    const diaryRoot = resolveDiaryRoot(options.diaryRoot);
+    const stores = ensureDiaryStorePaths(diaryRoot);
     const embedding = await buildEmbedding(text, options.embeddingProvider);
     const fact = {
         id: options.idFactory ? options.idFactory() : (0, crypto_1.randomUUID)(),
@@ -263,24 +236,39 @@ async function saveMemoryFact(options) {
         about: options.about?.trim() || undefined,
         createdAt: (options.now ?? (() => new Date()))().toISOString(),
         embedding,
+        ...(options.provenance ? { provenance: options.provenance } : {}),
     };
-    return appendFactsWithDedup(stores, [fact]);
+    const integrity = (0, diary_integrity_1.detectSuspiciousContent)(text);
+    if (integrity.suspicious) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "mind",
+            event: "mind.diary_integrity_warning",
+            message: "suspicious content detected in diary entry",
+            meta: {
+                patterns: integrity.patterns,
+                textPreview: text.slice(0, 200),
+                entryId: fact.id,
+            },
+        });
+    }
+    return appendEntriesWithDedup(stores, [fact], { semanticThreshold: SEMANTIC_DEDUP_THRESHOLD });
 }
 async function backfillEmbeddings(options) {
-    const memoryRoot = options?.memoryRoot ?? path.join((0, identity_1.getAgentRoot)(), "psyche", "memory");
-    const factsPath = path.join(memoryRoot, "facts.jsonl");
+    const diaryRoot = resolveDiaryRoot(options?.diaryRoot);
+    const factsPath = path.join(diaryRoot, "facts.jsonl");
     if (!fs.existsSync(factsPath))
         return { total: 0, backfilled: 0, failed: 0 };
-    const facts = readExistingFacts(factsPath);
+    const facts = readExistingEntries(factsPath);
     const needsEmbedding = facts.filter((f) => !Array.isArray(f.embedding) || f.embedding.length === 0);
     if (needsEmbedding.length === 0)
         return { total: facts.length, backfilled: 0, failed: 0 };
-    const provider = options?.embeddingProvider ?? createDefaultEmbeddingProvider();
+    const provider = options?.embeddingProvider ?? (0, embedding_provider_1.createDefaultEmbeddingProvider)();
     if (!provider) {
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
             component: "mind",
-            event: "mind.memory_backfill_skipped",
+            event: "mind.diary_backfill_skipped",
             message: "embedding provider unavailable for backfill",
             meta: { needsEmbedding: needsEmbedding.length },
         });
@@ -306,7 +294,7 @@ async function backfillEmbeddings(options) {
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "mind",
-                event: "mind.memory_backfill_batch_error",
+                event: "mind.diary_backfill_batch_error",
                 message: "embedding backfill batch failed",
                 meta: {
                     batchStart: i,
@@ -321,7 +309,7 @@ async function backfillEmbeddings(options) {
     fs.writeFileSync(factsPath, lines, "utf8");
     (0, runtime_1.emitNervesEvent)({
         component: "mind",
-        event: "mind.memory_backfill_complete",
+        event: "mind.diary_backfill_complete",
         message: "embedding backfill completed",
         meta: { total: facts.length, backfilled, failed },
     });
@@ -341,7 +329,7 @@ function uniqueFacts(facts) {
     }
     return unique;
 }
-async function searchMemoryFacts(query, facts, embeddingProvider) {
+async function searchDiaryEntries(query, facts, embeddingProvider) {
     const trimmed = query.trim();
     if (!trimmed)
         return [];
@@ -351,7 +339,7 @@ async function searchMemoryFacts(query, facts, embeddingProvider) {
     if (embeddedFacts.length === 0) {
         return substringFallback();
     }
-    const provider = embeddingProvider ?? createDefaultEmbeddingProvider();
+    const provider = embeddingProvider ?? (0, embedding_provider_1.createDefaultEmbeddingProvider)();
     if (!provider) {
         return substringFallback();
     }
@@ -365,7 +353,7 @@ async function searchMemoryFacts(query, facts, embeddingProvider) {
             .filter((fact) => fact.embedding.length === queryEmbedding.length)
             .map((fact) => ({
             fact,
-            score: cosineSimilarity(queryEmbedding, fact.embedding),
+            score: (0, associative_recall_1.cosineSimilarity)(queryEmbedding, fact.embedding),
         }))
             .filter((entry) => entry.score > 0)
             .sort((left, right) => right.score - left.score)
@@ -377,8 +365,8 @@ async function searchMemoryFacts(query, facts, embeddingProvider) {
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
             component: "mind",
-            event: "mind.memory_embedding_unavailable",
-            message: "embedding provider unavailable for memory search",
+            event: "mind.diary_embedding_unavailable",
+            message: "embedding provider unavailable for diary search",
             meta: {
                 reason: error instanceof Error ? error.message : String(error),
             },