@ouro.bot/cli 0.1.0-alpha.1 → 0.1.0-alpha.100

package/dist/mind/friends/trust-explanation.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeTrustContext = describeTrustContext;
+const runtime_1 = require("../../nerves/runtime");
+function findRelatedGroupId(friend) {
+    return friend.externalIds.find((externalId) => externalId.externalId.startsWith("group:"))?.externalId;
+}
+function resolveLevel(friend) {
+    return friend.trustLevel ?? "stranger";
+}
+function describeTrustContext(input) {
+    const level = resolveLevel(input.friend);
+    const relatedGroupId = findRelatedGroupId(input.friend);
+    const explanation = level === "family" || level === "friend"
+        ? {
+            level,
+            basis: "direct",
+            summary: level === "family"
+                ? "direct family trust"
+                : "direct trusted relationship",
+            why: "this relationship is directly trusted rather than inferred through a shared group or cold first contact.",
+            permits: [
+                "local operations when appropriate",
+                "proactive follow-through",
+                "full collaborative problem solving",
+            ],
+            constraints: [],
+        }
+        : level === "acquaintance"
+            ? {
+                level,
+                basis: "shared_group",
+                summary: relatedGroupId
+                    ? "known through the shared project group"
+                    : "known through a shared group context",
+                why: relatedGroupId
+                    ? `this trust comes from the shared group context ${relatedGroupId}, not from direct endorsement.`
+                    : "this trust comes from shared group context rather than direct endorsement.",
+                permits: [
+                    "group-safe coordination",
+                    "normal conversation inside the shared context",
+                ],
+                constraints: [
+                    "guarded local actions",
+                    "do not assume broad private authority",
+                ],
+                relatedGroupId,
+            }
+            : {
+                level,
+                basis: "unknown",
+                summary: "truly unknown first-contact context",
+                why: "this person is not known through direct trust or a shared group context.",
+                permits: [
+                    "safe first-contact orientation only",
+                ],
+                constraints: [
+                    "first contact does not reach the full model on open channels",
+                    "no local or privileged actions",
+                ],
+            };
+    (0, runtime_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.trust_explained",
+        message: "built explicit trust explanation",
+        meta: {
+            channel: input.channel,
+            level: explanation.level,
+            basis: explanation.basis,
+            hasRelatedGroup: Boolean(explanation.relatedGroupId),
+        },
+    });
+    return explanation;
+}

package/dist/mind/friends/types.js

@@ -2,10 +2,12 @@
 // Context kernel type definitions.
 // FriendRecord (merged identity + memory), channel capabilities, and resolved context.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRUSTED_LEVELS = void 0;
 exports.isIdentityProvider = isIdentityProvider;
 exports.isIntegration = isIntegration;
+exports.isTrustedLevel = isTrustedLevel;
 const runtime_1 = require("../../nerves/runtime");
