@ouro.bot/cli 0.1.0-alpha.62 → 0.1.0-alpha.637

package/dist/mind/desk-section.js

@@ -0,0 +1,310 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatRelative = formatRelative;
+exports.deskSection = deskSection;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+// ──────────────────────────────────────────────────────────────────────────────
+// Static body — the agent's daily-read description of its desk.
+//
+// This is the room every ouro agent sits down in at the top of every turn.
+// The voice is intentional: lowercase, second-person-implied, physical
+// metaphor (drawers, corkboard, reference shelf, back-of-room archive). The
+// goal is that an agent reading this every turn feels at home rather than
+// being briefed — the desk is the agent's place, not a system being
+// explained to it.
+// ──────────────────────────────────────────────────────────────────────────────
+const STATIC_BODY = `## my desk
+
+i have a desk. it lives at \`desk/\` — a quiet room of my work, persistent across sessions. tracks line one wall like drawers in a wide cabinet; each drawer holds tasks in their own folders. friction notes pin to the corkboard where i won't lose them. the lessons i've kept sit on a small reference shelf by the window. nothing here gets thrown away — when a task is done it slides into the back, still browsable, still mine. semantic search reaches every surface: active work, the archive at the back, the corkboard, the lessons shelf.
+
+**the reflex.** when something belongs on the desk, i put it down before i start — anything that spans more than this turn, anything i'd forget by tomorrow, anything the operator will ask about later. laying it down builds the room around future-me.
+
+**what belongs on the desk:**
+- a project ("refactor the auth system", "draft the Q3 strategy memo")
+- a recurring task ("check the inbox every 30m") — uses \`cadence\`
+- a one-time reminder ("ping someone about the dentist tomorrow") — uses \`scheduledAt\`
+- a multi-step investigation ("figure out why the daemon flakes")
+- a friction note worth pinning to the board
+- a lesson worth shelving for future-me
+
+**what doesn't:**
+- a single-turn answer — it'll be done before the page turns
+- ephemeral debugging that resolves in the same exchange
+- work that has its own room. trips live in a travel folder; habits keep their own ledger; attention items, diary entries, journal entries — each has a separate home. the desk *links* to them when relevant; it doesn't absorb them.
+
+**shape.** tracks group related work — drawers in the cabinet, or sections of a shelf if you prefer the library framing. tasks live in tracks. each task has iterations: one per work session, with \`planning.md\` and \`doing.md\` laid side-by-side on the page.
+
+**states.** every task moves: \`drafting\` → \`processing\` → \`validating\` → \`done\`. some pause along the way: \`collaborating\` when i'm waiting on a human or peer agent, \`paused\` when the operator set it down, \`blocked\` when something outside is in the way, \`cancelled\` when we stopped wanting it. external trackers (ADO work items, GitHub issues) get *linked* from a task, not *replaced* by one — the desk holds my view of the work; the trackers hold the team's.
+
+**how i tend the desk.** the \`desk\` skills walk me through the small ceremonies — \`session-start\` when i sit down, \`task-lifecycle\` when a status shifts, \`start-task\` when i lay something new on the page, \`friction-management\` when i pin a card, \`lesson-capture\` when something earns the reference shelf. the \`mcp__desk__*\` tools (search / recall / similar / timeline / thread / task_*) are the hands for finding, writing, and threading work together.
+
+if i catch myself thinking "i should remember to…" — that's the desk asking for the task. put it down first, then keep going.`;
+const TERMINAL_TASK_STATUSES = new Set(["done", "cancelled"]);
+const TERMINAL_TRACK_STATUSES = new Set(["closed"]);
+const TOP_N_TASKS_PER_FEATURED = 3;
+// ──────────────────────────────────────────────────────────────────────────────
+// Tiny frontmatter parser — local, just enough for `status` + `updated` reads.
+// schema_version: 0 (no field) and schema_version: 1 parse identically here
+// because both keep `status` and `updated` at top level.
+// ──────────────────────────────────────────────────────────────────────────────
+function parseScalar(raw) {
+    const value = raw.trim();
+    if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function parseFrontmatter(content) {
+    const out = {};
+    const lines = content.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---")
+        return out;
+    const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+    if (closing === -1)
+        return out;
+    for (let i = 1; i < closing; i += 1) {
+        const line = lines[i];
+        if (!line.trim())
+            continue;
+        const match = /^([A-Za-z0-9_:-]+):\s*(.*)$/.exec(line);
+        if (!match)
+            continue;
+        const key = match[1];
+        const inline = match[2];
+        if (inline.length === 0)
+            continue;
+        out[key] = parseScalar(inline);
+    }
+    return out;
+}
+function readDeskRoot() {
+    try {
+        const root = path.join((0, identity_1.getAgentRoot)(), "desk");
+        const stat = fs.statSync(root);
+        if (!stat.isDirectory())
+            return null;
+        return root;
+    }
+    catch {
+        return null;
+    }
+}
+function readTrackFile(trackDir) {
+    try {
+        const raw = fs.readFileSync(path.join(trackDir, "track.md"), "utf-8");
+        const fm = parseFrontmatter(raw);
+        return { status: fm.status ?? "active" };
+    }
+    catch {
+        return { status: "active" };
+    }
+}
+function readTaskFile(taskDir) {
+    try {
+        const raw = fs.readFileSync(path.join(taskDir, "task.md"), "utf-8");
+        const fm = parseFrontmatter(raw);
+        return {
+            slug: path.basename(taskDir),
+            status: fm.status ?? "drafting",
+            updated: fm.updated ?? null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function listSubdirs(parent) {
+    /* v8 ignore start -- defensive readdir catch only fires on transient FS errors @preserve */
+    try {
+        return fs
+            .readdirSync(parent, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith("."))
+            .map((e) => e.name)
+            .sort((a, b) => a.localeCompare(b));
+    }
+    catch {
+        return [];
+    }
+    /* v8 ignore stop @preserve */
+}
+function readTrack(deskRoot, slug) {
+    const trackDir = path.join(deskRoot, slug);
+    try {
+        const stat = fs.statSync(trackDir);
+        if (!stat.isDirectory())
+            return null;
+        /* v8 ignore start -- defensive statSync catch on stale featured slug @preserve */
+    }
+    catch {
+        return null;
+    }
+    /* v8 ignore stop @preserve */
+    const { status } = readTrackFile(trackDir);
+    const taskSlugs = listSubdirs(trackDir);
+    const tasks = [];
+    for (const taskSlug of taskSlugs) {
+        const task = readTaskFile(path.join(trackDir, taskSlug));
+        if (task)
+            tasks.push(task);
+    }
+    return { slug, status, tasks };
+}
+function readFeaturedList(deskRoot) {
+    try {
+        const raw = fs.readFileSync(path.join(deskRoot, "_meta", "featured.md"), "utf-8");
+        return raw
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0 && !line.startsWith("#"));
+    }
+    catch {
+        return [];
+    }
+}
+// ──────────────────────────────────────────────────────────────────────────────
+// Relative-time formatter — no deps, plain English short form
+// ──────────────────────────────────────────────────────────────────────────────
+function formatRelative(updated, now = new Date()) {
+    if (!updated)
+        return "unknown";
+    const then = new Date(updated);
+    if (Number.isNaN(then.getTime()))
+        return "unknown";
+    const diffMs = now.getTime() - then.getTime();
+    if (diffMs < 0)
+        return "just now";
+    const seconds = Math.floor(diffMs / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+// ──────────────────────────────────────────────────────────────────────────────
+// Featured-track resolution
+// ──────────────────────────────────────────────────────────────────────────────
+function isTrackEligibleAsFeatured(track) {
+    return !TERMINAL_TRACK_STATUSES.has(track.status);
+}
+function pickFeatured(tracks, featuredList) {
+    const bySlug = new Map(tracks.map((t) => [t.slug, t]));
+    for (const slug of featuredList) {
+        const track = bySlug.get(slug);
+        if (track && isTrackEligibleAsFeatured(track))
+            return track;
+    }
+    for (const track of tracks) {
+        if (isTrackEligibleAsFeatured(track))
+            return track;
+    }
+    return null;
+}
+// ──────────────────────────────────────────────────────────────────────────────
+// Currently block — assembly
+// ──────────────────────────────────────────────────────────────────────────────
+function nonTerminalTasks(track) {
+    return track.tasks.filter((t) => !TERMINAL_TASK_STATUSES.has(t.status));
+}
+function sortOldestUpdatedFirst(tasks) {
+    return tasks.slice().sort((a, b) => {
+        const aTime = a.updated ? new Date(a.updated).getTime() : Number.POSITIVE_INFINITY;
+        const bTime = b.updated ? new Date(b.updated).getTime() : Number.POSITIVE_INFINITY;
+        if (Number.isNaN(aTime) && Number.isNaN(bTime))
+            return 0;
+        if (Number.isNaN(aTime))
+            return 1;
+        if (Number.isNaN(bTime))
+            return -1;
+        return aTime - bTime;
+    });
+}
+function renderCurrently(deskRoot, now = new Date()) {
+    const trackSlugs = listSubdirs(deskRoot);
+    const tracks = [];
+    for (const slug of trackSlugs) {
+        const track = readTrack(deskRoot, slug);
+        if (track)
+            tracks.push(track);
+    }
+    if (tracks.length === 0) {
+        return "### currently\nthe desk is quiet today — no tracks yet. a good time to lay something down.";
+    }
+    const featuredList = readFeaturedList(deskRoot);
+    const featured = pickFeatured(tracks, featuredList);
+    if (!featured) {
+        return "### currently\nthe desk is quiet today — no tracks yet. a good time to lay something down.";
+    }
+    const featuredTasks = sortOldestUpdatedFirst(nonTerminalTasks(featured)).slice(0, TOP_N_TASKS_PER_FEATURED);
+    const lines = ["### currently"];
+    lines.push(`nearest the front of the desk: ${featured.slug}   (status: ${featured.status})`);
+    for (const task of featuredTasks) {
+        lines.push(`  → ${task.slug}   (status: ${task.status}, updated: ${formatRelative(task.updated, now)})`);
+    }
+    const otherActive = tracks
+        .filter((t) => t.slug !== featured.slug && !TERMINAL_TRACK_STATUSES.has(t.status))
+        .map((t) => t.slug);
+    if (otherActive.length > 0) {
+        lines.push(`also open on the desk: ${otherActive.join(", ")}`);
+    }
+    const nonTerminalCount = tracks.reduce((sum, t) => sum + nonTerminalTasks(t).length, 0);
+    lines.push(`tasks still open: ${nonTerminalCount}`);
+    return lines.join("\n");
+}
+// ──────────────────────────────────────────────────────────────────────────────
+// Public entry — every-turn synchronous read
+// ──────────────────────────────────────────────────────────────────────────────
+function deskSection(now = new Date()) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "prompt.desk_section_assembled",
+        component: "mind",
+        message: "assembling ## my desk section",
+        meta: { operation: "deskSection" },
+    });
+    const deskRoot = readDeskRoot();
+    if (!deskRoot) {
+        return `${STATIC_BODY}\n\n### currently\nthe desk is quiet today — no tracks yet. a good time to lay something down.`;
+    }
+    const currently = renderCurrently(deskRoot, now);
+    return `${STATIC_BODY}\n\n${currently}`;
+}

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,53 +33,26 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-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 session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
-const associative_recall_1 = require("./associative-recall");
+const note_search_1 = require("./note-search");
+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");
@@ -91,8 +64,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 };
@@ -115,7 +88,7 @@ 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();
@@ -178,13 +151,17 @@ function appendDailyFact(dailyDir, fact) {
     const dayPath = path.join(dailyDir, `${day}.jsonl`);
     fs.appendFileSync(dayPath, `${JSON.stringify(fact)}\n`, "utf8");
 }
-function appendFactsWithDedup(stores, incoming, options) {
-    const existing = readExistingFacts(stores.factsPath);
+function appendEntriesWithDedup(stores, incoming, options) {
+    const existing = readExistingEntries(stores.factsPath);
+    const cappedIncoming = incoming.map((fact) => ({
+        ...fact,
+        text: (0, session_events_1.capStructuredRecordString)(fact.text),
+    }));
     const all = [...existing];
     let added = 0;
     let skipped = 0;
     const semanticThreshold = options?.semanticThreshold;
-    for (const fact of incoming) {
+    for (const fact of cappedIncoming) {
         const duplicate = all.some((prior) => {
             if (overlapScore(prior.text, fact.text) > DEDUP_THRESHOLD)
                 return true;
@@ -192,7 +169,7 @@ function appendFactsWithDedup(stores, incoming, options) {
                 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 (0, note_search_1.cosineSimilarity)(fact.embedding, prior.embedding) > semanticThreshold;
             }
             return false;
         });
@@ -208,26 +185,20 @@ function appendFactsWithDedup(stores, incoming, options) {
     }
     (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 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 [];
@@ -240,8 +211,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),
             },
@@ -249,13 +220,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");
 }
-async function saveMemoryFact(options) {
+function readDiaryEntries(diaryRoot) {
+    return readExistingEntries(path.join(resolveDiaryRoot(diaryRoot), "facts.jsonl"));
+}
+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)(),
@@ -264,24 +241,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], { semanticThreshold: SEMANTIC_DEDUP_THRESHOLD });
+    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 },
         });
@@ -307,7 +299,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,
@@ -322,7 +314,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 },
     });
@@ -342,7 +334,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 [];
@@ -352,7 +344,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();
     }
@@ -366,7 +358,7 @@ async function searchMemoryFacts(query, facts, embeddingProvider) {
             .filter((fact) => fact.embedding.length === queryEmbedding.length)
             .map((fact) => ({
             fact,
-            score: (0, associative_recall_1.cosineSimilarity)(queryEmbedding, fact.embedding),
+            score: (0, note_search_1.cosineSimilarity)(queryEmbedding, fact.embedding),
         }))
             .filter((entry) => entry.score > 0)
             .sort((left, right) => right.score - left.score)
@@ -378,8 +370,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),
             },