@ouro.bot/cli 0.1.0-alpha.18 → 0.1.0-alpha.181

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

@@ -33,20 +33,22 @@ 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 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 {
@@ -78,7 +80,7 @@ class OpenAIEmbeddingProvider {
         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 +92,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 +116,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 +179,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,30 +209,12 @@ 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)
@@ -225,8 +227,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: "missing_openai_embeddings_key" },
         });
         return [];
@@ -239,8 +241,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 +250,25 @@ 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)();
+    const diaryPath = path.join(agentRoot, "diary");
+    if (fs.existsSync(diaryPath))
+        return diaryPath;
+    const legacyPath = path.join(agentRoot, "psyche", "memory");
+    if (fs.existsSync(legacyPath))
+        return legacyPath;
+    return diaryPath; // default to new path (will be created on first write)
+}
+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)(),
@@ -264,14 +278,14 @@ async function saveMemoryFact(options) {
         createdAt: (options.now ?? (() => new Date()))().toISOString(),
         embedding,
     };
-    return appendFactsWithDedup(stores, [fact]);
+    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 };
@@ -280,7 +294,7 @@ async function backfillEmbeddings(options) {
         (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 +320,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 +335,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 +355,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 [];
@@ -365,7 +379,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 +391,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),
             },

package/dist/mind/file-state.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileStateCache = exports.FileStateCache = void 0;
+exports.contentHash = contentHash;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const runtime_1 = require("../nerves/runtime");
+/** Compute sha256 hex hash of content */
+function contentHash(content) {
+    return (0, crypto_1.createHash)("sha256").update(content).digest("hex");
+}
+/**
+ * Session-scoped LRU cache tracking file reads.
+ * Stores content hashes (not full content) to limit memory.
+ * Keyed by absolute file path.
+ *
+ * Also maintains a separate snapshot list for future rewind support.
+ * Snapshots are indexed by content hash and linked to conversation messages.
+ */
+class FileStateCache {
+    entries;
+    maxSize;
+    snapshots = [];
+    maxSnapshots = 100;
+    constructor(maxSize = 50) {
+        this.entries = new Map();
+        this.maxSize = maxSize;
+    }
+    /**
+     * Record a file read. Computes content hash and stores metadata.
+     */
+    record(filePath, content, mtime, offset, limit, messageId) {
+        // If key already exists, delete it so re-insertion moves it to end (most recent)
+        if (this.entries.has(filePath)) {
+            this.entries.delete(filePath);
+        }
+        const hash = contentHash(content);
+        const fullRead = offset === undefined && limit === undefined;
+        this.entries.set(filePath, {
+            hash,
+            mtime,
+            offset: fullRead ? undefined : offset,
+            limit: fullRead ? undefined : limit,
+            fullRead,
+            recordedAt: Date.now(),
+            messageId,
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.file_state.record",
+            message: "recorded file state",
+            meta: { path: filePath, hash, fullRead },
+        });
+        // Evict LRU (first entry in Map iteration order) if over capacity
+        if (this.entries.size > this.maxSize) {
+            const firstKey = this.entries.keys().next().value;
+            this.entries.delete(firstKey);
+        }
+    }
+    /**
+     * Get the cached state for a file path. Also promotes it in LRU order.
+     */
+    get(filePath) {
+        const entry = this.entries.get(filePath);
+        if (entry === undefined)
+            return undefined;
+        // Promote to most-recently-used by re-inserting
+        this.entries.delete(filePath);
+        this.entries.set(filePath, entry);
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.file_state.get",
+            message: "retrieved file state",
+            meta: { path: filePath, hash: entry.hash },
+        });
+        return entry;
+    }
+    /**
+     * Check if a file has been modified since the last recorded read.
+     * Uses mtime as primary signal, content hash as fallback for cloud sync / touch scenarios.
+     * Returns { stale: false } if the path is not in cache or the file cannot be stat'd.
+     */
+    isStale(filePath) {
+        const entry = this.entries.get(filePath);
+        if (entry === undefined)
+            return { stale: false };
+        let currentMtime;
+        try {
+            currentMtime = (0, fs_1.statSync)(filePath).mtimeMs;
+        }
+        catch {
+            // File doesn't exist or can't be stat'd -- no basis for staleness
+            return { stale: false };
+        }
+        // Fast path: mtime unchanged means not stale
+        if (currentMtime === entry.mtime)
+            return { stale: false };
+        // mtime differs -- check content hash as fallback (handles touch / cloud sync)
+        try {
+            const currentContent = (0, fs_1.readFileSync)(filePath, "utf-8");
+            const currentHash = contentHash(currentContent);
+            if (currentHash === entry.hash)
+                return { stale: false };
+            (0, runtime_1.emitNervesEvent)({
+                component: "mind",
+                event: "mind.file_state.stale_detected",
+                message: "file staleness detected",
+                meta: { path: filePath, previousHash: entry.hash, currentHash },
+            });
+            return { stale: true, reason: `file modified since last read (mtime and content differ)` };
+        }
+        catch {
+            // Can't read file -- treat as not stale (file may have been deleted)
+            return { stale: false };
+        }
+    }
+    /**
+     * Create a pre-edit snapshot of the current cache state for a file.
+     * Snapshots are stored separately from the LRU cache for future rewind support.
+     * Returns undefined if the path is not in cache.
+     */
+    snapshot(filePath) {
+        const entry = this.entries.get(filePath);
+        if (entry === undefined)
+            return undefined;
+        const snap = {
+            filePath,
+            hash: entry.hash,
+            mtime: entry.mtime,
+            messageId: entry.messageId,
+            createdAt: Date.now(),
+        };
+        this.snapshots.push(snap);
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.file_state.snapshot_created",
+            message: "created file state snapshot",
+            meta: { path: filePath, hash: snap.hash },
+        });
+        // Evict oldest snapshots if over capacity
+        if (this.snapshots.length > this.maxSnapshots) {
+            this.snapshots = this.snapshots.slice(this.snapshots.length - this.maxSnapshots);
+        }
+        return snap;
+    }
+    /**
+     * Get all snapshots in creation order.
+     */
+    getSnapshots() {
+        return this.snapshots;
+    }
+    /**
+     * Look up a snapshot by content hash. Returns the first match.
+     */
+    lookupSnapshotByHash(hash) {
+        return this.snapshots.find(s => s.hash === hash);
+    }
+    /**
+     * Clear all snapshots.
+     */
+    clearSnapshots() {
+        this.snapshots = [];
+    }
+    /**
+     * Clear all cached entries (does not clear snapshots).
+     */
+    clear() {
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.file_state.clear",
+            message: "cleared file state cache",
+            meta: { entryCount: this.entries.size },
+        });
+        this.entries.clear();
+    }
+}
+exports.FileStateCache = FileStateCache;
+/** Session-scoped singleton instance used by tool handlers */
+exports.fileStateCache = new FileStateCache();

