@ouro.bot/cli 0.1.0-alpha.16 → 0.1.0-alpha.161

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/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);
+}

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");
+}