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

package/dist/mind/associative-recall.js

@@ -87,7 +87,19 @@ function readFacts(memoryRoot) {
     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--) {
@@ -144,8 +156,29 @@ async function injectAssociativeRecall(messages, options) {
         const facts = readFacts(memoryRoot);
         if (facts.length === 0)
             return;
-        const provider = options?.provider ?? createDefaultProvider();
-        const recalled = await recallFactsForQuery(query, facts, provider, options);
+        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 },
+                });
+            }
+        }
         if (recalled.length === 0)
             return;
         const recallSection = recalled
@@ -169,7 +202,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

@@ -34,6 +34,11 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CANONICAL_BUNDLE_MANIFEST = void 0;
+exports.getChangelogPath = getChangelogPath;
+exports.getPackageVersion = getPackageVersion;
+exports.createBundleMeta = createBundleMeta;
+exports.backfillBundleMeta = backfillBundleMeta;
+exports.resetBackfillTracking = resetBackfillTracking;
 exports.isCanonicalBundlePath = isCanonicalBundlePath;
 exports.findNonCanonicalBundlePaths = findNonCanonicalBundlePaths;
 const fs = __importStar(require("fs"));
@@ -41,6 +46,7 @@ const path = __importStar(require("path"));
 const runtime_1 = require("../nerves/runtime");
 exports.CANONICAL_BUNDLE_MANIFEST = [
     { path: "agent.json", kind: "file" },
+    { path: "bundle-meta.json", kind: "file" },
     { path: "psyche/SOUL.md", kind: "file" },
     { path: "psyche/IDENTITY.md", kind: "file" },
     { path: "psyche/LORE.md", kind: "file" },
@@ -48,11 +54,75 @@ exports.CANONICAL_BUNDLE_MANIFEST = [
     { path: "psyche/ASPIRATIONS.md", kind: "file" },
     { path: "psyche/memory", kind: "dir" },
     { path: "friends", kind: "dir" },
+    { path: "state", kind: "dir" },
     { path: "tasks", kind: "dir" },
     { path: "skills", kind: "dir" },
     { path: "senses", kind: "dir" },
     { path: "senses/teams", kind: "dir" },
 ];
+function getChangelogPath() {
+    const changelogPath = path.resolve(__dirname, "../../changelog.json");
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.changelog_path_resolved",
+        message: "resolved changelog path",
+        meta: { path: changelogPath },
+    });
+    return changelogPath;
+}
+function getPackageVersion() {
+    const packageJsonPath = path.resolve(__dirname, "../../package.json");
+    const raw = fs.readFileSync(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.package_version_read",
+        message: "read package version",
+        meta: { version: parsed.version },
+    });
+    return parsed.version;
+}
+function createBundleMeta() {
+    return {
+        runtimeVersion: getPackageVersion(),
+        bundleSchemaVersion: 1,
+        lastUpdated: new Date().toISOString(),
+    };
+}
+const _backfilledRoots = new Set();
+/**
+ * If bundle-meta.json is missing from the agent root, create it with current runtime version.
+ * This backfills existing agent bundles that were created before bundle-meta.json was introduced.
+ * Only attempts once per bundleRoot per process.
+ */
+function backfillBundleMeta(bundleRoot) {
+    if (_backfilledRoots.has(bundleRoot))
+        return;
+    _backfilledRoots.add(bundleRoot);
+    const metaPath = path.join(bundleRoot, "bundle-meta.json");
+    try {
+        if (fs.existsSync(metaPath)) {
+            return;
+        }
+        const meta = createBundleMeta();
+        fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf-8");
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.bundle_meta_backfill",
+            message: "backfilled missing bundle-meta.json",
+            meta: { bundleRoot },
+        });
+    }
+    catch {
+        // Non-blocking: if we can't write, that's okay
+    }
+}
+/**
+ * Reset the backfill tracking set. Used in tests.
+ */
+function resetBackfillTracking() {
+    _backfilledRoots.clear();
+}
 const CANONICAL_FILE_PATHS = new Set(exports.CANONICAL_BUNDLE_MANIFEST
     .filter((entry) => entry.kind === "file")
     .map((entry) => entry.path));

