@ouro.bot/cli 0.1.0-alpha.657 → 0.1.0-alpha.658

package/dist/mind/record-paths.js

@@ -0,0 +1,312 @@
+"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.resolveDeskRecordPaths = resolveDeskRecordPaths;
+exports.migrateLegacyRecordStores = migrateLegacyRecordStores;
+exports.resolveRecordDiaryRoot = resolveRecordDiaryRoot;
+exports.resolveRecordNotesRoot = resolveRecordNotesRoot;
+exports.resetRecordStoreMigrationTrackingForTests = resetRecordStoreMigrationTrackingForTests;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const migratedAgentRoots = new Set();
+const DERIVED_JOURNAL_INDEX_FILES = new Set([".index.json"]);
+function nowIso() {
+    return new Date().toISOString();
+}
+function resolveDeskRecordPaths(agentRoot = (0, identity_1.getAgentRoot)()) {
+    const recordRoot = path.join(agentRoot, "desk", "_record");
+    const diaryRoot = path.join(recordRoot, "diary");
+    return {
+        recordRoot,
+        diaryRoot,
+        diaryDailyDir: path.join(diaryRoot, "daily"),
+        factsPath: path.join(diaryRoot, "facts.jsonl"),
+        entitiesPath: path.join(diaryRoot, "entities.json"),
+        notesRoot: path.join(recordRoot, "notes"),
+        migrationReportPath: path.join(recordRoot, "migration-report.jsonl"),
+    };
+}
+function appendMigrationReport(paths, entry) {
+    fs.mkdirSync(paths.recordRoot, { recursive: true });
+    fs.appendFileSync(paths.migrationReportPath, `${JSON.stringify({ schemaVersion: 1, recordedAt: nowIso(), ...entry })}\n`, "utf-8");
+}
+function ensureRecordScaffold(paths) {
+    fs.mkdirSync(paths.diaryDailyDir, { recursive: true });
+    fs.mkdirSync(paths.notesRoot, { recursive: true });
+    if (!fs.existsSync(paths.factsPath))
+        fs.writeFileSync(paths.factsPath, "", "utf-8");
+    if (!fs.existsSync(paths.entitiesPath))
+        fs.writeFileSync(paths.entitiesPath, "{}\n", "utf-8");
+}
+function uniquePathForCollision(destination) {
+    const dir = path.dirname(destination);
+    const ext = path.extname(destination);
+    const base = path.basename(destination, ext);
+    for (let index = 1; index < 10_000; index += 1) {
+        const candidate = path.join(dir, `${base}.migrated-${index}${ext}`);
+        if (!fs.existsSync(candidate))
+            return candidate;
+    }
+    /* v8 ignore next -- defensive exhaustion guard; normal collision allocation is covered @preserve */
+    throw new Error(`could not allocate migration collision path for ${destination}`);
+}
+function mergeJsonlFile(source, destination) {
+    const sourceText = fs.readFileSync(source, "utf-8");
+    if (!fs.existsSync(destination)) {
+        fs.writeFileSync(destination, sourceText, "utf-8");
+        return "copied";
+    }
+    const destinationText = fs.readFileSync(destination, "utf-8");
+    const existing = new Set(destinationText.split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
+    const additions = sourceText.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !existing.has(line));
+    if (additions.length === 0)
+        return "kept-destination";
+    const prefix = destinationText.length > 0 && !destinationText.endsWith("\n") ? "\n" : "";
+    fs.appendFileSync(destination, `${prefix}${additions.join("\n")}\n`, "utf-8");
+    return "merged";
+}
+function readJsonObject(filePath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function mergeEntitiesFile(source, destination) {
+    if (!fs.existsSync(destination)) {
+        fs.copyFileSync(source, destination);
+        return "copied";
+    }
+    const sourceObject = readJsonObject(source);
+    const destinationObject = readJsonObject(destination);
+    if (!sourceObject || !destinationObject)
+        return copyLosslessFile(source, destination) === destination ? "merged" : "copied";
+    const conflicts = {};
+    const merged = { ...destinationObject };
+    for (const [key, value] of Object.entries(sourceObject)) {
+        if (!(key in merged)) {
+            merged[key] = value;
+            continue;
+        }
+        if (JSON.stringify(merged[key]) !== JSON.stringify(value)) {
+            conflicts[key] = value;
+        }
+    }
+    fs.writeFileSync(destination, `${JSON.stringify(merged, null, 2)}\n`, "utf-8");
+    if (Object.keys(conflicts).length > 0) {
+        const conflictPath = uniquePathForCollision(path.join(path.dirname(destination), "entities.migration-conflicts.json"));
+        fs.writeFileSync(conflictPath, `${JSON.stringify(conflicts, null, 2)}\n`, "utf-8");
+    }
+    return Object.keys(sourceObject).length > 0 ? "merged" : "kept-destination";
+}
+function copyLosslessFile(source, destination) {
+    if (!fs.existsSync(destination)) {
+        fs.copyFileSync(source, destination);
+        return destination;
+    }
+    const sourceContent = fs.readFileSync(source);
+    const destinationContent = fs.readFileSync(destination);
+    if (sourceContent.equals(destinationContent))
+        return destination;
+    if (sourceContent.length > 0 && destinationContent.length === 0) {
+        fs.copyFileSync(source, destination);
+        return destination;
+    }
+    const collisionPath = uniquePathForCollision(destination);
+    fs.copyFileSync(source, collisionPath);
+    return collisionPath;
+}
+function mergeRecordFile(source, destination) {
+    fs.mkdirSync(path.dirname(destination), { recursive: true });
+    const basename = path.basename(destination);
+    if (basename === "facts.jsonl" || destination.endsWith(".jsonl")) {
+        mergeJsonlFile(source, destination);
+        return;
+    }
+    if (basename === "entities.json") {
+        mergeEntitiesFile(source, destination);
+        return;
+    }
+    copyLosslessFile(source, destination);
+}
+function mergeDirectory(source, destination) {
+    fs.mkdirSync(destination, { recursive: true });
+    for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+        const sourcePath = path.join(source, entry.name);
+        const destinationPath = path.join(destination, entry.name);
+        if (entry.isDirectory()) {
+            mergeDirectory(sourcePath, destinationPath);
+            continue;
+        }
+        mergeRecordFile(sourcePath, destinationPath);
+    }
+}
+function removeDirectoryTree(root) {
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+        const entryPath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            removeDirectoryTree(entryPath);
+            continue;
+        }
+        fs.rmSync(entryPath, { force: true });
+    }
+    fs.rmdirSync(root);
+}
+function moveOrMergeDirectory(paths, source, destination, reason) {
+    if (!fs.existsSync(source))
+        return;
+    fs.mkdirSync(path.dirname(destination), { recursive: true });
+    mergeDirectory(source, destination);
+    removeDirectoryTree(source);
+    appendMigrationReport(paths, { action: "merged", source, destination, reason });
+}
+function quarantineJournalFile(paths, sourcePath, relativePath, reason) {
+    const destinationPath = path.join(paths.recordRoot, "migration-quarantine", "journal", relativePath);
+    fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+    copyLosslessFile(sourcePath, destinationPath);
+    appendMigrationReport(paths, { action: "quarantined", source: sourcePath, destination: destinationPath, reason });
+}
+function slugFromJournalFile(filename) {
+    const base = filename.replace(/\.[^.]+$/, "");
+    const slug = base
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80)
+        .replace(/-+$/g, "");
+    return slug || "entry";
+}
+function migrateJournalEntry(paths, sourcePath, relativePath) {
+    const entryName = path.basename(sourcePath);
+    if (DERIVED_JOURNAL_INDEX_FILES.has(entryName)) {
+        appendMigrationReport(paths, {
+            action: "dropped",
+            source: sourcePath,
+            reason: "derived journal index is obsolete after Desk record migration",
+        });
+        return;
+    }
+    const extension = path.extname(entryName).toLowerCase();
+    if (extension !== ".md" && extension !== ".txt") {
+        quarantineJournalFile(paths, sourcePath, relativePath, "non-text journal scratch quarantined after Desk record migration");
+        return;
+    }
+    const relativeSlug = slugFromJournalFile(relativePath.split(path.sep).join("-"));
+    const destinationPath = copyLosslessFile(sourcePath, path.join(paths.notesRoot, `journal-${relativeSlug}.md`));
+    appendMigrationReport(paths, {
+        action: "moved",
+        source: sourcePath,
+        destination: destinationPath,
+        reason: "journal text migrated into Desk record notes",
+    });
+}
+function migrateJournalTree(paths, root, current) {
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+        const sourcePath = path.join(current, entry.name);
+        if (entry.isDirectory()) {
+            migrateJournalTree(paths, root, sourcePath);
+            continue;
+        }
+        migrateJournalEntry(paths, sourcePath, path.relative(root, sourcePath));
+    }
+}
+function migrateJournalIntoNotes(paths, agentRoot) {
+    const journalRoot = path.join(agentRoot, "journal");
+    if (!fs.existsSync(journalRoot))
+        return;
+    fs.mkdirSync(paths.notesRoot, { recursive: true });
+    migrateJournalTree(paths, journalRoot, journalRoot);
+    removeDirectoryTree(journalRoot);
+    appendMigrationReport(paths, {
+        action: "removed",
+        source: journalRoot,
+        reason: "top-level journal is no longer an active substrate",
+    });
+}
+function migrateLegacyRecordStores(agentRoot = (0, identity_1.getAgentRoot)()) {
+    const paths = resolveDeskRecordPaths(agentRoot);
+    const legacyRoots = [
+        path.join(agentRoot, "psyche", "mem" + "ory"),
+        path.join(agentRoot, "diary"),
+        path.join(agentRoot, "notes"),
+        path.join(agentRoot, "journal"),
+    ];
+    if (migratedAgentRoots.has(agentRoot) && !legacyRoots.some((root) => fs.existsSync(root))) {
+        ensureRecordScaffold(paths);
+        return paths;
+    }
+    migratedAgentRoots.add(agentRoot);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.record_store_migration_start",
+        message: "record store migration started",
+        meta: { agentRoot, recordRoot: paths.recordRoot },
+    });
+    ensureRecordScaffold(paths);
+    moveOrMergeDirectory(paths, path.join(agentRoot, "psyche", "mem" + "ory"), paths.diaryRoot, "legacy pre-diary fact store moved into Desk record diary");
+    moveOrMergeDirectory(paths, path.join(agentRoot, "diary"), paths.diaryRoot, "top-level diary moved into Desk record diary");
+    moveOrMergeDirectory(paths, path.join(agentRoot, "notes"), paths.notesRoot, "top-level notes moved into Desk record notes");
+    const staleNotesIndex = path.join(paths.notesRoot, ".index.json");
+    if (fs.existsSync(staleNotesIndex)) {
+        fs.rmSync(staleNotesIndex, { force: true });
+        appendMigrationReport(paths, {
+            action: "removed",
+            source: staleNotesIndex,
+            reason: "canonical notes index stores file paths and must be rebuilt after migration",
+        });
+    }
+    migrateJournalIntoNotes(paths, agentRoot);
+    ensureRecordScaffold(paths);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.record_store_migration_end",
+        message: "record store migration completed",
+        meta: { agentRoot, recordRoot: paths.recordRoot },
+    });
+    return paths;
+}
+function resolveRecordDiaryRoot(agentRoot = (0, identity_1.getAgentRoot)()) {
+    return migrateLegacyRecordStores(agentRoot).diaryRoot;
+}
+function resolveRecordNotesRoot(agentRoot = (0, identity_1.getAgentRoot)()) {
+    return migrateLegacyRecordStores(agentRoot).notesRoot;
+}
+function resetRecordStoreMigrationTrackingForTests() {
+    migratedAgentRoots.clear();
+}

