@ouro.bot/cli 0.1.0-alpha.7 → 0.1.0-alpha.70

package/dist/mind/friends/channel.js

@@ -3,10 +3,13 @@
 // Pure lookup, no I/O, cannot fail. Unknown channel gets minimal defaults.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getChannelCapabilities = getChannelCapabilities;
+exports.isRemoteChannel = isRemoteChannel;
+exports.getAlwaysOnSenseNames = getAlwaysOnSenseNames;
 const runtime_1 = require("../../nerves/runtime");
 const CHANNEL_CAPABILITIES = {
     cli: {
         channel: "cli",
+        senseType: "local",
         availableIntegrations: [],
         supportsMarkdown: false,
         supportsStreaming: true,
@@ -15,6 +18,7 @@ const CHANNEL_CAPABILITIES = {
     },
     teams: {
         channel: "teams",
+        senseType: "closed",
         availableIntegrations: ["ado", "graph", "github"],
         supportsMarkdown: true,
         supportsStreaming: true,
@@ -23,15 +27,26 @@ 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,
+    },
 };
 const DEFAULT_CAPABILITIES = {
     channel: "cli",
+    senseType: "local",
     availableIntegrations: [],
     supportsMarkdown: false,
     supportsStreaming: false,
@@ -47,3 +62,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);
+}

package/dist/mind/friends/group-context.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertGroupContextParticipants = upsertGroupContextParticipants;
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../../nerves/runtime");
+const CURRENT_SCHEMA_VERSION = 1;
+function normalizeDisplayName(externalId, displayName) {
+    const trimmed = displayName?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : externalId;
+}
+function buildNameNotes(name, now) {
+    return name !== "Unknown"
+        ? { name: { value: name, savedAt: now } }
+        : {};
+}
+function dedupeParticipants(participants) {
+    const deduped = new Map();
+    for (const participant of participants) {
+        const externalId = participant.externalId.trim();
+        if (!externalId)
+            continue;
+        const key = `${participant.provider}:${externalId}`;
+        if (!deduped.has(key)) {
+            deduped.set(key, {
+                ...participant,
+                externalId,
+                displayName: participant.displayName?.trim() || undefined,
+            });
+        }
+    }
+    return Array.from(deduped.values());
+}
+function createGroupExternalId(provider, groupExternalId, linkedAt) {
+    return {
+        provider,
+        externalId: groupExternalId,
+        linkedAt,
+    };
+}
+function shouldPromoteToAcquaintance(friend) {
+    return (friend.trustLevel ?? "stranger") === "stranger";
+}
+function createAcquaintanceRecord(participant, groupExternalId, linkedAt) {
+    const name = normalizeDisplayName(participant.externalId, participant.displayName);
+    return {
+        id: (0, node_crypto_1.randomUUID)(),
+        name,
+        role: "acquaintance",
+        trustLevel: "acquaintance",
+        connections: [],
+        externalIds: [
+            {
+                provider: participant.provider,
+                externalId: participant.externalId,
+                linkedAt,
+            },
+            createGroupExternalId(participant.provider, groupExternalId, linkedAt),
+        ],
+        tenantMemberships: [],
+        toolPreferences: {},
+        notes: buildNameNotes(name, linkedAt),
+        totalTokens: 0,
+        createdAt: linkedAt,
+        updatedAt: linkedAt,
+        schemaVersion: CURRENT_SCHEMA_VERSION,
+    };
+}
+async function upsertGroupContextParticipants(input) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.group_context_upsert_start",
+        message: "upserting shared-group participant context",
+        meta: {
+            participantCount: input.participants.length,
+            hasGroupExternalId: input.groupExternalId.trim().length > 0,
+        },
+    });
+    const groupExternalId = input.groupExternalId.trim();
+    if (!groupExternalId) {
+        return [];
+    }
+    const now = input.now ?? (() => new Date().toISOString());
+    const participants = dedupeParticipants(input.participants);
+    const results = [];
+    for (const participant of participants) {
+        const linkedAt = now();
+        const existing = await input.store.findByExternalId(participant.provider, participant.externalId);
+        if (!existing) {
+            const created = createAcquaintanceRecord(participant, groupExternalId, linkedAt);
+            await input.store.put(created.id, created);
+            results.push({
+                friendId: created.id,
+                name: created.name,
+                trustLevel: "acquaintance",
+                created: true,
+                updated: false,
+                addedGroupExternalId: true,
+            });
+            continue;
+        }
+        const hasGroupExternalId = existing.externalIds.some((externalId) => externalId.externalId === groupExternalId);
+        const promoteToAcquaintance = shouldPromoteToAcquaintance(existing);
+        const trustLevel = promoteToAcquaintance
+            ? "acquaintance"
+            : existing.trustLevel;
+        const role = promoteToAcquaintance
+            ? "acquaintance"
+            : existing.role;
+        const updatedExternalIds = hasGroupExternalId
+            ? existing.externalIds
+            : [...existing.externalIds, createGroupExternalId(participant.provider, groupExternalId, linkedAt)];
+        const updated = promoteToAcquaintance || !hasGroupExternalId;
+        const record = updated
+            ? {
+                ...existing,
+                role,
+                trustLevel,
+                externalIds: updatedExternalIds,
+                updatedAt: linkedAt,
+            }
+            : existing;
+        if (updated) {
+            await input.store.put(record.id, record);
+        }
+        results.push({
+            friendId: record.id,
+            name: record.name,
+            trustLevel,
+            created: false,
+            updated,
+            addedGroupExternalId: !hasGroupExternalId,
+        });
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.group_context_upsert_end",
+        message: "upserted shared-group participant context",
+        meta: {
+            participantCount: participants.length,
+            updatedCount: results.filter((result) => result.created || result.updated).length,
+        },
+    });
+    return results;
+}

