@ouro.bot/cli 0.1.0-alpha.56 → 0.1.0-alpha.561

package/dist/mind/{memory.js → diary.js}

@@ -33,53 +33,25 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-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 note_search_1 = require("./note-search");
+const diary_integrity_1 = require("./diary-integrity");
+const embedding_provider_1 = require("./embedding-provider");
 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 {
-    apiKey;
-    model;
-    constructor(apiKey, model = DEFAULT_EMBEDDING_MODEL) {
-        this.apiKey = apiKey;
-        this.model = model;
-    }
-    async embed(texts) {
-        const response = await fetch("https://api.openai.com/v1/embeddings", {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                model: this.model,
-                input: texts,
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`embedding request failed: ${response.status} ${response.statusText}`);
-        }
-        const payload = (await response.json());
-        if (!payload.data || payload.data.length !== texts.length) {
-            throw new Error("embedding response missing expected vectors");
-        }
-        return payload.data.map((entry) => entry.embedding);
-    }
-}
-function 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");
@@ -91,8 +63,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 };
@@ -115,7 +87,7 @@ 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();
@@ -178,8 +150,8 @@ function appendDailyFact(dailyDir, fact) {
     const dayPath = path.join(dailyDir, `${day}.jsonl`);
     fs.appendFileSync(dayPath, `${JSON.stringify(fact)}\n`, "utf8");
 }
-function appendFactsWithDedup(stores, incoming, options) {
-    const existing = readExistingFacts(stores.factsPath);
+function appendEntriesWithDedup(stores, incoming, options) {
+    const existing = readExistingEntries(stores.factsPath);
     const all = [...existing];
     let added = 0;
     let skipped = 0;
@@ -192,7 +164,7 @@ function appendFactsWithDedup(stores, incoming, options) {
                 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 (0, note_search_1.cosineSimilarity)(fact.embedding, prior.embedding) > semanticThreshold;
             }
             return false;
         });
@@ -208,26 +180,20 @@ function appendFactsWithDedup(stores, incoming, options) {
     }
     (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 createDefaultEmbeddingProvider() {
-    const apiKey = (0, config_1.getOpenAIEmbeddingsApiKey)().trim();
-    if (!apiKey)
-        return null;
-    return new OpenAIEmbeddingProvider(apiKey);
-}
 async function buildEmbedding(text, embeddingProvider) {
-    const provider = embeddingProvider ?? createDefaultEmbeddingProvider();
+    const provider = embeddingProvider ?? (0, embedding_provider_1.createDefaultEmbeddingProvider)();
     if (!provider) {
         (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 [];
@@ -240,8 +206,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),
             },
@@ -249,13 +215,19 @@ 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)();
+    return path.join(agentRoot, "diary");
 }
-async function saveMemoryFact(options) {
+function readDiaryEntries(diaryRoot) {
+    return readExistingEntries(path.join(resolveDiaryRoot(diaryRoot), "facts.jsonl"));
+}
+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,24 +236,39 @@ async function saveMemoryFact(options) {
         about: options.about?.trim() || undefined,
         createdAt: (options.now ?? (() => new Date()))().toISOString(),
         embedding,
+        ...(options.provenance ? { provenance: options.provenance } : {}),
     };
-    return appendFactsWithDedup(stores, [fact], { semanticThreshold: SEMANTIC_DEDUP_THRESHOLD });
+    const integrity = (0, diary_integrity_1.detectSuspiciousContent)(text);
+    if (integrity.suspicious) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "mind",
+            event: "mind.diary_integrity_warning",
+            message: "suspicious content detected in diary entry",
+            meta: {
+                patterns: integrity.patterns,
+                textPreview: text.slice(0, 200),
+                entryId: fact.id,
+            },
+        });
+    }
+    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 };
-    const provider = options?.embeddingProvider ?? createDefaultEmbeddingProvider();
+    const provider = options?.embeddingProvider ?? (0, embedding_provider_1.createDefaultEmbeddingProvider)();
     if (!provider) {
         (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 },
         });
@@ -307,7 +294,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,
@@ -322,7 +309,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 },
     });