package/dist/mind/first-impressions.js

@@ -11,9 +11,22 @@ exports.ONBOARDING_TOKEN_THRESHOLD = 100_000;
 function isOnboarding(friend) {
     return (friend.totalTokens ?? 0) < exports.ONBOARDING_TOKEN_THRESHOLD;
 }
-function getFirstImpressions(friend) {
+function hasLiveContinuityPressure(state) {
+    if (!state)
+        return false;
+    if (typeof state.currentObligation === "string" && state.currentObligation.trim().length > 0)
+        return true;
+    if (state.mustResolveBeforeHandoff === true)
+        return true;
+    if (state.hasQueuedFollowUp === true)
+        return true;
+    return false;
+}
+function getFirstImpressions(friend, state) {
     if (!isOnboarding(friend))
         return "";
+    if (hasLiveContinuityPressure(state))
+        return "";
     (0, runtime_1.emitNervesEvent)({
         component: "mind",
         event: "mind.first_impressions",
@@ -37,7 +50,8 @@ function getFirstImpressions(friend) {
     lines.push("- what do they do outside of work that they care about?");
     lines.push("i don't ask all of these at once -- i weave them into conversation naturally, one or two at a time, and i genuinely follow up on what they share.");
     lines.push("i introduce what i can do -- i have tools, integrations, and skills that can help them. i mention these naturally as they become relevant.");
-    lines.push("if my friend hasn't asked me to do something specific, or i've already finished what they asked for, that's my cue to turn the tables -- i ask them questions about themselves, what they're into, what they need. no idle small talk; i'm on a mission to get to know them.");
+    lines.push("if we're already in motion on a task, thread, or follow-up, i do not reset with a generic opener like 'hiya' or 'what do ya need help with?'. i continue directly or ask the specific next question.");
+    lines.push("only when the conversation is genuinely fresh and idle, with no active ask or thread in flight, a light opener is okay.");
     lines.push("i save everything i learn immediately with save_friend_note -- names, roles, preferences, projects, anything. the bar is low: if i learned it, i save it.");
     return lines.join("\n");
 }

package/dist/mind/friends/channel.js

@@ -2,11 +2,26 @@
 // Channel capabilities -- hardcoded const map keyed by channel identifier.
 // Pure lookup, no I/O, cannot fail. Unknown channel gets minimal defaults.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.channelToFacing = channelToFacing;
 exports.getChannelCapabilities = getChannelCapabilities;
+exports.isRemoteChannel = isRemoteChannel;
+exports.getAlwaysOnSenseNames = getAlwaysOnSenseNames;
 const runtime_1 = require("../../nerves/runtime");
+const AGENT_FACING_CHANNELS = new Set(["inner", "mcp"]);
+function channelToFacing(channel) {
+    const facing = channel && AGENT_FACING_CHANNELS.has(channel) ? "agent" : "human";
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.facing_lookup",
+        message: "channel facing lookup",
+        meta: { channel: channel ?? "undefined", facing },
+    });
+    return facing;
+}
 const CHANNEL_CAPABILITIES = {
     cli: {
         channel: "cli",
+        senseType: "local",
         availableIntegrations: [],
         supportsMarkdown: false,
         supportsStreaming: true,
@@ -15,6 +30,7 @@ const CHANNEL_CAPABILITIES = {
     },
     teams: {
         channel: "teams",
+        senseType: "closed",
         availableIntegrations: ["ado", "graph", "github"],
         supportsMarkdown: true,
         supportsStreaming: true,
@@ -23,15 +39,35 @@ const CHANNEL_CAPABILITIES = {
     },
     bluebubbles: {
         channel: "bluebubbles",
+        senseType: "open",
         availableIntegrations: [],
         supportsMarkdown: false,
         supportsStreaming: false,
         supportsRichCards: false,
         maxMessageLength: Infinity,
     },
+    inner: {
+        channel: "inner",
+        senseType: "internal",
+        availableIntegrations: [],
+        supportsMarkdown: false,
+        supportsStreaming: true,
+        supportsRichCards: false,
+        maxMessageLength: Infinity,
+    },
+    mcp: {
+        channel: "mcp",
+        senseType: "local",
+        availableIntegrations: [],
+        supportsMarkdown: true,
+        supportsStreaming: false,
+        supportsRichCards: false,
+        maxMessageLength: Infinity,
+    },
 };
 const DEFAULT_CAPABILITIES = {
     channel: "cli",
+    senseType: "local",
     availableIntegrations: [],
     supportsMarkdown: false,
     supportsStreaming: false,
@@ -47,3 +83,23 @@ function getChannelCapabilities(channel) {
     });
     return CHANNEL_CAPABILITIES[channel] ?? DEFAULT_CAPABILITIES;
 }
+/** Whether the channel is remote (open or closed) vs local/internal. */
+function isRemoteChannel(capabilities) {
+    const senseType = capabilities?.senseType;
+    return senseType !== undefined && senseType !== "local" && senseType !== "internal";
+}
+/**
+ * Returns channel names whose senseType is "open" or "closed" -- i.e. channels
+ * that are always-on (daemon-managed) rather than interactive or internal.
+ */
+function getAlwaysOnSenseNames() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.always_on_lookup",
+        message: "always-on sense names lookup",
+        meta: {},
+    });
+    return Object.entries(CHANNEL_CAPABILITIES)
+        .filter(([, cap]) => cap.senseType === "open" || cap.senseType === "closed")
+        .map(([channel]) => channel);
+}