@ouro.bot/cli 0.1.0-alpha.27 → 0.1.0-alpha.271

package/dist/mind/associative-recall.js

@@ -35,59 +35,42 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cosineSimilarity = cosineSimilarity;
 exports.recallFactsForQuery = recallFactsForQuery;
+exports.searchJournalIndex = searchJournalIndex;
 exports.injectAssociativeRecall = injectAssociativeRecall;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const config_1 = require("../heart/config");
-const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
-const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
+const diary_1 = require("./diary");
+const embedding_provider_1 = require("./embedding-provider");
 const DEFAULT_MIN_SCORE = 0.5;
 const DEFAULT_TOP_K = 3;
-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 createDefaultProvider() {
-    const apiKey = (0, config_1.getOpenAIEmbeddingsApiKey)();
-    if (!apiKey) {
+    const provider = (0, embedding_provider_1.createDefaultEmbeddingProvider)();
+    if (!provider) {
         throw new Error("openaiEmbeddingsApiKey not configured");
     }
-    return new OpenAIEmbeddingProvider(apiKey);
+    return provider;
 }
-function readFacts(memoryRoot) {
-    const factsPath = path.join(memoryRoot, "facts.jsonl");
+function readFacts(diaryRoot) {
+    const factsPath = path.join(diaryRoot, "facts.jsonl");
     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")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            facts.push(JSON.parse(trimmed));
+        }
+        catch {
+            // Skip corrupt lines (e.g. partial write from a crash).
+        }
+    }
+    return facts;
 }
 function getLatestUserText(messages) {
     for (let i = messages.length - 1; i >= 0; i--) {
@@ -133,6 +116,40 @@ async function recallFactsForQuery(query, facts, provider, options) {
         .sort((left, right) => right.score - left.score)
         .slice(0, topK);
 }
+function readJournalIndex(journalDir) {
+    const indexPath = path.join(journalDir, ".index.json");
+    try {
+        const raw = fs.readFileSync(indexPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed;
+    }
+    catch {
+        return [];
+    }
+}
+function searchJournalIndex(queryEmbedding, entries, options) {
+    const minScore = options?.minScore ?? DEFAULT_MIN_SCORE;
+    const topK = options?.topK ?? DEFAULT_TOP_K;
+    return entries
+        .filter((entry) => Array.isArray(entry.embedding) && entry.embedding.length > 0)
+        .map((entry) => ({
+        filename: entry.filename,
+        preview: entry.preview,
+        score: cosineSimilarity(queryEmbedding, entry.embedding),
+    }))
+        .filter((entry) => entry.score >= minScore)
+        .sort((left, right) => right.score - left.score)
+        .slice(0, topK);
+}
+function resolveJournalDir(diaryRoot, explicitJournalDir) {
+    if (explicitJournalDir)
+        return explicitJournalDir;
+    // journal/ is a sibling of diary/ at the agent root level
+    const agentRoot = path.dirname(diaryRoot);
+    return path.join(agentRoot, "journal");
+}
 async function injectAssociativeRecall(messages, options) {
     try {
         if (messages[0]?.role !== "system" || typeof messages[0].content !== "string")
@@ -140,37 +157,80 @@ async function injectAssociativeRecall(messages, options) {
         const query = getLatestUserText(messages);
         if (!query)
             return;
-        const memoryRoot = options?.memoryRoot ?? path.join((0, identity_1.getAgentRoot)(), "psyche", "memory");
-        const facts = readFacts(memoryRoot);
-        if (facts.length === 0)
+        const diaryRoot = options?.diaryRoot ?? (0, diary_1.resolveDiaryRoot)();
+        const facts = readFacts(diaryRoot);
+        const journalDir = resolveJournalDir(diaryRoot, options?.journalDir);
+        const journalEntries = readJournalIndex(journalDir);
+        if (facts.length === 0 && journalEntries.length === 0)
             return;
-        let recalled;
-        try {
-            const provider = options?.provider ?? createDefaultProvider();
-            recalled = await recallFactsForQuery(query, facts, provider, options);
-        }
-        catch {
-            // Embeddings unavailable — fall back to substring matching
-            const lowerQuery = query.toLowerCase();
-            const topK = options?.topK ?? DEFAULT_TOP_K;
-            recalled = facts
-                .filter((fact) => fact.text.toLowerCase().includes(lowerQuery))
-                .slice(0, topK)
-                .map((fact) => ({ ...fact, score: 1 }));
-            if (recalled.length > 0) {
-                (0, runtime_1.emitNervesEvent)({
-                    level: "warn",
-                    component: "mind",
-                    event: "mind.associative_recall_fallback",
-                    message: "embeddings unavailable, used substring fallback",
-                    meta: { matchCount: recalled.length },
+        // Build combined result lines tagged by source
+        const resultLines = [];
+        let queryEmbedding;
+        // Search diary entries
+        if (facts.length > 0) {
+            let recalled;
+            try {
+                const provider = options?.provider ?? createDefaultProvider();
+                recalled = await recallFactsForQuery(query, facts, provider, options);
+                // Compute query embedding for journal search while provider is available
+                if (journalEntries.length > 0) {
+                    const [qe] = await provider.embed([query.trim()]);
+                    queryEmbedding = qe;
+                }
+            }
+            catch {
+                // Embeddings unavailable — fall back to substring matching
+                const lowerQuery = query.toLowerCase();
+                const topK = options?.topK ?? DEFAULT_TOP_K;
+                recalled = facts
+                    .filter((fact) => fact.text.toLowerCase().includes(lowerQuery))
+                    .slice(0, topK)
+                    .map((fact) => ({ ...fact, score: 1 }));
+                if (recalled.length > 0) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "mind",
+                        event: "mind.associative_recall_fallback",
+                        message: "embeddings unavailable, used substring fallback",
+                        meta: { matchCount: recalled.length },
+                    });
+                }
+            }
+            for (const fact of recalled) {
+                resultLines.push({
+                    text: `[diary] ${fact.text} [score=${fact.score.toFixed(3)} source=${fact.source}]`,
+                    score: fact.score,
                 });
             }
         }
-        if (recalled.length === 0)
+        // Search journal entries (works whether diary had results or not)
+        if (journalEntries.length > 0) {
+            try {
+                if (!queryEmbedding) {
+                    const provider = options?.provider ?? createDefaultProvider();
+                    const [qe] = await provider.embed([query.trim()]);
+                    queryEmbedding = qe;
+                }
+                if (queryEmbedding) {
+                    const journalResults = searchJournalIndex(queryEmbedding, journalEntries, options);
+                    for (const entry of journalResults) {
+                        resultLines.push({
+                            text: `[journal] ${entry.filename}: ${entry.preview} [score=${entry.score.toFixed(3)}]`,
+                            score: entry.score,
+                        });
+                    }
+                }
+            }
+            catch {
+                // Embeddings unavailable — no journal fallback
+            }
+        }
+        if (resultLines.length === 0)
             return;
-        const recallSection = recalled
-            .map((fact, index) => `${index + 1}. ${fact.text} [score=${fact.score.toFixed(3)} source=${fact.source}]`)
+        // Sort all results by score descending
+        resultLines.sort((left, right) => right.score - left.score);
+        const recallSection = resultLines
+            .map((entry, index) => `${index + 1}. ${entry.text}`)
             .join("\n");
         messages[0] = {
             role: "system",
@@ -180,7 +240,7 @@ async function injectAssociativeRecall(messages, options) {
             component: "mind",
             event: "mind.associative_recall",
             message: "associative recall injected",
-            meta: { count: recalled.length },
+            meta: { count: resultLines.length },
         });
     }
     catch (error) {
@@ -190,7 +250,7 @@ async function injectAssociativeRecall(messages, options) {
             event: "mind.associative_recall_error",
             message: "associative recall failed",
             meta: {
-                reason: error instanceof Error ? error.message : String(error),
+                reason: error instanceof Error ? error.message : /* v8 ignore start -- defensive: non-Error catch branch @preserve */ String(error) /* v8 ignore stop */,
             },
         });
     }

package/dist/mind/bundle-manifest.js

@@ -52,8 +52,15 @@ exports.CANONICAL_BUNDLE_MANIFEST = [
     { path: "psyche/LORE.md", kind: "file" },
     { path: "psyche/TACIT.md", kind: "file" },
     { path: "psyche/ASPIRATIONS.md", kind: "file" },
-    { path: "psyche/memory", kind: "dir" },
+    { path: "arc", kind: "dir" },
+    { path: "arc/episodes", kind: "dir" },
+    { path: "arc/obligations", kind: "dir" },
+    { path: "arc/cares", kind: "dir" },
+    { path: "arc/intentions", kind: "dir" },
+    { path: "diary", kind: "dir" },
+    { path: "journal", kind: "dir" },
     { path: "friends", kind: "dir" },
+    { path: "state", kind: "dir" },
     { path: "tasks", kind: "dir" },
     { path: "skills", kind: "dir" },
     { path: "senses", kind: "dir" },

package/dist/mind/context.js

@@ -36,7 +36,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.trimMessages = trimMessages;
 exports.validateSessionMessages = validateSessionMessages;
 exports.repairSessionMessages = repairSessionMessages;
+exports.migrateToolNames = migrateToolNames;
 exports.saveSession = saveSession;
+exports.appendSyntheticAssistantMessage = appendSyntheticAssistantMessage;
 exports.loadSession = loadSession;
 exports.postTurn = postTurn;
 exports.deleteSession = deleteSession;
@@ -50,17 +52,17 @@ function buildTrimmableBlocks(messages) {
     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 +80,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 +134,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 +148,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)({
@@ -219,7 +221,7 @@ function repairSessionMessages(messages) {
         result.push(msg);
     }
     (0, runtime_1.emitNervesEvent)({
-        level: "warn",
+        level: "info",
         event: "mind.session_invariant_repair",
         component: "mind",
         message: "repaired session invariant violations",
@@ -227,11 +229,79 @@ function repairSessionMessages(messages) {
     });
     return result;
 }
-function saveSession(filePath, messages, lastUsage) {
+function stripOrphanedToolResults(messages) {
+    const validCallIds = new Set();
+    for (const msg of messages) {
+        if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls))
+            continue;
+        for (const toolCall of msg.tool_calls)
+            validCallIds.add(toolCall.id);
+    }
+    let removed = 0;
+    const repaired = messages.filter((msg) => {
+        if (msg.role !== "tool")
+            return true;
+        const keep = validCallIds.has(msg.tool_call_id);
+        if (!keep)
+            removed++;
+        return keep;
+    });
+    if (removed > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            event: "mind.session_orphan_tool_result_repair",
+            component: "mind",
+            message: "removed orphaned tool results from session history",
+            meta: { removed },
+        });
+    }
+    return repaired;
+}
+// Tool renames that have shipped. Old names in session history confuse the
+// model into calling tools that no longer exist. Applied on session load so
+// the transcript uses the current vocabulary.
+const TOOL_NAME_MIGRATIONS = {
+    final_answer: "settle",
+    no_response: "observe",
+    go_inward: "ponder",
+    descend: "ponder",
+    memory_save: "diary_write",
+    memory_search: "recall",
+};
+function migrateToolNames(messages) {
+    let migrated = 0;
+    const result = messages.map((msg) => {
+        if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls) || msg.tool_calls.length === 0)
+            return msg;
+        let changed = false;
+        const updatedCalls = msg.tool_calls.map((tc) => {
+            if (tc.type !== "function")
+                return tc;
+            const newName = TOOL_NAME_MIGRATIONS[tc.function.name];
+            if (!newName)
+                return tc;
+            changed = true;
+            migrated++;
+            return { ...tc, function: { ...tc.function, name: newName } };
+        });
+        return changed ? { ...msg, tool_calls: updatedCalls } : msg;
+    });
+    if (migrated > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            event: "mind.session_tool_name_migration",
+            component: "mind",
+            message: "migrated deprecated tool names in session history",
+            meta: { migrated },
+        });
+    }
+    return result;
+}
+function saveSession(filePath, messages, lastUsage, state) {
     const violations = validateSessionMessages(messages);
     if (violations.length > 0) {
         (0, runtime_1.emitNervesEvent)({
-            level: "warn",
+            level: "info",
             event: "mind.session_invariant_violation",
             component: "mind",
             message: "session invariant violated on save",
@@ -239,12 +309,41 @@ function saveSession(filePath, messages, lastUsage) {
         });
         messages = repairSessionMessages(messages);
     }
+    messages = stripOrphanedToolResults(messages);
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     const envelope = { version: 1, messages };
     if (lastUsage)
         envelope.lastUsage = lastUsage;
+    if (state?.mustResolveBeforeHandoff === true || typeof state?.lastFriendActivityAt === "string") {
+        envelope.state = {
+            ...(state?.mustResolveBeforeHandoff === true ? { mustResolveBeforeHandoff: true } : {}),
+            ...(typeof state?.lastFriendActivityAt === "string" ? { lastFriendActivityAt: state.lastFriendActivityAt } : {}),
+        };
+    }
     fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
 }
+function appendSyntheticAssistantMessage(filePath, content) {
+    try {
+        if (!fs.existsSync(filePath))
+            return false;
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const data = JSON.parse(raw);
+        if (data.version !== 1 || !Array.isArray(data.messages))
+            return false;
+        data.messages.push({ role: "assistant", content });
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.session_synthetic_message_appended",
+            message: "appended synthetic assistant message to session",
+            meta: { path: filePath, contentLength: content.length },
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function loadSession(filePath) {
     try {
         const raw = fs.readFileSync(filePath, "utf-8");
@@ -255,7 +354,7 @@ function loadSession(filePath) {
         const violations = validateSessionMessages(messages);
         if (violations.length > 0) {
             (0, runtime_1.emitNervesEvent)({
-                level: "warn",
+                level: "info",
                 event: "mind.session_invariant_violation",
                 component: "mind",
                 message: "session invariant violated on load",
@@ -263,13 +362,25 @@ function loadSession(filePath) {
             });
             messages = repairSessionMessages(messages);
         }
-        return { messages, lastUsage: data.lastUsage };
+        messages = stripOrphanedToolResults(messages);
+        messages = migrateToolNames(messages);
+        const rawState = data?.state && typeof data.state === "object" && data.state !== null
+            ? data.state
+            : undefined;
+        const state = rawState && (rawState.mustResolveBeforeHandoff === true
+            || typeof rawState.lastFriendActivityAt === "string")
+            ? {
+                ...(rawState.mustResolveBeforeHandoff === true ? { mustResolveBeforeHandoff: true } : {}),
+                ...(typeof rawState.lastFriendActivityAt === "string" ? { lastFriendActivityAt: rawState.lastFriendActivityAt } : {}),
+            }
+            : undefined;
+        return { messages, lastUsage: data.lastUsage, state };
     }
     catch {
         return null;
     }
 }
-function postTurn(messages, sessPath, usage, hooks) {
+function postTurn(messages, sessPath, usage, hooks, state) {
     if (hooks?.beforeTrim) {
         try {
             hooks.beforeTrim([...messages]);
@@ -289,7 +400,7 @@ function postTurn(messages, sessPath, usage, hooks) {
     const { maxTokens, contextMargin } = (0, config_1.getContextConfig)();
     const trimmed = trimMessages(messages, maxTokens, contextMargin, usage?.input_tokens);
     messages.splice(0, messages.length, ...trimmed);
-    saveSession(sessPath, messages, usage);
+    saveSession(sessPath, messages, usage, state);
 }
 function deleteSession(filePath) {
     try {