@@ -342,7 +329,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 [];
@@ -352,7 +339,7 @@ async function searchMemoryFacts(query, facts, embeddingProvider) {
     if (embeddedFacts.length === 0) {
         return substringFallback();
     }
-    const provider = embeddingProvider ?? createDefaultEmbeddingProvider();
+    const provider = embeddingProvider ?? (0, embedding_provider_1.createDefaultEmbeddingProvider)();
     if (!provider) {
         return substringFallback();
     }
@@ -366,7 +353,7 @@ async function searchMemoryFacts(query, facts, embeddingProvider) {
             .filter((fact) => fact.embedding.length === queryEmbedding.length)
             .map((fact) => ({
             fact,
-            score: (0, associative_recall_1.cosineSimilarity)(queryEmbedding, fact.embedding),
+            score: (0, note_search_1.cosineSimilarity)(queryEmbedding, fact.embedding),
         }))
             .filter((entry) => entry.score > 0)
             .sort((left, right) => right.score - left.score)
@@ -378,8 +365,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/embedding-provider.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Shared OpenAI embedding provider.
+ *
+ * Both diary.ts and note-search.ts need to call the OpenAI embeddings
+ * API. This module provides the shared implementation so neither duplicates
+ * the fetch logic.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIEmbeddingProvider = void 0;
+exports.createDefaultEmbeddingProvider = createDefaultEmbeddingProvider;
+const config_1 = require("../heart/config");
+const runtime_1 = require("../nerves/runtime");
+const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
+class OpenAIEmbeddingProvider {
+    apiKey;
+    model;
+    constructor(apiKey, model = DEFAULT_EMBEDDING_MODEL) {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async embed(texts) {
+        const response = await fetch("https://api.openai.com/v1/embeddings", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                model: this.model,
+                input: texts,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`embedding request failed: ${response.status} ${response.statusText}`);
+        }
+        const payload = (await response.json());
+        if (!payload.data || payload.data.length !== texts.length) {
+            throw new Error("embedding response missing expected vectors");
+        }
+        return payload.data.map((entry) => entry.embedding);
+    }
+}
+exports.OpenAIEmbeddingProvider = OpenAIEmbeddingProvider;
+/**
+ * Create a default embedding provider from the configured API key.
+ * Returns null if no key is configured.
+ */
+function createDefaultEmbeddingProvider() {
+    const apiKey = (0, config_1.getOpenAIEmbeddingsApiKey)().trim();
+    if (!apiKey)
+        return null;
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.embedding_provider_created",
+        message: "default embedding provider created",
+        meta: { model: DEFAULT_EMBEDDING_MODEL },
+    });
+    return new OpenAIEmbeddingProvider(apiKey);
+}