package/dist/mind/friends/store-file.js

@@ -100,6 +100,25 @@ class FileFriendStore {
         }
         return entries.some((entry) => entry.endsWith(".json"));
     }
+    async listAll() {
+        let entries;
+        try {
+            entries = await fsPromises.readdir(this.friendsPath);
+        }
+        catch {
+            return [];
+        }
+        const records = [];
+        for (const entry of entries) {
+            if (!entry.endsWith(".json"))
+                continue;
+            const raw = await this.readJson(path.join(this.friendsPath, entry));
+            if (!raw)
+                continue;
+            records.push(this.normalize(raw));
+        }
+        return records;
+    }
     normalize(raw) {
         const trustLevel = raw.trustLevel;
         const normalizedTrustLevel = trustLevel === "family" ||

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,8 +2,10 @@
 // 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", "imessage-handle"]);
 function isIdentityProvider(value) {
@@ -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,7 +33,6 @@ 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;
@@ -46,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 {
@@ -120,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))
@@ -170,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;
@@ -195,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)
@@ -264,7 +265,7 @@ 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");
@@ -365,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/pending.js

@@ -33,24 +33,56 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 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.enqueueDeferredReturn = enqueueDeferredReturn;
+exports.drainDeferredReturns = drainDeferredReturns;
 exports.drainPending = drainPending;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const os = __importStar(require("os"));
+const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
 function getPendingDir(agentName, friendId, channel, key) {
-    return path.join(os.homedir(), ".agentstate", agentName, "pending", friendId, channel, key);
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "pending", friendId, channel, key);
 }
-function drainPending(pendingDir) {
+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 [];
+        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 drainQueue(queueDir) {
+    if (!fs.existsSync(queueDir))
+        return { messages: [], recovered: 0 };
     let entries;
     try {
-        entries = fs.readdirSync(pendingDir);
+        entries = fs.readdirSync(queueDir);
     }
     catch {
-        return [];
+        return { messages: [], recovered: 0 };
     }
     // Collect both .json (new) and .processing (crash recovery)
     const jsonFiles = entries.filter(f => f.endsWith(".json") && !f.endsWith(".processing"));
@@ -62,9 +94,9 @@ function drainPending(pendingDir) {
     ].sort((a, b) => a.file.localeCompare(b.file));
     const messages = [];
     for (const { file, needsRename } of allFiles) {
-        const srcPath = path.join(pendingDir, file);
+        const srcPath = path.join(queueDir, file);
         const processingPath = needsRename
-            ? path.join(pendingDir, file + ".processing")
+            ? path.join(queueDir, file + ".processing")
             : srcPath;
         try {
             if (needsRename) {
@@ -83,11 +115,42 @@ function drainPending(pendingDir) {
             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: processingFiles.length },
+        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",