package/dist/mind/context.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.trimMessages = trimMessages;
+exports.validateSessionMessages = validateSessionMessages;
+exports.repairSessionMessages = repairSessionMessages;
 exports.saveSession = saveSession;
 exports.loadSession = loadSession;
 exports.postTurn = postTurn;
@@ -48,17 +50,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++;
@@ -76,13 +78,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));
@@ -130,7 +132,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.
@@ -144,7 +146,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)({
@@ -166,11 +168,116 @@ function trimMessages(messages, maxTokens, contextMargin, actualTokenCount) {
     });
     return trimmed;
 }
-function saveSession(filePath, messages, lastUsage) {
+/**
+ * Checks session invariant: after system messages, sequence must be
+ * user → assistant (with optional tool calls/results) → user → assistant...
+ * Never assistant → assistant without a user in between.
+ */
+function validateSessionMessages(messages) {
+    const violations = [];
+    let prevNonToolRole = null;
+    let prevAssistantHadToolCalls = false;
+    let sawToolResultSincePrevAssistant = false;
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg.role === "system")
+            continue;
+        if (msg.role === "tool") {
+            sawToolResultSincePrevAssistant = true;
+            continue;
+        }
+        if (msg.role === "assistant" && prevNonToolRole === "assistant") {
+            // assistant → tool(s) → assistant is valid (tool call flow)
+            if (!(prevAssistantHadToolCalls && sawToolResultSincePrevAssistant)) {
+                violations.push(`back-to-back assistant at index ${i}`);
+            }
+        }
+        prevAssistantHadToolCalls = msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
+        sawToolResultSincePrevAssistant = false;
+        prevNonToolRole = msg.role;
+    }
+    return violations;
+}
+/**
+ * Repairs session invariant violations by merging consecutive assistant messages.
+ */
+function repairSessionMessages(messages) {
+    const violations = validateSessionMessages(messages);
+    if (violations.length === 0)
+        return messages;
+    const result = [];
+    for (const msg of messages) {
+        if (msg.role === "assistant" && result.length > 0) {
+            const prev = result[result.length - 1];
+            if (prev.role === "assistant" && !("tool_calls" in prev)) {
+                const prevContent = typeof prev.content === "string" ? prev.content : "";
+                const curContent = typeof msg.content === "string" ? msg.content : "";
+                prev.content = `${prevContent}\n\n${curContent}`;
+                continue;
+            }
+        }
+        result.push(msg);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: "info",
+        event: "mind.session_invariant_repair",
+        component: "mind",
+        message: "repaired session invariant violations",
+        meta: { violations },
+    });
+    return result;
+}
+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;
+}
+function saveSession(filePath, messages, lastUsage, state) {
+    const violations = validateSessionMessages(messages);
+    if (violations.length > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            event: "mind.session_invariant_violation",
+            component: "mind",
+            message: "session invariant violated on save",
+            meta: { path: filePath, violations },
+        });
+        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 loadSession(filePath) {
@@ -179,13 +286,36 @@ function loadSession(filePath) {
         const data = JSON.parse(raw);
         if (data.version !== 1)
             return null;
-        return { messages: data.messages, lastUsage: data.lastUsage };
+        let messages = data.messages;
+        const violations = validateSessionMessages(messages);
+        if (violations.length > 0) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "info",
+                event: "mind.session_invariant_violation",
+                component: "mind",
+                message: "session invariant violated on load",
+                meta: { path: filePath, violations },
+            });
+            messages = repairSessionMessages(messages);
+        }
+        messages = stripOrphanedToolResults(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]);
@@ -205,7 +335,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 {

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

@@ -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,15 +18,35 @@ const CHANNEL_CAPABILITIES = {
     },
     teams: {
         channel: "teams",
+        senseType: "closed",
         availableIntegrations: ["ado", "graph", "github"],
         supportsMarkdown: true,
         supportsStreaming: true,
         supportsRichCards: true,
         maxMessageLength: Infinity,
     },
+    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,
@@ -39,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" ||