package/dist/mind/file-state.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileStateCache = exports.FileStateCache = void 0;
+exports.contentHash = contentHash;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const runtime_1 = require("../nerves/runtime");
+/** Compute sha256 hex hash of content */
+function contentHash(content) {
+    return (0, crypto_1.createHash)("sha256").update(content).digest("hex");
+}
+/**
+ * Session-scoped LRU cache tracking file reads.
+ * Stores content hashes (not full content) to limit stored content.
+ * Keyed by absolute file path.
+ *
+ * Also maintains a separate snapshot list for future rewind support.
+ * Snapshots are indexed by content hash and linked to conversation messages.
+ */
+class FileStateCache {
+    entries;
+    maxSize;
+    snapshots = [];
+    maxSnapshots = 100;
+    constructor(maxSize = 50) {
+        this.entries = new Map();
+        this.maxSize = maxSize;
+    }
+    /**
+     * Record a file read. Computes content hash and stores metadata.
+     */
+    record(filePath, content, mtime, offset, limit, messageId) {
+        // If key already exists, delete it so re-insertion moves it to end (most recent)
+        if (this.entries.has(filePath)) {
+            this.entries.delete(filePath);
+        }
+        const hash = contentHash(content);
+        const fullRead = offset === undefined && limit === undefined;
+        this.entries.set(filePath, {
+            hash,
+            mtime,
+            offset: fullRead ? undefined : offset,
+            limit: fullRead ? undefined : limit,
+            fullRead,
+            recordedAt: Date.now(),
+            messageId,
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.file_state.record",
+            message: "recorded file state",
+            meta: { path: filePath, hash, fullRead },
+        });
+        // Evict LRU (first entry in Map iteration order) if over capacity
+        if (this.entries.size > this.maxSize) {
+            const firstKey = this.entries.keys().next().value;
+            this.entries.delete(firstKey);
+        }
+    }
+    /**
+     * Get the cached state for a file path. Also promotes it in LRU order.
+     */
+    get(filePath) {
+        const entry = this.entries.get(filePath);
+        if (entry === undefined)
+            return undefined;
+        // Promote to most-recently-used by re-inserting
+        this.entries.delete(filePath);
+        this.entries.set(filePath, entry);
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.file_state.get",
+            message: "retrieved file state",
+            meta: { path: filePath, hash: entry.hash },
+        });
+        return entry;
+    }
+    /**
+     * Check if a file has been modified since the last recorded read.
+     * Uses mtime as primary signal, content hash as fallback for cloud sync / touch scenarios.
+     * Returns { stale: false } if the path is not in cache or the file cannot be stat'd.
+     */
+    isStale(filePath) {
+        const entry = this.entries.get(filePath);
+        if (entry === undefined)
+            return { stale: false };
+        let currentMtime;
+        try {
+            currentMtime = (0, fs_1.statSync)(filePath).mtimeMs;
+        }
+        catch {
+            // File doesn't exist or can't be stat'd -- no basis for staleness
+            return { stale: false };
+        }
+        // Fast path: mtime unchanged means not stale
+        if (currentMtime === entry.mtime)
+            return { stale: false };
+        // mtime differs -- check content hash as fallback (handles touch / cloud sync)
+        try {
+            const currentContent = (0, fs_1.readFileSync)(filePath, "utf-8");
+            const currentHash = contentHash(currentContent);
+            if (currentHash === entry.hash)
+                return { stale: false };
+            (0, runtime_1.emitNervesEvent)({
+                component: "mind",
+                event: "mind.file_state.stale_detected",
+                message: "file staleness detected",
+                meta: { path: filePath, previousHash: entry.hash, currentHash },
+            });
+            return { stale: true, reason: `file modified since last read (mtime and content differ)` };
+        }
+        catch {
+            // Can't read file -- treat as not stale (file may have been deleted)
+            return { stale: false };
+        }
+    }
+    /**
+     * Create a pre-edit snapshot of the current cache state for a file.
+     * Snapshots are stored separately from the LRU cache for future rewind support.
+     * Returns undefined if the path is not in cache.
+     */
+    snapshot(filePath) {
+        const entry = this.entries.get(filePath);
+        if (entry === undefined)
+            return undefined;
+        const snap = {
+            filePath,
+            hash: entry.hash,
+            mtime: entry.mtime,
+            messageId: entry.messageId,
+            createdAt: Date.now(),
+        };
+        this.snapshots.push(snap);
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.file_state.snapshot_created",
+            message: "created file state snapshot",
+            meta: { path: filePath, hash: snap.hash },
+        });
+        // Evict oldest snapshots if over capacity
+        if (this.snapshots.length > this.maxSnapshots) {
+            this.snapshots = this.snapshots.slice(this.snapshots.length - this.maxSnapshots);
+        }
+        return snap;
+    }
+    /**
+     * Get all snapshots in creation order.
+     */
+    getSnapshots() {
+        return this.snapshots;
+    }
+    /**
+     * Look up a snapshot by content hash. Returns the first match.
+     */
+    lookupSnapshotByHash(hash) {
+        return this.snapshots.find(s => s.hash === hash);
+    }
+    /**
+     * Clear all snapshots.
+     */
+    clearSnapshots() {
+        this.snapshots = [];
+    }
+    /**
+     * Clear all cached entries (does not clear snapshots).
+     */
+    clear() {
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.file_state.clear",
+            message: "cleared file state cache",
+            meta: { entryCount: this.entries.size },
+        });
+        this.entries.clear();
+    }
+}
+exports.FileStateCache = FileStateCache;
+/** Session-scoped singleton instance used by tool handlers */
+exports.fileStateCache = new FileStateCache();

package/dist/mind/friends/channel.js

@@ -2,10 +2,22 @@
 // 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",
@@ -34,6 +46,24 @@ const CHANNEL_CAPABILITIES = {
         supportsRichCards: false,
         maxMessageLength: Infinity,
     },