-const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation"]);
+const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation", "imessage-handle"]);
 function isIdentityProvider(value) {
     (0, runtime_1.emitNervesEvent)({
         component: "friends",
@@ -19,3 +21,9 @@ const INTEGRATIONS = new Set(["ado", "github", "graph"]);
 function isIntegration(value) {
     return typeof value === "string" && INTEGRATIONS.has(value);
 }
+/** Trust levels that grant full tool access and proactive send capability. */
+exports.TRUSTED_LEVELS = new Set(["family", "friend"]);
+/** Whether a trust level grants full access (family or friend). Defaults to "friend" for legacy records. */
+function isTrustedLevel(trustLevel) {
+    return exports.TRUSTED_LEVELS.has(trustLevel ?? "friend");
+}

package/dist/mind/memory.js

@@ -33,11 +33,11 @@ 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.backfillEmbeddings = backfillEmbeddings;
 exports.searchMemoryFacts = searchMemoryFacts;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -45,7 +45,9 @@ 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 {
@@ -119,9 +121,16 @@ function readExistingFacts(factsPath) {
     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))
@@ -169,13 +178,24 @@ function appendDailyFact(dailyDir, fact) {
     const dayPath = path.join(dailyDir, `${day}.jsonl`);
     fs.appendFileSync(dayPath, `${JSON.stringify(fact)}\n`, "utf8");
 }
-function appendFactsWithDedup(stores, incoming) {
+function appendFactsWithDedup(stores, incoming, options) {
     const existing = readExistingFacts(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;
@@ -194,24 +214,6 @@ function appendFactsWithDedup(stores, incoming) {
     });
     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)
@@ -263,7 +265,68 @@ async function saveMemoryFact(options) {
         createdAt: (options.now ?? (() => new Date()))().toISOString(),
         embedding,
     };
-    return appendFactsWithDedup(stores, [fact]);
+    return appendFactsWithDedup(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");
+    if (!fs.existsSync(factsPath))
+        return { total: 0, backfilled: 0, failed: 0 };
+    const facts = readExistingFacts(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();
+    if (!provider) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "mind",
+            event: "mind.memory_backfill_skipped",
+            message: "embedding provider unavailable for backfill",
+            meta: { needsEmbedding: needsEmbedding.length },
+        });
+        return { total: facts.length, backfilled: 0, failed: needsEmbedding.length };
+    }
+    const batchSize = options?.batchSize ?? 50;
+    let backfilled = 0;
+    let failed = 0;
+    for (let i = 0; i < needsEmbedding.length; i += batchSize) {
+        const batch = needsEmbedding.slice(i, i + batchSize);
+        try {
+            const vectors = await provider.embed(batch.map((f) => f.text));
+            for (let j = 0; j < batch.length; j++) {
+                batch[j].embedding = vectors[j] ?? [];
+                if (batch[j].embedding.length > 0)
+                    backfilled++;
+                else
+                    failed++;
+            }
+        }
+        catch (error) {
+            failed += batch.length;
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "mind",
+                event: "mind.memory_backfill_batch_error",
+                message: "embedding backfill batch failed",
+                meta: {
+                    batchStart: i,
+                    batchSize: batch.length,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    // Rewrite facts file with updated embeddings
+    const lines = facts.map((f) => JSON.stringify(f)).join("\n") + "\n";
+    fs.writeFileSync(factsPath, lines, "utf8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.memory_backfill_complete",
+        message: "embedding backfill completed",
+        meta: { total: facts.length, backfilled, failed },
+    });
+    return { total: facts.length, backfilled, failed };
 }
 function substringMatches(queryLower, facts) {
     return facts.filter((fact) => fact.text.toLowerCase().includes(queryLower));
@@ -303,7 +366,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)

package/dist/mind/obligation-steering.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findActivePersistentObligation = findActivePersistentObligation;
+exports.renderActiveObligationSteering = renderActiveObligationSteering;
+const runtime_1 = require("../nerves/runtime");
+function findActivePersistentObligation(frame) {
+    if (!frame)
+        return null;
+    return (frame.pendingObligations ?? []).find((ob) => ob.status !== "pending" && ob.status !== "fulfilled") ?? null;
+}
+function renderActiveObligationSteering(obligation) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.obligation_steering_rendered",
+        message: "rendered active obligation steering",
+        meta: {
+            hasObligation: Boolean(obligation),
+            hasSurface: Boolean(obligation?.currentSurface?.label),
+        },
+    });
+    if (!obligation)
+        return "";
+    const name = obligation.origin.friendId;
+    const surfaceLine = obligation.currentSurface?.label
+        ? `\nright now that work is happening in ${obligation.currentSurface.label}.`
+        : "";
+    return `## where my attention is
+i'm already working on something i owe ${name}.${surfaceLine}
+
+i should close that loop before i act like this is a fresh blank turn.`;
+}

package/dist/mind/pending.js

@@ -0,0 +1,160 @@
+"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.INNER_DIALOG_PENDING = void 0;
+exports.getPendingDir = getPendingDir;
+exports.getDeferredReturnDir = getDeferredReturnDir;
+exports.getInnerDialogPendingDir = getInnerDialogPendingDir;
+exports.hasPendingMessages = hasPendingMessages;
+exports.queuePendingMessage = queuePendingMessage;
+exports.enqueueDeferredReturn = enqueueDeferredReturn;
+exports.drainDeferredReturns = drainDeferredReturns;
+exports.drainPending = drainPending;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+function getPendingDir(agentName, friendId, channel, key) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "pending", friendId, channel, key);
+}
+function getDeferredReturnDir(agentName, friendId) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "pending-returns", friendId);
+}
+/** Canonical inner-dialog pending path segments. */
+exports.INNER_DIALOG_PENDING = { friendId: "self", channel: "inner", key: "dialog" };
+/** Returns the pending dir for this agent's inner dialog. */
+function getInnerDialogPendingDir(agentName) {
+    return getPendingDir(agentName, exports.INNER_DIALOG_PENDING.friendId, exports.INNER_DIALOG_PENDING.channel, exports.INNER_DIALOG_PENDING.key);
+}
+function hasPendingMessages(pendingDir) {
+    if (!fs.existsSync(pendingDir))
+        return false;
+    try {
+        return fs.readdirSync(pendingDir).some((entry) => entry.endsWith(".json") || entry.endsWith(".json.processing"));
+    }
+    catch {
+        return false;
+    }
+}
+function writeQueueFile(queueDir, message) {
+    fs.mkdirSync(queueDir, { recursive: true });
+    const fileName = `${message.timestamp}-${Math.random().toString(36).slice(2, 10)}.json`;
+    const filePath = path.join(queueDir, fileName);
+    fs.writeFileSync(filePath, JSON.stringify(message, null, 2));
+    return filePath;
+}
+function queuePendingMessage(pendingDir, message) {
+    writeQueueFile(pendingDir, message);
+}
+function drainQueue(queueDir) {
+    if (!fs.existsSync(queueDir))
+        return { messages: [], recovered: 0 };
+    let entries;
+    try {
+        entries = fs.readdirSync(queueDir);
+    }
+    catch {
+        return { messages: [], recovered: 0 };
+    }
+    // Collect both .json (new) and .processing (crash recovery)
+    const jsonFiles = entries.filter(f => f.endsWith(".json") && !f.endsWith(".processing"));
+    const processingFiles = entries.filter(f => f.endsWith(".json.processing"));
+    // Sort by filename (timestamp prefix gives chronological order)
+    const allFiles = [
+        ...processingFiles.map(f => ({ file: f, needsRename: false })),
+        ...jsonFiles.map(f => ({ file: f, needsRename: true })),
+    ].sort((a, b) => a.file.localeCompare(b.file));
+    const messages = [];
+    for (const { file, needsRename } of allFiles) {
+        const srcPath = path.join(queueDir, file);
+        const processingPath = needsRename
+            ? path.join(queueDir, file + ".processing")
+            : srcPath;
+        try {
+            if (needsRename) {
+                fs.renameSync(srcPath, processingPath);
+            }
+            const raw = fs.readFileSync(processingPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            messages.push(parsed);
+            fs.unlinkSync(processingPath);
+        }
+        catch {
+            // Skip unparseable files — still try to clean up
+            try {
+                fs.unlinkSync(processingPath);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    return {
+        messages,
+        recovered: processingFiles.length,
+    };
+}
+function enqueueDeferredReturn(agentName, friendId, message) {
+    const queueDir = getDeferredReturnDir(agentName, friendId);
+    const filePath = writeQueueFile(queueDir, message);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.deferred_return_enqueued",
+        component: "mind",
+        message: "deferred return queued for later friend delivery",
+        meta: { friendId, queueDir },
+    });
+    return filePath;
+}
+function drainDeferredReturns(agentName, friendId) {
+    const queueDir = getDeferredReturnDir(agentName, friendId);
+    const { messages } = drainQueue(queueDir);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.deferred_returns_drained",
+        component: "mind",
+        message: "deferred friend returns drained",
+        meta: { friendId, queueDir, count: messages.length },
+    });
+    return messages;
+}
+function drainPending(pendingDir) {
+    if (!fs.existsSync(pendingDir))
+        return [];
+    const { messages, recovered } = drainQueue(pendingDir);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.pending_drained",
+        component: "mind",
+        message: "pending queue drained",
+        meta: { pendingDir, count: messages.length, recovered },
+    });
+    return messages;
+}

package/dist/mind/phrases.js

@@ -16,6 +16,7 @@ function getPhrases() {
         message: "loading phrase pools",
         meta: {},
     });
+    (0, identity_1.resetAgentConfigCache)();
     const phrases = (0, identity_1.loadAgentConfig)().phrases;
     (0, runtime_1.emitNervesEvent)({
         event: "repertoire.load_end",

package/dist/mind/prompt-refresh.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshSystemPrompt = refreshSystemPrompt;
+const prompt_1 = require("./prompt");
+const runtime_1 = require("../nerves/runtime");
+async function refreshSystemPrompt(messages, channel, options, context) {
+    const newSystem = await (0, prompt_1.buildSystem)(channel, options, context);
+    if (messages.length > 0 && messages[0].role === "system") {
+        messages[0] = { role: "system", content: newSystem };
+    }
+    else {
+        messages.unshift({ role: "system", content: newSystem });
+    }
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.system_prompt_refreshed",
+        component: "mind",
+        message: "system prompt refreshed",
+        meta: { channel },
+    });
+}