package/dist/repertoire/bundle-templates.js

@@ -14,7 +14,7 @@
  *   - Build artifacts (rare in bundles, but possible).
  *
  * It DOES NOT handle PII. The bundle is inherently full of PII — `friends/`,
- * `diary/`, `journal/`, `psyche/`, `arc/`, `facts/`, `family/`, `travel/`
+ * `desk/_record/`, `psyche/`, `arc/`, `facts/`, `family/`, `travel/`
  * etc. That's the point of the bundle; blocking those via .gitignore would
  * defeat the purpose.
  *
@@ -54,19 +54,18 @@ node_modules/
 dist/
 `;
 /**
- * PII-sensitive top-level directories. Enumerated here so `bundle_first_push_review`
+ * PII-sensitive bundle directories. Enumerated here so `bundle_first_push_review`
  * can categorize and count. Adding a new PII bucket to the bundle means adding
  * it here so the first-push warning includes it.
  */
 exports.PII_BUNDLE_DIRECTORIES = [
     "friends",
-    "diary",
-    "journal",
+    "desk/_record/diary",
+    "desk/_record/notes",
     "psyche",
     "arc",
     "facts",
     "family",
     "travel",
-    "notes",
     "sessions",
 ];

package/dist/repertoire/tools-bundle.js

@@ -944,7 +944,7 @@ exports.bundleToolDefinitions = [
             type: "function",
             function: {
                 name: "bundle_first_push_review",
-                description: "Review my bundle for PII exposure before the first push to a new remote. Enumerates PII-bearing directories (friends, diary, journal, etc.) with per-directory counts, probes the remote URL for GitHub public/private visibility, and returns a first-person warning text I must show the human plus a confirmationToken I must pass to bundle_push on first push. Required before the first push to any new remote.",
+                description: "Review my bundle for PII exposure before the first push to a new remote. Enumerates PII-bearing directories (friends, Desk record, Arc, etc.) with per-directory counts, probes the remote URL for GitHub public/private visibility, and returns a first-person warning text I must show the human plus a confirmationToken I must pass to bundle_push on first push. Required before the first push to any new remote.",
                 parameters: { type: "object", properties: {} },
             },
         },

package/dist/repertoire/tools-evolution.js

@@ -8,7 +8,7 @@ const runtime_1 = require("../nerves/runtime");
 const EVOLUTION_ACTIONS = new Set([
     "create_case",
     "add_evidence",
-    "write_journal",
+    "write_record",
     "write_desk",
     "write_diary",
     "spawn_coding",
@@ -46,7 +46,7 @@ const EVIDENCE_KINDS = new Set([
     "release",
     "installed_runtime",
     "diary_entry",
-    "journal_file",
+    "desk_record_note",
     "skill_file",
     "sense_artifact",
     "hosted_audit",
@@ -54,7 +54,7 @@ const EVIDENCE_KINDS = new Set([
     "external_doc",
 ]);
 const REDACTIONS = new Set(["none", "summary", "private_ref", "secret_ref"]);
-const DECISIONS = new Set(["ignore", "defer", "journal", "ask", "delegate", "act", "abandon"]);
+const DECISIONS = new Set(["ignore", "defer", "record", "ask", "delegate", "act", "abandon"]);
 const VERIFICATION_STATUSES = new Set(["not-verified", "partial", "passed", "failed"]);
 const RATIFICATION_DESTINATIONS = new Set([
     "code",
@@ -63,7 +63,7 @@ const RATIFICATION_DESTINATIONS = new Set([
     "desk_lesson",
     "desk_task",
     "diary",
-    "journal",
+    "desk_record",
     "habit",
     "policy",
     "agent_config",

package/dist/repertoire/tools-notes.js

@@ -1,45 +1,9 @@
 "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.notesToolDefinitions = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const skills_1 = require("./skills");
 const config_1 = require("../heart/config");
-const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
 const diary_1 = require("../mind/diary");
 const provenance_trust_1 = require("../mind/provenance-trust");
@@ -170,8 +134,8 @@ exports.notesToolDefinitions = [
         tool: {
             type: "function",
             function: {
-                name: "search_notes",
-                description: "Search my diary and journal for facts, thoughts, and working notes matching a query. Uses semantic similarity -- phrasing matters. Try different angles if the first query doesn't find what you're looking for. Search written notes before asking the human something the notes may already answer.",
+                name: "search_facts",
+                description: "Search my Desk record diary facts matching a query. Uses semantic similarity -- phrasing matters. Try different angles if the first query doesn't find what you're looking for. Search written facts before asking the human something the record may already answer.",
                 parameters: {
                     type: "object",
                     properties: { query: { type: "string" } },
@@ -185,7 +149,6 @@ exports.notesToolDefinitions = [
                 if (!query)
                     return "query is required";
                 const resultLines = [];
-                // Search diary entries
                 const hits = await (0, diary_1.searchDiaryEntries)(query, (0, diary_1.readDiaryEntries)());
                 for (const fact of hits) {
                     let meta = `source=${fact.source}, createdAt=${fact.createdAt}`;
@@ -200,35 +163,52 @@ exports.notesToolDefinitions = [
                     const tag = (0, provenance_trust_1.classifyProvenanceTrust)(fact.provenance) === "external" ? "diary/external" : "diary";
                     resultLines.push(`[${tag}] ${fact.text} (${meta})`);
                 }
-                // Search journal index
-                const agentRoot = (0, identity_1.getAgentRoot)();
-                const journalIndexPath = path.join(agentRoot, "journal", ".index.json");
-                try {
-                    const raw = fs.readFileSync(journalIndexPath, "utf8");
-                    const journalEntries = JSON.parse(raw);
-                    if (Array.isArray(journalEntries) && journalEntries.length > 0) {
-                        // Substring match on preview and filename
-                        const lowerQuery = query.toLowerCase();
-                        for (const entry of journalEntries) {
-                            /* v8 ignore next 4 -- both sides tested (filename-only match in search_notes-journal.test.ts); v8 misreports || short-circuit @preserve */
-                            if (entry.preview.toLowerCase().includes(lowerQuery) ||
-                                entry.filename.toLowerCase().includes(lowerQuery)) {
-                                resultLines.push(`[journal] ${entry.filename}: ${entry.preview}`);
-                            }
-                        }
-                    }
-                }
-                catch {
-                    // No journal index or malformed — skip journal search
-                }
                 return resultLines.join("\n");
             }
             catch (e) {
-                return `error: ${e instanceof Error ? e.message : String(e)}`;
+                return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
             }
         },
         summaryKeys: ["query"],
     },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "consult_diary",
+                description: "Inspect my Desk record diary facts. With a query, searches semantically. Without a query, returns the most recent facts. Use this for direct record inspection before asking someone to restate something already written down.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string" },
+                        limit: { type: "string" },
+                    },
+                },
+            },
+        },
+        handler: async (a) => {
+            try {
+                const limitRaw = a.limit ? Number.parseInt(String(a.limit), 10) : 10;
+                const limit = Number.isFinite(limitRaw) ? Math.min(50, Math.max(1, limitRaw)) : 10;
+                const query = typeof a.query === "string" ? a.query.trim() : "";
+                const facts = (0, diary_1.readDiaryEntries)();
+                const matches = query ? await (0, diary_1.searchDiaryEntries)(query, facts) : [...facts].sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+                const items = matches.slice(0, limit).map((fact) => ({
+                    id: fact.id,
+                    text: fact.text,
+                    source: fact.source,
+                    createdAt: fact.createdAt,
+                    ...(fact.about ? { about: fact.about } : {}),
+                    ...(fact.provenance ? { provenance: fact.provenance } : {}),
+                }));
+                return JSON.stringify({ items });
+            }
+            catch (e) {
+                return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
+            }
+        },
+        summaryKeys: ["query", "limit"],
+    },
     {
         tool: {
             type: "function",
@@ -275,7 +255,7 @@ exports.notesToolDefinitions = [
             return `saved diary entry (added=${result.added}, skipped=${result.skipped})`;
         },
         summaryKeys: ["entry", "about"],
-        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "writes diary memory" },
+        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "writes Desk record diary fact" },
     },
     {
         tool: {

package/dist/repertoire/tools-record.js

@@ -37,9 +37,10 @@ exports.recordToolDefinitions = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const session_events_1 = require("../heart/session-events");
-const identity_1 = require("../heart/identity");
 const embedding_provider_1 = require("../mind/embedding-provider");
 const note_search_1 = require("../mind/note-search");
+const record_paths_1 = require("../mind/record-paths");
+const types_1 = require("../mind/friends/types");
 const runtime_1 = require("../nerves/runtime");
 const NOTES_INDEX_VERSION = 1;
 const NOTE_SLUG_MAX_CHARS = 40;
@@ -54,6 +55,12 @@ function hasSelfTrust(ctx) {
     const friend = ctx?.context?.friend;
     return !friend || friend.id === "self";
 }
+function hasRecordReadTrust(ctx) {
+    if (hasSelfTrust(ctx))
+        return true;
+    const friend = ctx?.context?.friend;
+    return Boolean(friend) && (0, types_1.isTrustedLevel)(friend?.trustLevel);
+}
 function normalizeTags(value) {
     if (value === undefined || value === null)
         return undefined;
@@ -224,8 +231,6 @@ function indexFreshForRecords(index, records) {
     const recordsByFilename = new Map(records.map((record) => [record.filename, record]));
     const seenFilenames = new Set();
     for (const entry of index.entries) {
-        if (seenFilenames.has(entry.filename))
-            return false;
         const record = recordsByFilename.get(entry.filename);
         if (!record || !entryMatchesRecord(entry, record))
             return false;
@@ -331,7 +336,7 @@ exports.recordToolDefinitions = [
             type: "function",
             function: {
                 name: "note",
-                description: "Write a durable self note as canonical markdown in my notes folder. Only available to my self/inner context, not external callers.",
+                description: "Write a durable self note as canonical markdown in my Desk record notes. Only available to my self/inner context, not external callers.",
                 parameters: {
                     type: "object",
                     properties: {
@@ -359,9 +364,9 @@ exports.recordToolDefinitions = [
             const createdAt = new Date().toISOString();
             const date = createdAt.slice(0, 10);
             const tags = normalizeTags(rawArgs.tags);
-            const notesDir = path.join((0, identity_1.getAgentRoot)(), "notes");
-            const indexPath = path.join(notesDir, ".index.json");
             try {
+                const notesDir = (0, record_paths_1.resolveRecordNotesRoot)();
+                const indexPath = path.join(notesDir, ".index.json");
                 fs.mkdirSync(notesDir, { recursive: true });
                 const savedPath = ensureUniquePath(notesDir, date, slugForContent(content));
                 fs.writeFileSync(savedPath, renderNote(createdAt, cappedContent, tags), "utf8");
@@ -386,14 +391,14 @@ exports.recordToolDefinitions = [
             }
         },
         summaryKeys: ["content", "tags"],
-        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "writes canonical note memory" },
+        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "writes canonical Desk record note" },
     },
     {
         tool: {
             type: "function",
             function: {
                 name: "consult_notes",
-                description: "Search my canonical markdown notes semantically using the notes-native index. Only available to my self/inner context, not external callers.",
+                description: "Search my canonical markdown Desk record notes semantically using the notes-native index. Read-only orientation lookup for trusted callers.",
                 parameters: {
                     type: "object",
                     properties: {
@@ -407,13 +412,13 @@ exports.recordToolDefinitions = [
             },
         },
         handler: async (args, ctx) => {
-            if (!hasSelfTrust(ctx))
-                return "error: consult_notes requires self trust and cannot be used from an external caller context.";
+            if (!hasRecordReadTrust(ctx))
+                return "error: consult_notes requires trusted record-read access.";
             const rawArgs = args;
             const query = typeof rawArgs.query === "string" ? rawArgs.query.trim() : "";
             if (!query)
                 return JSON.stringify({ items: [] });
-            const notesDir = path.join((0, identity_1.getAgentRoot)(), "notes");
+            const notesDir = (0, record_paths_1.resolveRecordNotesRoot)();
             const indexPath = path.join(notesDir, ".index.json");
             const records = listCanonicalNotes(notesDir);
             if (records.length === 0)

package/dist/repertoire/tools-session.js

@@ -361,7 +361,7 @@ exports.sessionToolDefinitions = [
             type: "function",
             function: {
                 name: "query_session",
-                description: "inspect another session. use transcript for recent context or status for self/inner progress. deprecated search invocations should use search_notes or consult_notes instead.",
+                description: "inspect another session. use transcript for recent context or status for self/inner progress. deprecated search invocations should use search_facts, consult_diary, or consult_notes instead.",
                 parameters: {
                     type: "object",
                     properties: {
@@ -372,9 +372,9 @@ exports.sessionToolDefinitions = [
                         mode: {
                             type: "string",
                             enum: ["transcript", "status", "search"],
-                            description: "transcript (default), lightweight status for self/inner checks, or deprecated search; use search_notes or consult_notes instead",
+                            description: "transcript (default), lightweight status for self/inner checks, or deprecated search; use search_facts, consult_diary, or consult_notes instead",
                         },
-                        query: { type: "string", description: "deprecated when mode=search; use search_notes or consult_notes instead" },
+                        query: { type: "string", description: "deprecated when mode=search; use search_facts, consult_diary, or consult_notes instead" },
                     },
                     required: ["friendId", "channel"],
                 },
@@ -405,7 +405,7 @@ exports.sessionToolDefinitions = [
             if (mode === "search") {
                 return JSON.stringify({
                     kind: "deprecated",
-                    message: "query_session mode=search is no longer available; use search_notes or consult_notes instead.",
+                    message: "query_session mode=search is no longer available; use search_facts, consult_diary, or consult_notes instead.",
                     removalCycle: "alpha.616",
                 });
             }

package/dist/repertoire/tools.js

@@ -203,7 +203,7 @@ function riskProfileForTool(def, name, args) {
     return def.riskProfile ?? { mutates: "none", risk: "low" };
 }
 function orientationHoldMessage(name, profile, reason) {
-    return `orientation hold: ${reason} Available: orientation_get plus read-only inspection tools like trip_status, query_session, read_config, read_file, grep, and search_notes. Resolve the referent/correction, then retry ${name} if the action is still correct. Blocked ${mutationKindsFor(profile).join(", ")}. ${profile.reason}.`;
+    return `orientation hold: ${reason} Available: orientation_get plus read-only inspection tools like trip_status, query_session, read_config, read_file, grep, search_facts, consult_diary, and consult_notes. Resolve the referent/correction, then retry ${name} if the action is still correct. Blocked ${mutationKindsFor(profile).join(", ")}. ${profile.reason}.`;
 }
 function mutationKindsFor(profile) {
     const mutates = profile.mutates;