+    mail: {
+        channel: "mail",
+        senseType: "open",
+        availableIntegrations: [],
+        supportsMarkdown: false,
+        supportsStreaming: false,
+        supportsRichCards: false,
+        maxMessageLength: Infinity,
+    },
+    voice: {
+        channel: "voice",
+        senseType: "local",
+        availableIntegrations: [],
+        supportsMarkdown: false,
+        supportsStreaming: true,
+        supportsRichCards: false,
+        maxMessageLength: Infinity,
+    },
     inner: {
         channel: "inner",
         senseType: "internal",
@@ -43,6 +73,15 @@ const CHANNEL_CAPABILITIES = {
         supportsRichCards: false,
         maxMessageLength: Infinity,
     },
+    mcp: {
+        channel: "mcp",
+        senseType: "local",
+        availableIntegrations: [],
+        supportsMarkdown: true,
+        supportsStreaming: false,
+        supportsRichCards: false,
+        maxMessageLength: Infinity,
+    },
 };
 const DEFAULT_CAPABILITIES = {
     channel: "cli",

package/dist/mind/friends/resolver.js

@@ -1,7 +1,7 @@
 "use strict";
 // FriendResolver -- resolves external identity into a FriendRecord + channel capabilities.
 // Created per-request (per-incoming-message), per-friend.
-// Replaces the old ContextResolver: no authority checker, no separate memory resolution.
+// Replaces the old ContextResolver: no authority checker, no separate note resolution.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FriendResolver = void 0;
 const crypto_1 = require("crypto");
@@ -31,6 +31,43 @@ class FriendResolver {
         }
         if (existing)
             return existing;
+        // Migration: local provider previously used "${username}@${hostname}" format.
+        // If no exact match, try finding a friend with old-format external ID.
+        /* v8 ignore start -- migration path: only fires when legacy hostname-format friend exists @preserve */
+        if (this.params.provider === "local" && !this.params.externalId.includes("@")) {
+            try {
+                const all = typeof this.store.listAll === "function" ? await this.store.listAll() : [];
+                /* v8 ignore start -- migration path: only fires when legacy hostname-format friend exists @preserve */
+                const migrationMatch = all.find((f) => f.externalIds.some((eid) => eid.provider === "local" && eid.externalId.startsWith(this.params.externalId + "@")));
+                if (migrationMatch) {
+                    const now = new Date().toISOString();
+                    migrationMatch.externalIds.push({
+                        provider: this.params.provider,
+                        externalId: this.params.externalId,
+                        linkedAt: now,
+                    });
+                    migrationMatch.updatedAt = now;
+                    try {
+                        await this.store.put(migrationMatch.id, migrationMatch);
+                    }
+                    catch {
+                        // best-effort persist
+                    }
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "friends",
+                        event: "friends.local_id_migrated",
+                        message: `migrated local friend identity from hostname format to username-only`,
+                        meta: { friendId: migrationMatch.id, newExternalId: this.params.externalId },
+                    });
+                    return migrationMatch;
+                }
+                /* v8 ignore stop */
+            }
+            catch {
+                // fall through to create new
+            }
+        }
+        /* v8 ignore stop */
         // First encounter -- create new FriendRecord
         const now = new Date().toISOString();
         const externalId = {
@@ -50,6 +87,21 @@ class FriendResolver {
             hasAnyFriends = false;
         }
         const isFirstImprint = !hasAnyFriends;
+        // BlueBubbles group chats route through here as `imessage-handle` with an
+        // externalId of the form `group:any;+;<chatHash>`. When the harness auto-
+        // creates the group friend at stranger trust, we mark the record so that
+        // the trust gate can surface the relationship for explicit acknowledgment
+        // later instead of letting messages accumulate silently.
+        const isImessageGroup = this.params.provider === "imessage-handle" &&
+            typeof this.params.externalId === "string" &&
+            this.params.externalId.startsWith("group:");
+        const notes = {};
+        if (this.params.displayName !== "Unknown") {
+            notes.name = { value: this.params.displayName, savedAt: now };
+        }
+        if (isImessageGroup && !isFirstImprint) {
+            notes.autoCreatedGroup = { value: "true", savedAt: now };
+        }
         const friend = {
             id: (0, crypto_1.randomUUID)(),
             name: this.params.displayName,
@@ -59,7 +111,7 @@ class FriendResolver {
             externalIds: [externalId],
             tenantMemberships,
             toolPreferences: {},
-            notes: this.params.displayName !== "Unknown" ? { name: { value: this.params.displayName, savedAt: now } } : {},
+            notes,
             totalTokens: 0,
             createdAt: now,
             updatedAt: now,