chatlab-cli 0.36.2 → 0.37.0

package/dist/{chunk-VREVDZ4Q.mjs → chunk-DQR2YS3I.mjs}

@@ -9,7 +9,7 @@ import {
   createEmptyContactsDiagnostics,
   normalizeContactsTimeRangePreset,
   resolveContactsTimeRange
-} from "./chunk-VUYWUHWW.mjs";
+} from "./chunk-EJBBVLUN.mjs";
 import {
   PEOPLE_RELATIONSHIPS_ALGORITHM_VERSION,
   buildPeopleRelationshipsNeighborhoodGraph,
@@ -18,7 +18,7 @@ import {
   computePeopleRelationshipsSnapshot,
   normalizePeopleRelationshipsTimeRangePreset,
   resolvePeopleRelationshipsTimeRange
-} from "./chunk-6EZPD3XJ.mjs";
+} from "./chunk-N2WGG3MS.mjs";
 import {
   ANNUAL_SUMMARY_ALGORITHM_VERSION,
   TIME_INVESTMENT_ALGORITHM_VERSION,
@@ -37,6 +37,7 @@ import {
   NAVIGATION_LAYOUT_SCHEMA_VERSION,
   appLogger,
   applyPreprocessingPipeline,
+  buildContactKey,
   buildSessionInfo,
   checkSessionsCanGenerateSummary,
   cleanupAnnualSummarySnapshotTempFiles,
@@ -47,6 +48,7 @@ import {
   deleteMember,
   deleteMembers,
   deleteTimeInvestmentSnapshots,
+  desensitizeText,
   generateIncrementalSessionIndex,
   generateMessageKey,
   generateSessionIndex,
@@ -55,15 +57,22 @@ import {
   getChatSessionList,
   getContactsDir,
   getContactsFactsCacheDir,
+  getCrossChatSessionActivityFacts,
   getDbFileVersion,
   getGlobalInsightDir,
   getGlobalInsightFactsCacheDir,
   getMemberNameHistory,
   getMembersPaginated,
   getMembersWithAliases,
+  getNonSystemMembersForContacts,
+  getParticipantSessionFacts,
+  getParticipantSetInteractionFacts,
   getPeopleRelationshipsDir,
   getPeopleRelationshipsFactsCacheDir,
   getPrivateChatMemberAvatar,
+  getRecentMessages,
+  getSearchMessageContext,
+  getSegmentSummaries,
   getSegmentSummary,
   getSessionIndexStats,
   getSessionInfo,
@@ -80,16 +89,22 @@ import {
   isSupportedChatLabFormatVersion,
   loadSegmentMessages,
   matchOwnerProfile,
+  matchesBlacklist,
   mergeConfirmedNames,
   mergeMembers,
   normalizeAnnualSummaryRange,
   normalizeSessionGapThreshold,
   openBetterSqliteDatabase,
+  preprocessMessages,
   readAnnualSummarySnapshot,
   readTimeInvestmentSnapshot,
   renameSession,
   resolveApiKey,
+  resolveContactMember,
+  resolveOwnerMember,
   saveSegmentSummary,
+  searchMessagesByKeywords,
+  shouldScopeContactToSession,
   snapshotPathProvider,
   toAnnualSummaryLocalDate,
   toAnnualSummaryRangeKey,
@@ -99,7 +114,7 @@ import {
   writeAuthProfile,
   writeParseResultToDb,
   writeTimeInvestmentSnapshot
-} from "./chunk-TRGR3KKJ.mjs";
+} from "./chunk-4J4MA3RC.mjs";
 import {
   __commonJS,
   __export,
@@ -4778,6 +4793,11 @@ var feature5 = {
     requiredFields: ["weflow", "session"]
   }
 };
+function normalizePlatformMessageId(value) {
+  if (typeof value !== "string" && typeof value !== "number") return void 0;
+  const id = String(value).trim();
+  return id && id !== "0" ? id : void 0;
+}
 function convertMessageType3(typeStr) {
   switch (typeStr) {
     case "\u6587\u672C\u6D88\u606F":
@@ -5080,9 +5100,9 @@ async function* parseWeFlow(options2) {
         const rawContent = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
         content = rawContent.trim() || null;
       }
+      const platformMessageId = normalizePlatformMessageId(msg.platformMessageId);
       return {
-        platformMessageId: String(msg.localId),
-        // 消息的平台原始 ID（用于回复关联查询）
+        platformMessageId,
         senderPlatformId: platformId,
         senderAccountName: accountName,
         // WeFlow 格式没有单独的群昵称字段
@@ -7931,22 +7951,56 @@ function generateFallbackMessageKey(message) {
   const contentKey = generateMessageKey(message.timestamp, message.senderPlatformId, message.content);
   return JSON.stringify([contentKey, message.type, message.replyToMessageId || null]);
 }
-function createMessageDedupState(platformMessageIds = [], fallbackKeys = [], fallbackOnlyKeys = []) {
+function createMessageDedupState(platformMessageIds = [], fallbackKeys = [], fallbackOnlyKeys = [], options2 = {}) {
+  const fallbackKeySet = new Set(fallbackKeys);
+  const fallbackOnlyKeySet = new Set(fallbackOnlyKeys);
+  const fallbackMultiplicityBalances = /* @__PURE__ */ new Map();
+  if (options2.preserveFallbackMultiplicity) {
+    for (const key of fallbackKeySet) fallbackMultiplicityBalances.set(key, -1);
+    for (const key of fallbackOnlyKeySet) fallbackMultiplicityBalances.set(key, 1);
+  }
   return {
     platformMessageIds: new Set(platformMessageIds),
-    fallbackKeys: new Set(fallbackKeys),
-    fallbackOnlyKeys: new Set(fallbackOnlyKeys)
+    fallbackKeys: fallbackKeySet,
+    fallbackOnlyKeys: fallbackOnlyKeySet,
+    preserveFallbackMultiplicity: options2.preserveFallbackMultiplicity ?? false,
+    fallbackMultiplicityBalances
   };
 }
+function setFallbackMultiplicityBalance(state, key, balance) {
+  if (balance === 0) state.fallbackMultiplicityBalances.delete(key);
+  else state.fallbackMultiplicityBalances.set(key, balance);
+}
+function hasUnmatchedFallbackOnlyMessage(state, fallbackKey) {
+  return state.preserveFallbackMultiplicity ? (state.fallbackMultiplicityBalances.get(fallbackKey) ?? 0) > 0 : state.fallbackOnlyKeys.has(fallbackKey);
+}
 function registerMessageAndCheckDuplicate(message, state) {
   const key = generateFallbackMessageKey(message);
   if (message.platformMessageId) {
     if (state.platformMessageIds.has(message.platformMessageId)) return true;
     state.platformMessageIds.add(message.platformMessageId);
+    if (state.preserveFallbackMultiplicity) {
+      const balance = state.fallbackMultiplicityBalances.get(key) ?? 0;
+      if (balance > 0) {
+        setFallbackMultiplicityBalance(state, key, balance - 1);
+        return true;
+      }
+      setFallbackMultiplicityBalance(state, key, balance - 1);
+      return false;
+    }
     if (state.fallbackOnlyKeys.delete(key)) return true;
     state.fallbackKeys.add(key);
     return false;
   }
+  if (state.preserveFallbackMultiplicity) {
+    const balance = state.fallbackMultiplicityBalances.get(key) ?? 0;
+    if (balance < 0) {
+      setFallbackMultiplicityBalance(state, key, balance + 1);
+      return true;
+    }
+    setFallbackMultiplicityBalance(state, key, balance + 1);
+    return false;
+  }
   if (state.fallbackKeys.has(key)) return true;
   state.fallbackKeys.add(key);
   state.fallbackOnlyKeys.add(key);
@@ -7954,6 +8008,9 @@ function registerMessageAndCheckDuplicate(message, state) {
 }
 
 // ../../packages/node-runtime/src/import/streaming-importer.ts
+function shouldPreserveFallbackMultiplicity(formatId) {
+  return formatId === PARSER_FORMAT_IDS.WEFLOW || formatId === PARSER_FORMAT_IDS.ECHOTRACE;
+}
 var BATCH_COMMIT_SIZE = 5e4;
 var CHECKPOINT_INTERVAL = 2e5;
 var SYSTEM_SENDER_ID2 = "SYSTEM";
@@ -8251,7 +8308,9 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
     skippedInvalidTimestamp: 0,
     skippedNoType: 0
   };
-  const dedupState = createMessageDedupState();
+  const dedupState = createMessageDedupState([], [], [], {
+    preserveFallbackMultiplicity: shouldPreserveFallbackMultiplicity(formatFeature.id)
+  });
   logger?.info("Starting streamParseFile...");
   const parsePipelineStartedAt = now();
   let parserTimingFinished = false;
@@ -8591,7 +8650,9 @@ async function analyzeNewImport(filePath, onProgress, options2) {
   }
   let meta = null;
   const memberSet = /* @__PURE__ */ new Set();
-  const dedupState = createMessageDedupState();
+  const dedupState = createMessageDedupState([], [], [], {
+    preserveFallbackMultiplicity: shouldPreserveFallbackMultiplicity(formatFeature.id)
+  });
   let totalMessages = 0;
   let newMessageCount = 0;
   let duplicateCount = 0;
@@ -8816,8 +8877,9 @@ function createExistingMessageLookup(db) {
     db,
     maxMessageId,
     hasFallbackOnlyMessages,
-    consumedFallbackOnlyKeys: /* @__PURE__ */ new Set(),
+    consumedFallbackOnlyOccurrenceCounts: /* @__PURE__ */ new Map(),
     bridgedPlatformMessageIds: /* @__PURE__ */ new Set(),
+    consumedFallbackOccurrenceCounts: /* @__PURE__ */ new Map(),
     candidateStatement: db.prepare(
       `SELECT msg.type, msg.content, msg.reply_to_message_id, msg.platform_message_id
        FROM member m
@@ -8868,28 +8930,36 @@ function candidateFallbackKey(message, candidate) {
     replyToMessageId: candidate.reply_to_message_id ?? void 0
   });
 }
-function isExistingMessageDuplicate(lookup, message, existingBatchPlatformIds, candidateCache) {
+function isExistingMessageDuplicate(lookup, message, existingBatchPlatformIds, candidateCache, preserveFallbackMultiplicity) {
   if (message.platformMessageId && (existingBatchPlatformIds.has(message.platformMessageId) || lookup.bridgedPlatformMessageIds.has(message.platformMessageId))) {
     return true;
   }
   const fallbackKey = generateFallbackMessageKey(message);
   if (message.platformMessageId) {
-    if (!lookup.hasFallbackOnlyMessages || lookup.consumedFallbackOnlyKeys.has(fallbackKey)) return false;
-    const matchesFallbackOnly = getExistingCandidates(lookup, message, candidateCache).some(
+    if (!lookup.hasFallbackOnlyMessages) return false;
+    const matchingFallbackOnlyCount = getExistingCandidates(lookup, message, candidateCache).filter(
       (candidate) => !candidate.platform_message_id && candidateFallbackKey(message, candidate) === fallbackKey
-    );
+    ).length;
+    const consumedCount2 = lookup.consumedFallbackOnlyOccurrenceCounts.get(fallbackKey) ?? 0;
+    const matchesFallbackOnly = preserveFallbackMultiplicity ? consumedCount2 < matchingFallbackOnlyCount : consumedCount2 === 0 && matchingFallbackOnlyCount > 0;
     if (matchesFallbackOnly) {
-      lookup.consumedFallbackOnlyKeys.add(fallbackKey);
+      lookup.consumedFallbackOnlyOccurrenceCounts.set(fallbackKey, consumedCount2 + 1);
       lookup.bridgedPlatformMessageIds.add(message.platformMessageId);
     }
     return matchesFallbackOnly;
   }
-  return getExistingCandidates(lookup, message, candidateCache).some(
+  const matchingCount = getExistingCandidates(lookup, message, candidateCache).filter(
     (candidate) => candidateFallbackKey(message, candidate) === fallbackKey
-  );
+  ).length;
+  if (!preserveFallbackMultiplicity) return matchingCount > 0;
+  const consumedCount = lookup.consumedFallbackOccurrenceCounts.get(fallbackKey) ?? 0;
+  if (consumedCount >= matchingCount) return false;
+  lookup.consumedFallbackOccurrenceCounts.set(fallbackKey, consumedCount + 1);
+  return true;
 }
-function isDuplicate(lookup, incomingState, message, existingBatchPlatformIds, candidateCache) {
-  if (isExistingMessageDuplicate(lookup, message, existingBatchPlatformIds, candidateCache)) return true;
+function isDuplicate(lookup, incomingState, message, existingBatchPlatformIds, candidateCache, preserveFallbackMultiplicity) {
+  if (isExistingMessageDuplicate(lookup, message, existingBatchPlatformIds, candidateCache, preserveFallbackMultiplicity))
+    return true;
   return registerMessageAndCheckDuplicate(message, incomingState);
 }
 function normalizeImportTimestamp(timestamp) {
@@ -8912,9 +8982,10 @@ async function analyzeIncrementalImport(sessionId, filePath, deps, options2) {
   let duplicateCount = 0;
   let platform = formatFeature.platform;
   const mapPlatformId = createPlatformIdMapper(options2?.senderPlatformIdMappings);
+  const preserveFallbackMultiplicity = shouldPreserveFallbackMultiplicity(formatFeature.id);
   try {
     const existingLookup = createExistingMessageLookup(db);
-    const incomingState = createMessageDedupState();
+    const incomingState = createMessageDedupState([], [], [], { preserveFallbackMultiplicity });
     await streamParseFile(
       filePath,
       {
@@ -8946,7 +9017,8 @@ async function analyzeIncrementalImport(sessionId, filePath, deps, options2) {
               incomingState,
               { ...msg, timestamp },
               existingBatchPlatformIds,
-              candidateCache
+              candidateCache,
+              preserveFallbackMultiplicity
             )) {
               duplicateCount++;
             } else {
@@ -8976,6 +9048,7 @@ async function incrementalImport(sessionId, filePath, deps, options2) {
   const metaUpdateMode = options2?.metaUpdateMode ?? "patch";
   const memberUpdateMode = options2?.memberUpdateMode ?? "upsert";
   const mapPlatformId = createPlatformIdMapper(options2?.senderPlatformIdMappings);
+  const preserveFallbackMultiplicity = shouldPreserveFallbackMultiplicity(formatFeature.id);
   try {
     let trackError2 = function(index, reason, detail) {
       errorCount++;
@@ -8986,7 +9059,7 @@ async function incrementalImport(sessionId, filePath, deps, options2) {
     };
     var trackError = trackError2;
     const existingLookup = createExistingMessageLookup(db);
-    const incomingState = createMessageDedupState();
+    const incomingState = createMessageDedupState([], [], [], { preserveFallbackMultiplicity });
     const memberIdMap = /* @__PURE__ */ new Map();
     const existingMembers = db.prepare("SELECT id, platform_id FROM member").all();
     for (const m of existingMembers) {
@@ -9105,7 +9178,8 @@ async function incrementalImport(sessionId, filePath, deps, options2) {
               incomingState,
               { ...msg, timestamp },
               existingBatchPlatformIds,
-              candidateCache
+              candidateCache,
+              preserveFallbackMultiplicity
             )) {
               duplicateCount++;
               continue;
@@ -11693,7 +11767,8 @@ function buildContactsSignature(adapter, timeRangePreset) {
     `algorithm:${CONTACTS_ALGORITHM_VERSION}`,
     `range:${normalizeContactsTimeRangePreset(timeRangePreset)}`
   ];
-  for (const sessionId of [...adapter.listSessionIds()].sort()) {
+  const sessionIds = adapter.listSessionCandidateIds?.() ?? adapter.listSessionIds();
+  for (const sessionId of [...sessionIds].sort()) {
     const dbPath = adapter.getDbPath(sessionId);
     parts.push(`${sessionId}:${getDbFileVersion(dbPath)}`);
   }
@@ -11941,6 +12016,7 @@ var DefaultContactsService = class {
   }
   ensureTaskStarted(signature, timeRangePreset) {
     if (this.inFlight) return;
+    const sessionIds = this.deps.adapter.listSessionCandidateIds?.() ?? this.deps.adapter.listSessionIds();
     const taskId = `contacts_${this.now()}_${Math.random().toString(36).slice(2)}`;
     this.task = {
       id: taskId,
@@ -11948,7 +12024,7 @@ var DefaultContactsService = class {
       startedAt: this.now(),
       finishedAt: null,
       processedSessions: 0,
-      totalSessions: this.deps.adapter.listSessionIds().length,
+      totalSessions: sessionIds.length,
       timeRangePreset
     };
     const abortController = new AbortController();
@@ -12220,6 +12296,1821 @@ __export(contacts_exports, {
   getContactsFactsCacheDir: () => getContactsFactsCacheDir
 });
 
+// ../../packages/node-runtime/src/services/cross-chat-analysis/service.ts
+import { createHash as createHash2 } from "crypto";
+var DEFAULT_MAX_SESSIONS = 24;
+var MAX_MAX_SESSIONS = 100;
+var DEFAULT_MAX_EVIDENCE = 1e3;
+var MAX_MAX_EVIDENCE = 1e3;
+var DEFAULT_MAX_WALL_TIME_MS = 8e3;
+var MAX_MAX_WALL_TIME_MS = 3e4;
+var DEFAULT_CONTEXT_SIZE = 10;
+var MAX_CONTEXT_SIZE = 50;
+var RECENT_SESSION_MESSAGE_LIMIT = 200;
+var RECENT_SESSION_SUMMARY_LIMIT = 5;
+var SEARCH_CONTEXT_BEFORE = 2;
+var SEARCH_CONTEXT_AFTER = 2;
+var MAX_RECENT_DAYS = 3650;
+var CONTACT_SESSIONS_ALGORITHM_VERSION = "contact-sessions-v1";
+var DEFAULT_INSPECTION_PAGE_SIZE = 50;
+var MAX_INSPECTION_PAGE_SIZE = 100;
+var SHARED_INTERACTIONS_ALGORITHM_VERSION = "shared-interactions-v1";
+var PROXIMITY_ALGORITHM_VERSION = "lookahead-3-decay-120-gap-1800-v2";
+var DEFAULT_SHARED_INTERACTIONS_PAGE_SIZE = 20;
+var MAX_SHARED_INTERACTIONS_PAGE_SIZE = 50;
+var DEFAULT_MAX_ANCHORS_PER_PAIR = 4;
+var MAX_MAX_ANCHORS_PER_PAIR = 8;
+var PRIVATE_CONTACTS_RANKING_ALGORITHM_VERSION = "private-contacts-ranking-v1";
+var GROUP_SESSIONS_RANKING_ALGORITHM_VERSION = "group-sessions-ranking-v1";
+var DEFAULT_RANKING_LIMIT = 10;
+var MAX_RANKING_LIMIT = 50;
+var RANKING_MAX_WALL_TIME_MS = 3e4;
+var OVERVIEW_TOP_MEMBERS_LIMIT = 5;
+function createCrossChatAnalysisService(deps) {
+  return new DefaultCrossChatAnalysisService(deps);
+}
+var DefaultCrossChatAnalysisService = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  lookupContact(rawQuery) {
+    const query = rawQuery.trim();
+    const response = this.deps.contactsService.getContactsPage({
+      acceptStale: true,
+      page: 1,
+      pageSize: 200,
+      query,
+      timeRangePreset: "all"
+    });
+    const normalizedQuery = normalizeContactName(query);
+    const exactMatches = response.contacts.filter(
+      (contact) => [contact.displayName, ...contact.aliases].some((name) => normalizeContactName(name) === normalizedQuery)
+    );
+    const matchedContacts = exactMatches.length > 0 ? exactMatches : response.contacts;
+    const totalCandidates = exactMatches.length > 0 ? exactMatches.length : response.pagination.total;
+    const candidates = matchedContacts.slice(0, 8).map((contact) => {
+      const detail = this.deps.contactsService.getContactDetail(contact.key, {
+        acceptStale: true,
+        timeRangePreset: "all"
+      });
+      return {
+        contactKey: contact.key,
+        displayName: contact.displayName,
+        platform: contact.platform,
+        aliases: contact.aliases,
+        sourceSessions: detail.contact?.sourceSessions.map((session) => ({
+          id: session.id,
+          name: session.name,
+          type: session.type
+        })) ?? []
+      };
+    });
+    const status = totalCandidates === 1 ? "resolved" : totalCandidates > 1 ? "ambiguous" : response.cache.status === "missing" || response.task?.status === "running" ? "unavailable" : "not_found";
+    return {
+      query,
+      status,
+      cacheStatus: response.cache.status,
+      totalCandidates,
+      candidates
+    };
+  }
+  async resolveEntities(refs, options2 = {}) {
+    throwIfAborted(options2.signal);
+    const contacts = [];
+    const sessions = [];
+    const unresolved = [];
+    const candidateSessionIds = /* @__PURE__ */ new Set();
+    const resolvedSessionIds = /* @__PURE__ */ new Set();
+    const failedSessionIds = /* @__PURE__ */ new Set();
+    for (const ref of refs) {
+      throwIfAborted(options2.signal);
+      if (ref.type === "session") {
+        candidateSessionIds.add(ref.sessionId);
+        const descriptor = this.tryGetSessionDescriptor(ref.sessionId);
+        if (descriptor) {
+          resolvedSessionIds.add(ref.sessionId);
+          sessions.push({ ref, status: "resolved", session: descriptor });
+        } else {
+          failedSessionIds.add(ref.sessionId);
+          sessions.push({ ref, status: "unresolved" });
+          unresolved.push({ ref, reason: "session_not_found" });
+        }
+        await yieldToEventLoop2();
+        continue;
+      }
+      const detail = this.deps.contactsService.getContactDetail(ref.contactKey, {
+        acceptStale: true,
+        timeRangePreset: "all"
+      });
+      const contact = detail.contact;
+      if (!contact) {
+        contacts.push({
+          ref,
+          status: "unresolved",
+          cacheStatus: detail.cache.status,
+          sessions: [],
+          unresolvedSessionIds: [],
+          failedSessionIds: []
+        });
+        unresolved.push({
+          ref,
+          reason: detail.cache.status === "missing" ? "contact_snapshot_missing" : "contact_not_found"
+        });
+        await yieldToEventLoop2();
+        continue;
+      }
+      const sourceSessions = contact.sessionScoped ? contact.sourceSessions.filter((source) => source.id === contact.sessionId) : contact.sourceSessions;
+      const resolvedContactSessions = [];
+      const unresolvedContactSessions = [];
+      const failedContactSessions = [];
+      for (const source of sourceSessions) {
+        throwIfAborted(options2.signal);
+        candidateSessionIds.add(source.id);
+        try {
+          const db = this.deps.adapter.openReadonly(source.id);
+          if (!db) {
+            failedContactSessions.push(source.id);
+            failedSessionIds.add(source.id);
+            continue;
+          }
+          const descriptor = getSessionDescriptor(source.id, db);
+          const member = resolveContactMember(db, contact.platformId);
+          if (!descriptor || !member) {
+            unresolvedContactSessions.push(source.id);
+            continue;
+          }
+          resolvedContactSessions.push({
+            ...descriptor,
+            memberId: member.id,
+            memberPlatformId: member.platformId,
+            memberName: member.name
+          });
+          resolvedSessionIds.add(source.id);
+        } catch (error) {
+          failedContactSessions.push(source.id);
+          failedSessionIds.add(source.id);
+          appLogger.warn("cross-chat-analysis", `failed to resolve contact in source session: ${source.id}`, error);
+        } finally {
+          await yieldToEventLoop2();
+        }
+      }
+      const status = resolvedContactSessions.length === 0 ? "unresolved" : unresolvedContactSessions.length > 0 || failedContactSessions.length > 0 ? "partial" : "resolved";
+      contacts.push({
+        ref,
+        status,
+        cacheStatus: detail.cache.status,
+        sessions: resolvedContactSessions,
+        unresolvedSessionIds: unresolvedContactSessions,
+        failedSessionIds: failedContactSessions
+      });
+      if (status === "unresolved") unresolved.push({ ref, reason: "member_not_found" });
+      if (sourceSessions.length === 0) await yieldToEventLoop2();
+    }
+    throwIfAborted(options2.signal);
+    return {
+      contacts,
+      sessions,
+      unresolved,
+      coverage: {
+        requestedEntities: refs.length,
+        resolvedEntities: contacts.filter((item) => item.status !== "unresolved").length + sessions.filter((item) => item.status === "resolved").length,
+        candidateSessions: candidateSessionIds.size,
+        resolvedSessions: resolvedSessionIds.size,
+        failedSessions: failedSessionIds.size
+      }
+    };
+  }
+  async inspectContactSessions(request, options2 = {}) {
+    throwIfAborted(options2.signal);
+    const contactKey = request.contactKey.trim();
+    if (!contactKey) throw new Error("contactKey is required");
+    const rangeRequest = normalizeInspectionRangeRequest(request.startTs, request.endTs, request.recentDays);
+    const requestedRange = resolveInspectionRange(rangeRequest, () => this.now());
+    const includeRosterOnly = request.includeRosterOnly !== false;
+    const pageSize = clampInteger(request.pageSize, DEFAULT_INSPECTION_PAGE_SIZE, 1, MAX_INSPECTION_PAGE_SIZE);
+    const maxWallTimeMs = clampInteger(request.maxWallTimeMs, DEFAULT_MAX_WALL_TIME_MS, 1, MAX_MAX_WALL_TIME_MS);
+    const detail = this.deps.contactsService.getContactDetail(contactKey, {
+      acceptStale: true,
+      timeRangePreset: "all"
+    });
+    const contact = detail.contact;
+    if (!contact) {
+      return emptyContactSessionsResult(detail.cache.status, requestedRange);
+    }
+    const startedAt = this.now();
+    const candidateSessionIds = contact.sessionScoped ? contact.sessionId ? [contact.sessionId] : [] : [...new Set(this.deps.adapter.listSessionCandidateIds?.() ?? this.deps.adapter.listSessionIds())].sort(
+      (left, right) => left.localeCompare(right)
+    );
+    const cursor = parseInspectionCursor(
+      request.cursor,
+      (range2) => createInspectionFingerprint({
+        candidateSessionIds,
+        contactKey,
+        rangeRequest,
+        startTs: range2.startTs,
+        endTs: range2.endTs,
+        includeRosterOnly
+      }),
+      candidateSessionIds,
+      requestedRange
+    );
+    const range = cursor.range;
+    const sessions = [];
+    const failedSessionIds = [];
+    const truncatedReasons = /* @__PURE__ */ new Set();
+    let scannedSessions = 0;
+    let nextCandidateIndex = cursor.nextCandidateIndex;
+    let dataEarliestMessageTs = null;
+    let dataLatestMessageTs = null;
+    options2.onProgress?.({ processedSessions: 0, totalSessions: candidateSessionIds.length });
+    while (nextCandidateIndex < candidateSessionIds.length && sessions.length < pageSize) {
+      throwIfAborted(options2.signal);
+      if (this.now() - startedAt >= maxWallTimeMs) {
+        truncatedReasons.add("time_budget");
+        break;
+      }
+      const sessionId = candidateSessionIds[nextCandidateIndex];
+      options2.onProgress?.({
+        processedSessions: nextCandidateIndex,
+        totalSessions: candidateSessionIds.length,
+        currentSessionId: sessionId
+      });
+      try {
+        const db = this.deps.adapter.openReadonly(sessionId);
+        if (!db) {
+          failedSessionIds.push(sessionId);
+        } else {
+          const descriptor = getSessionDescriptor(sessionId, db);
+          const meta = getSessionMeta(db);
+          if (descriptor && meta?.platform === contact.platform) {
+            const member = getNonSystemMembersForContacts(db).find((item) => item.platformId === contact.platformId);
+            if (member) {
+              const facts = getParticipantSessionFacts(db, member.id, range);
+              if (includeRosterOnly || facts.ownMessageCount > 0) {
+                sessions.push({
+                  ...descriptor,
+                  memberId: member.id,
+                  memberName: member.name,
+                  presence: facts.ownMessageCount > 0 ? "spoke" : "roster_only",
+                  presenceObservedInRange: facts.ownMessageCount > 0,
+                  ownMessageCount: facts.ownMessageCount,
+                  sessionMessageCount: facts.sessionMessageCount,
+                  messageShare: facts.sessionMessageCount > 0 ? facts.ownMessageCount / facts.sessionMessageCount : null,
+                  firstOwnMessageTs: facts.firstOwnMessageTs,
+                  lastOwnMessageTs: facts.lastOwnMessageTs,
+                  activeDays: facts.activeDays,
+                  memberCount: descriptor.sessionType === "group" /* GROUP */ ? facts.memberCount : null,
+                  sessionFirstMessageTs: facts.sessionFirstMessageTs,
+                  lastMessageTs: facts.sessionLastMessageTs
+                });
+                dataEarliestMessageTs = minNullable(dataEarliestMessageTs, facts.sessionFirstMessageTs);
+                dataLatestMessageTs = maxNullable(dataLatestMessageTs, facts.sessionLastMessageTs);
+              }
+            }
+          }
+        }
+      } catch (error) {
+        failedSessionIds.push(sessionId);
+        appLogger.warn("cross-chat-analysis", `failed to inspect contact session: ${sessionId}`, error);
+      } finally {
+        scannedSessions++;
+        nextCandidateIndex++;
+      }
+      await yieldToEventLoop2();
+    }
+    if (sessions.length >= pageSize && nextCandidateIndex < candidateSessionIds.length) {
+      truncatedReasons.add("page_size");
+    }
+    const complete = nextCandidateIndex >= candidateSessionIds.length;
+    const nextCursor = complete ? null : createInspectionCursor(cursor.fingerprint, candidateSessionIds[nextCandidateIndex - 1] ?? null, range);
+    options2.onProgress?.({ processedSessions: nextCandidateIndex, totalSessions: candidateSessionIds.length });
+    return {
+      algorithmVersion: CONTACT_SESSIONS_ALGORITHM_VERSION,
+      contact: {
+        contactKey: contact.key,
+        displayName: contact.displayName,
+        platform: contact.platform,
+        sessionScoped: contact.sessionScoped
+      },
+      appliedRange: {
+        ...range,
+        dataEarliestMessageTs,
+        dataLatestMessageTs
+      },
+      summary: summarizeContactSessions(sessions, !request.cursor && complete),
+      sessions,
+      coverage: {
+        candidateSessions: candidateSessionIds.length,
+        scannedSessions,
+        matchedSessions: sessions.length,
+        returnedSessions: sessions.length,
+        failedSessions: failedSessionIds.length,
+        failedSessionIds,
+        complete,
+        nextCursor,
+        truncated: truncatedReasons.size > 0,
+        truncatedReasons: [...truncatedReasons],
+        contactCacheStatus: detail.cache.status
+      }
+    };
+  }
+  async inspectSharedInteractions(request, options2 = {}) {
+    throwIfAborted(options2.signal);
+    const participantRefs = normalizeParticipantRefs(request.participants);
+    const rangeRequest = normalizeInspectionRangeRequest(request.startTs, request.endTs, request.recentDays);
+    const requestedRange = resolveInspectionRange(rangeRequest, () => this.now());
+    const pageSize = clampInteger(
+      request.pageSize,
+      DEFAULT_SHARED_INTERACTIONS_PAGE_SIZE,
+      1,
+      MAX_SHARED_INTERACTIONS_PAGE_SIZE
+    );
+    const maxAnchorsPerPair = clampInteger(
+      request.maxAnchorsPerPair,
+      DEFAULT_MAX_ANCHORS_PER_PAIR,
+      0,
+      MAX_MAX_ANCHORS_PER_PAIR
+    );
+    const maxWallTimeMs = clampInteger(request.maxWallTimeMs, DEFAULT_MAX_WALL_TIME_MS, 1, MAX_MAX_WALL_TIME_MS);
+    const startedAt = this.now();
+    const resolvedParticipants = participantRefs.map((ref, index) => {
+      if (ref.type === "owner") {
+        return {
+          index,
+          ref,
+          status: "resolved",
+          displayName: "owner",
+          platform: void 0,
+          cacheStatus: void 0,
+          contact: void 0
+        };
+      }
+      const detail = this.deps.contactsService.getContactDetail(ref.contactKey, {
+        acceptStale: true,
+        timeRangePreset: "all"
+      });
+      return {
+        index,
+        ref,
+        status: detail.contact ? "resolved" : "unresolved",
+        displayName: detail.contact?.displayName ?? ref.contactKey,
+        platform: detail.contact?.platform,
+        cacheStatus: detail.cache.status,
+        contact: detail.contact
+      };
+    });
+    const unresolvedParticipantIndexes = resolvedParticipants.filter((participant) => participant.status === "unresolved").map((participant) => participant.index);
+    const publicParticipants = resolvedParticipants.map(({ contact: _contact, ...participant }) => participant);
+    if (unresolvedParticipantIndexes.length > 0) {
+      return emptySharedInteractionsResult(publicParticipants, unresolvedParticipantIndexes, requestedRange);
+    }
+    throwIfAborted(options2.signal);
+    const sessionScopedIds = resolvedParticipants.flatMap(
+      (participant) => participant.ref.type === "contact" && participant.contact?.sessionScoped && participant.contact.sessionId ? [participant.contact.sessionId] : []
+    ).filter((sessionId, index, all) => all.indexOf(sessionId) === index);
+    const candidateSessionIds = (sessionScopedIds.length > 1 ? [] : sessionScopedIds.length === 1 ? sessionScopedIds : [...new Set(this.deps.adapter.listSessionCandidateIds?.() ?? this.deps.adapter.listSessionIds())]).sort((left, right) => left.localeCompare(right));
+    throwIfAborted(options2.signal);
+    const cursor = parseInspectionCursor(
+      request.cursor,
+      (range2) => createInspectionFingerprint({
+        candidateSessionIds,
+        participantRefs,
+        rangeRequest,
+        startTs: range2.startTs,
+        endTs: range2.endTs,
+        maxAnchorsPerPair
+      }),
+      candidateSessionIds,
+      requestedRange
+    );
+    const range = cursor.range;
+    const sessions = [];
+    const failedSessionIds = [];
+    const truncatedReasons = /* @__PURE__ */ new Set();
+    const ownerResolution = participantRefs.some((ref) => ref.type === "owner") ? { resolvedSessions: 0, missingOwnerSessions: 0, unresolvedOwnerSessions: 0 } : void 0;
+    let identityCollisionSessions = 0;
+    let scannedSessions = 0;
+    let nextCandidateIndex = cursor.nextCandidateIndex;
+    let dataEarliestMessageTs = null;
+    let dataLatestMessageTs = null;
+    options2.onProgress?.({ processedSessions: 0, totalSessions: candidateSessionIds.length });
+    while (nextCandidateIndex < candidateSessionIds.length && sessions.length < pageSize) {
+      throwIfAborted(options2.signal);
+      if (this.now() - startedAt >= maxWallTimeMs) {
+        truncatedReasons.add("time_budget");
+        break;
+      }
+      const sessionId = candidateSessionIds[nextCandidateIndex];
+      options2.onProgress?.({
+        processedSessions: nextCandidateIndex,
+        totalSessions: candidateSessionIds.length,
+        currentSessionId: sessionId
+      });
+      try {
+        const db = this.deps.adapter.openReadonly(sessionId);
+        if (!db) {
+          failedSessionIds.push(sessionId);
+        } else {
+          const descriptor = getSessionDescriptor(sessionId, db);
+          const meta = getSessionMeta(db);
+          if (descriptor && meta) {
+            const members = getNonSystemMembersForContacts(db);
+            const participantMembers = resolvedParticipants.map((participant) => {
+              if (participant.ref.type === "owner") {
+                if (!meta.ownerId?.trim()) {
+                  if (ownerResolution) ownerResolution.missingOwnerSessions++;
+                  return null;
+                }
+                const owner = members.find((member) => member.platformId === meta.ownerId);
+                if (!owner) {
+                  if (ownerResolution) ownerResolution.unresolvedOwnerSessions++;
+                  return null;
+                }
+                if (ownerResolution) ownerResolution.resolvedSessions++;
+                return owner;
+              }
+              if (!participant.contact || participant.contact.platform !== meta.platform) return null;
+              return members.find((member) => member.platformId === participant.contact?.platformId) ?? null;
+            });
+            if (participantMembers.every((member) => member !== null)) {
+              const resolvedMembers = participantMembers.filter((member) => member !== null);
+              if (new Set(resolvedMembers.map((member) => member.id)).size !== resolvedMembers.length) {
+                identityCollisionSessions++;
+              } else {
+                const facts = getParticipantSetInteractionFacts(
+                  db,
+                  resolvedMembers.map((member) => member.id),
+                  {
+                    ...range,
+                    maxAnchorsPerPair
+                  }
+                );
+                const participantIndexByMemberId = new Map(
+                  resolvedMembers.map((member, index) => [member.id, resolvedParticipants[index].index])
+                );
+                const item = mapSharedInteractionSession(descriptor, resolvedMembers, participantIndexByMemberId, facts);
+                sessions.push(item);
+                dataEarliestMessageTs = minNullable(dataEarliestMessageTs, facts.sessionFirstMessageTs);
+                dataLatestMessageTs = maxNullable(dataLatestMessageTs, facts.sessionLastMessageTs);
+                if (facts.proximityStatus !== "complete") truncatedReasons.add("message_budget");
+              }
+            }
+          }
+        }
+      } catch (error) {
+        failedSessionIds.push(sessionId);
+        appLogger.warn("cross-chat-analysis", `failed to inspect shared interactions: ${sessionId}`, error);
+      } finally {
+        scannedSessions++;
+        nextCandidateIndex++;
+      }
+      await yieldToEventLoop2();
+    }
+    if (sessions.length >= pageSize && nextCandidateIndex < candidateSessionIds.length) {
+      truncatedReasons.add("page_size");
+    }
+    sessions.sort(compareSharedInteractionSessions);
+    const complete = nextCandidateIndex >= candidateSessionIds.length;
+    const nextCursor = complete ? null : createInspectionCursor(cursor.fingerprint, candidateSessionIds[nextCandidateIndex - 1] ?? null, range);
+    options2.onProgress?.({ processedSessions: nextCandidateIndex, totalSessions: candidateSessionIds.length });
+    return {
+      algorithmVersion: SHARED_INTERACTIONS_ALGORITHM_VERSION,
+      proximityAlgorithmVersion: PROXIMITY_ALGORITHM_VERSION,
+      participants: publicParticipants,
+      appliedRange: {
+        ...range,
+        dataEarliestMessageTs,
+        dataLatestMessageTs
+      },
+      summary: summarizeSharedInteractions(sessions, !request.cursor && complete),
+      sessions,
+      coverage: {
+        candidateSessions: candidateSessionIds.length,
+        scannedSessions,
+        matchedSessions: sessions.length,
+        returnedSessions: sessions.length,
+        failedSessions: failedSessionIds.length,
+        failedSessionIds,
+        complete,
+        nextCursor,
+        truncated: truncatedReasons.size > 0,
+        truncatedReasons: [...truncatedReasons],
+        unresolvedParticipantIndexes,
+        identityCollisionSessions,
+        ownerResolution
+      }
+    };
+  }
+  async searchMessages(request, options2 = {}) {
+    const keywords = request.keywords.map((keyword) => keyword.trim()).filter(Boolean);
+    if (keywords.length === 0 && (!request.scopes || request.scopes.length === 0)) {
+      throw new Error("At least one search keyword is required for an unscoped search");
+    }
+    throwIfAborted(options2.signal);
+    const sender = request.sender === "owner" ? "owner" : "all";
+    const recentDays = normalizeRecentDays(request.recentDays);
+    const effectiveRecentDays = request.startTs === void 0 ? recentDays : void 0;
+    let startTs = request.startTs;
+    let endTs = request.endTs;
+    if (effectiveRecentDays !== void 0) {
+      const range = normalizeInspectionRange(void 0, endTs, effectiveRecentDays, () => this.now());
+      startTs = range.startTs ?? void 0;
+      endTs = range.endTs ?? void 0;
+    }
+    const ownerResolution = sender === "owner" ? { resolvedSessions: 0, missingOwnerSessions: 0, unresolvedOwnerSessions: 0 } : void 0;
+    const maxSessions = clampInteger(request.maxSessions, DEFAULT_MAX_SESSIONS, 1, MAX_MAX_SESSIONS);
+    const maxEvidence = clampInteger(request.maxEvidence, DEFAULT_MAX_EVIDENCE, 1, MAX_MAX_EVIDENCE);
+    const maxWallTimeMs = clampInteger(request.maxWallTimeMs, DEFAULT_MAX_WALL_TIME_MS, 1, MAX_MAX_WALL_TIME_MS);
+    const startedAt = this.now();
+    const failedSessionIds = /* @__PURE__ */ new Set();
+    const { candidates, candidateSessionCount, eligibleCandidateCount, timedOut } = await this.resolveSearchCandidates(
+      request.scopes,
+      failedSessionIds,
+      sender,
+      ownerResolution,
+      maxSessions,
+      startedAt + maxWallTimeMs,
+      options2.signal
+    );
+    const selected = candidates;
+    const truncatedReasons = /* @__PURE__ */ new Set();
+    if (eligibleCandidateCount > selected.length) truncatedReasons.add("session_budget");
+    if (timedOut) truncatedReasons.add("time_budget");
+    const sessionResults = [];
+    let totalMatches = 0;
+    let scannedSessions = 0;
+    let matchedSessions = 0;
+    let processedSessions = 0;
+    options2.onProgress?.({ processedSessions: 0, totalSessions: selected.length });
+    for (const [index, candidate] of selected.entries()) {
+      throwIfAborted(options2.signal);
+      if (this.now() - startedAt >= maxWallTimeMs) {
+        truncatedReasons.add("time_budget");
+        break;
+      }
+      options2.onProgress?.({
+        processedSessions: index,
+        totalSessions: selected.length,
+        currentSessionId: candidate.descriptor.sessionId
+      });
+      throwIfAborted(options2.signal);
+      try {
+        const db = this.deps.adapter.openReadonly(candidate.descriptor.sessionId);
+        if (!db) {
+          failedSessionIds.add(candidate.descriptor.sessionId);
+          continue;
+        }
+        const result = searchMessagesByKeywords(db, keywords, {
+          startTs,
+          endTs,
+          senderIds: candidate.memberIds,
+          matchMode: request.matchMode,
+          sort: request.sort,
+          limit: maxEvidence
+        });
+        scannedSessions++;
+        totalMatches += result.total ?? result.messages.length;
+        if (result.messages.length > 0) matchedSessions++;
+        if ((result.total ?? result.messages.length) > result.messages.length) truncatedReasons.add("evidence_budget");
+        sessionResults.push({
+          candidate,
+          db,
+          totalMatches: result.total ?? result.messages.length,
+          matches: result.messages.map((message) => ({
+            ...toCrossChatMessage(candidate.descriptor, message),
+            evidenceRole: "match"
+          }))
+        });
+      } catch (error) {
+        failedSessionIds.add(candidate.descriptor.sessionId);
+        appLogger.warn("cross-chat-analysis", `failed to search session: ${candidate.descriptor.sessionId}`, error);
+      } finally {
+        processedSessions++;
+      }
+      await yieldToEventLoop2();
+    }
+    sessionResults.sort(compareSessionSearchResults);
+    const evidence = collectSearchEvidence(sessionResults, maxEvidence, startTs, endTs, {
+      deadline: startedAt + maxWallTimeMs,
+      now: () => this.now(),
+      signal: options2.signal
+    });
+    const messages = evidence.messages;
+    if (evidence.timedOut) truncatedReasons.add("time_budget");
+    const returnedMatchCount = messages.filter((message) => message.evidenceRole === "match").length;
+    if (returnedMatchCount < totalMatches) truncatedReasons.add("evidence_budget");
+    const sortMultiplier = request.sort === "asc" ? 1 : -1;
+    messages.sort(
+      (left, right) => (left.timestamp - right.timestamp || left.sessionId.localeCompare(right.sessionId) || left.messageId - right.messageId) * sortMultiplier
+    );
+    options2.onProgress?.({ processedSessions, totalSessions: selected.length });
+    return {
+      messages,
+      totalMatches,
+      appliedFilters: {
+        startTs: startTs ?? null,
+        endTs: endTs ?? null,
+        recentDays: effectiveRecentDays ?? null,
+        sender
+      },
+      coverage: {
+        candidateSessions: candidateSessionCount,
+        scannedSessions,
+        matchedSessions,
+        failedSessions: failedSessionIds.size,
+        ownerResolution,
+        truncated: truncatedReasons.size > 0,
+        truncatedReasons: [...truncatedReasons]
+      }
+    };
+  }
+  readRecentSession(sessionId) {
+    const db = this.deps.adapter.ensureReadonly(sessionId);
+    const descriptor = getSessionDescriptor(sessionId, db);
+    if (!descriptor) throw createNotFoundError(`Session not found: ${sessionId}`);
+    const recent = searchMessagesByKeywords(db, [], {
+      sort: "desc",
+      limit: RECENT_SESSION_MESSAGE_LIMIT
+    });
+    const summaries = getSegmentSummaries(db, { limit: RECENT_SESSION_SUMMARY_LIMIT }).filter((segment) => typeof segment.summary === "string").map((segment) => ({
+      segmentId: segment.id,
+      startTs: segment.startTs,
+      endTs: segment.endTs,
+      messageCount: segment.messageCount,
+      participants: segment.participants,
+      summary: segment.summary
+    }));
+    const messages = recent.messages.map((message) => toCrossChatMessage(descriptor, message));
+    const totalMessages = recent.total ?? messages.length;
+    return {
+      source: descriptor,
+      messages,
+      summaries,
+      coverage: {
+        totalMessages,
+        returnedMessages: messages.length,
+        returnedSummaries: summaries.length,
+        hasEarlierMessages: totalMessages > messages.length
+      }
+    };
+  }
+  async rankPrivateContacts(request, options2 = {}) {
+    throwIfAborted(options2.signal);
+    const range = normalizeInspectionRange(request.startTs, request.endTs, request.recentDays, () => this.now());
+    const rankBy = request.rankBy === "active_days" ? "active_days" : "message_count";
+    const limit = clampInteger(request.limit, DEFAULT_RANKING_LIMIT, 1, MAX_RANKING_LIMIT);
+    const excludedSessionIds = new Set(this.deps.getExcludedSessionIds?.() ?? []);
+    const sessionIds = this.deps.adapter.listSessionCandidateIds?.() ?? this.deps.adapter.listSessionIds();
+    const deadline = this.now() + RANKING_MAX_WALL_TIME_MS;
+    const accumulators = /* @__PURE__ */ new Map();
+    const failedSessionIds = [];
+    const coverage = {
+      candidateSessions: 0,
+      scannedSessions: 0,
+      analyzedSessions: 0,
+      excludedSessions: 0,
+      missingOwnerSessions: 0,
+      unresolvedOwnerSessions: 0,
+      missingContactSessions: 0,
+      ambiguousContactSessions: 0,
+      failedSessions: 0,
+      failedSessionIds,
+      complete: true,
+      truncated: false,
+      truncatedReasons: []
+    };
+    let dataEarliestMessageTs = null;
+    let dataLatestMessageTs = null;
+    let processedSessions = 0;
+    options2.onProgress?.({ processedSessions: 0, totalSessions: sessionIds.length });
+    for (const [index, sessionId] of sessionIds.entries()) {
+      throwIfAborted(options2.signal);
+      if (this.now() >= deadline) {
+        coverage.truncated = true;
+        coverage.truncatedReasons.push("time_budget");
+        break;
+      }
+      options2.onProgress?.({ processedSessions: index, totalSessions: sessionIds.length, currentSessionId: sessionId });
+      try {
+        const db = this.deps.adapter.openReadonly(sessionId);
+        if (!db) {
+          coverage.failedSessions++;
+          failedSessionIds.push(sessionId);
+          continue;
+        }
+        const descriptor = getSessionDescriptor(sessionId, db);
+        if (!descriptor || descriptor.sessionType !== "private" /* PRIVATE */) continue;
+        coverage.candidateSessions++;
+        coverage.scannedSessions++;
+        if (excludedSessionIds.has(sessionId)) {
+          coverage.excludedSessions++;
+          continue;
+        }
+        const facts = getCrossChatSessionActivityFacts(db, range);
+        dataEarliestMessageTs = minNullable(dataEarliestMessageTs, facts.dataEarliestMessageTs);
+        dataLatestMessageTs = maxNullable(dataLatestMessageTs, facts.dataLatestMessageTs);
+        const meta = getSessionMeta(db);
+        if (!meta?.ownerId?.trim()) {
+          coverage.missingOwnerSessions++;
+          continue;
+        }
+        const owner = resolveOwnerMember(db);
+        if (!owner) {
+          coverage.unresolvedOwnerSessions++;
+          continue;
+        }
+        const candidates = getNonSystemMembersForContacts(db).filter((member) => member.id !== owner.id);
+        if (candidates.length === 0) {
+          coverage.missingContactSessions++;
+          continue;
+        }
+        const activeMemberIds = new Set(
+          facts.members.filter((member) => member.messageCount > 0).map((member) => member.memberId)
+        );
+        const activeCandidates = candidates.filter((candidate) => activeMemberIds.has(candidate.id));
+        const resolvedCandidates = activeCandidates.length > 0 ? activeCandidates : candidates;
+        if (resolvedCandidates.length > 1) {
+          coverage.ambiguousContactSessions++;
+          continue;
+        }
+        coverage.analyzedSessions++;
+        if (facts.totalMessages === 0) continue;
+        const contact = resolvedCandidates[0];
+        const contactKey = buildContactKey(
+          descriptor.platform,
+          contact.platformId,
+          shouldScopeContactToSession(descriptor.platform, contact) ? sessionId : void 0
+        );
+        const ownerActivity = facts.members.find((member) => member.memberId === owner.id);
+        const contactActivity = facts.members.find((member) => member.memberId === contact.id);
+        const accumulator = accumulators.get(contactKey) ?? {
+          contactKey,
+          platformId: contact.platformId,
+          displayName: pickPreferredContactDisplayName(contact.platformId, contact.name, descriptor.sessionName),
+          platform: descriptor.platform,
+          totalMessages: 0,
+          ownerMessages: 0,
+          contactMessages: 0,
+          activeDayKeys: /* @__PURE__ */ new Set(),
+          firstMessageTs: null,
+          lastMessageTs: null,
+          sessionIds: []
+        };
+        accumulator.displayName = pickPreferredContactDisplayName(
+          contact.platformId,
+          accumulator.displayName,
+          contact.name,
+          descriptor.sessionName
+        );
+        accumulator.totalMessages += facts.totalMessages;
+        accumulator.ownerMessages += ownerActivity?.messageCount ?? 0;
+        accumulator.contactMessages += contactActivity?.messageCount ?? 0;
+        facts.activeDayKeys.forEach((day) => accumulator.activeDayKeys.add(day));
+        accumulator.firstMessageTs = minNullable(accumulator.firstMessageTs, facts.firstMessageTs);
+        accumulator.lastMessageTs = maxNullable(accumulator.lastMessageTs, facts.lastMessageTs);
+        accumulator.sessionIds.push(sessionId);
+        accumulators.set(contactKey, accumulator);
+      } catch (error) {
+        coverage.failedSessions++;
+        failedSessionIds.push(sessionId);
+        appLogger.warn("cross-chat-analysis", `failed to rank private session: ${sessionId}`, error);
+      } finally {
+        processedSessions = index + 1;
+        await yieldToEventLoop2();
+      }
+    }
+    options2.onProgress?.({ processedSessions, totalSessions: sessionIds.length });
+    coverage.complete = !coverage.truncated && coverage.failedSessions === 0 && coverage.missingOwnerSessions === 0 && coverage.unresolvedOwnerSessions === 0 && coverage.missingContactSessions === 0 && coverage.ambiguousContactSessions === 0;
+    const ranked = [...accumulators.values()].sort(
+      (left, right) => comparePrivateContactRankAccumulators(left, right, rankBy)
+    );
+    const items = ranked.slice(0, limit).map((item, index) => {
+      const contactDetail = this.deps.contactsService.getContactDetail(item.contactKey, {
+        acceptStale: true,
+        timeRangePreset: "all"
+      });
+      return {
+        rank: index + 1,
+        contactKey: item.contactKey,
+        displayName: pickPreferredContactDisplayName(
+          item.platformId,
+          contactDetail.contact?.displayName,
+          item.displayName
+        ),
+        platform: item.platform,
+        totalMessages: item.totalMessages,
+        ownerMessages: item.ownerMessages,
+        contactMessages: item.contactMessages,
+        activeDays: item.activeDayKeys.size,
+        firstMessageTs: item.firstMessageTs,
+        lastMessageTs: item.lastMessageTs,
+        sessionIds: [...item.sessionIds].sort()
+      };
+    });
+    const currentTs = Math.floor(this.now() / 1e3);
+    return {
+      algorithmVersion: PRIVATE_CONTACTS_RANKING_ALGORITHM_VERSION,
+      rankBy,
+      appliedRange: {
+        ...range,
+        dataEarliestMessageTs,
+        dataLatestMessageTs,
+        currentTs
+      },
+      items,
+      coverage
+    };
+  }
+  async rankGroupSessions(request, options2 = {}) {
+    throwIfAborted(options2.signal);
+    if (request.mode !== "owner_activity" && request.mode !== "total_activity") {
+      throw new Error("mode must be owner_activity or total_activity");
+    }
+    const range = normalizeInspectionRange(request.startTs, request.endTs, request.recentDays, () => this.now());
+    const limit = clampInteger(request.limit, DEFAULT_RANKING_LIMIT, 1, MAX_RANKING_LIMIT);
+    const excludedSessionIds = new Set(this.deps.getExcludedSessionIds?.() ?? []);
+    const sessionIds = this.deps.adapter.listSessionCandidateIds?.() ?? this.deps.adapter.listSessionIds();
+    const deadline = this.now() + RANKING_MAX_WALL_TIME_MS;
+    const items = [];
+    const failedSessionIds = [];
+    const coverage = {
+      candidateSessions: 0,
+      scannedSessions: 0,
+      analyzedSessions: 0,
+      excludedSessions: 0,
+      missingOwnerSessions: 0,
+      unresolvedOwnerSessions: 0,
+      failedSessions: 0,
+      failedSessionIds,
+      complete: true,
+      truncated: false,
+      truncatedReasons: []
+    };
+    let dataEarliestMessageTs = null;
+    let dataLatestMessageTs = null;
+    let processedSessions = 0;
+    options2.onProgress?.({ processedSessions: 0, totalSessions: sessionIds.length });
+    for (const [index, sessionId] of sessionIds.entries()) {
+      throwIfAborted(options2.signal);
+      if (this.now() >= deadline) {
+        coverage.truncated = true;
+        coverage.truncatedReasons.push("time_budget");
+        break;
+      }
+      options2.onProgress?.({ processedSessions: index, totalSessions: sessionIds.length, currentSessionId: sessionId });
+      try {
+        const db = this.deps.adapter.openReadonly(sessionId);
+        if (!db) {
+          coverage.failedSessions++;
+          failedSessionIds.push(sessionId);
+          continue;
+        }
+        const descriptor = getSessionDescriptor(sessionId, db);
+        if (!descriptor || descriptor.sessionType !== "group" /* GROUP */) continue;
+        coverage.candidateSessions++;
+        coverage.scannedSessions++;
+        if (excludedSessionIds.has(sessionId)) {
+          coverage.excludedSessions++;
+          continue;
+        }
+        const facts = getCrossChatSessionActivityFacts(db, range);
+        dataEarliestMessageTs = minNullable(dataEarliestMessageTs, facts.dataEarliestMessageTs);
+        dataLatestMessageTs = maxNullable(dataLatestMessageTs, facts.dataLatestMessageTs);
+        const meta = getSessionMeta(db);
+        let ownerStatus = "missing";
+        let ownerMessages = null;
+        let ownerActiveDays = null;
+        if (!meta?.ownerId?.trim()) {
+          coverage.missingOwnerSessions++;
+        } else {
+          const owner = resolveOwnerMember(db);
+          if (!owner) {
+            ownerStatus = "unresolved";
+            coverage.unresolvedOwnerSessions++;
+          } else {
+            ownerStatus = "resolved";
+            const ownerActivity = facts.members.find((member) => member.memberId === owner.id);
+            ownerMessages = ownerActivity?.messageCount ?? 0;
+            ownerActiveDays = ownerActivity?.activeDays ?? 0;
+          }
+        }
+        if (request.mode === "owner_activity" && ownerStatus !== "resolved") continue;
+        coverage.analyzedSessions++;
+        if (facts.totalMessages === 0) continue;
+        items.push({
+          ...descriptor,
+          rank: 0,
+          lastMessageTs: facts.lastMessageTs,
+          totalMessages: facts.totalMessages,
+          ownerMessages,
+          ownerMessageShare: ownerMessages === null || facts.totalMessages === 0 ? null : roundRatio(ownerMessages, facts.totalMessages),
+          ownerActiveDays,
+          activeMembers: facts.activeMembers,
+          activeDays: facts.activeDays,
+          firstMessageTs: facts.firstMessageTs,
+          ownerStatus
+        });
+      } catch (error) {
+        coverage.failedSessions++;
+        failedSessionIds.push(sessionId);
+        appLogger.warn("cross-chat-analysis", `failed to rank group session: ${sessionId}`, error);
+      } finally {
+        processedSessions = index + 1;
+        await yieldToEventLoop2();
+      }
+    }
+    options2.onProgress?.({ processedSessions, totalSessions: sessionIds.length });
+    coverage.complete = !coverage.truncated && coverage.failedSessions === 0 && (request.mode === "total_activity" || coverage.missingOwnerSessions === 0 && coverage.unresolvedOwnerSessions === 0);
+    items.sort((left, right) => compareGroupSessionRankItems(left, right, request.mode));
+    const rankedItems = items.slice(0, limit).map((item, index) => ({ ...item, rank: index + 1 }));
+    return {
+      algorithmVersion: GROUP_SESSIONS_RANKING_ALGORITHM_VERSION,
+      mode: request.mode,
+      appliedRange: {
+        ...range,
+        dataEarliestMessageTs,
+        dataLatestMessageTs,
+        currentTs: Math.floor(this.now() / 1e3)
+      },
+      items: rankedItems,
+      coverage
+    };
+  }
+  getGlobalActivitySummary(request) {
+    const service = this.deps.globalInsightService;
+    if (!service) throw new Error("Global activity summary is unavailable in this runtime");
+    const mode = request.mode ?? "year";
+    if (mode !== "year" && mode !== "recent_365") {
+      throw new Error("mode must be year or recent_365");
+    }
+    if (request.year !== void 0 && (!Number.isInteger(request.year) || request.year < 1970)) {
+      throw new Error("year must be an integer greater than or equal to 1970");
+    }
+    const summary = service.getAnnualSummary(
+      mode === "recent_365" ? { mode: "recent", days: 365, acceptStale: true } : { mode: "year", year: request.year, acceptStale: true }
+    );
+    const dataState = summary.cache.status === "fresh" ? "fresh" : summary.cache.status === "stale" ? "stale" : summary.task.status === "failed" ? "failed" : "preparing";
+    return { mode, dataState, summary };
+  }
+  getMessageContext(request) {
+    const db = this.deps.adapter.ensureReadonly(request.sessionId);
+    const descriptor = getSessionDescriptor(request.sessionId, db);
+    if (!descriptor) throw createNotFoundError(`Session not found: ${request.sessionId}`);
+    const contextSize = clampInteger(request.contextSize, DEFAULT_CONTEXT_SIZE, 0, MAX_CONTEXT_SIZE);
+    const messages = getSearchMessageContext(db, [request.messageId], contextSize, contextSize);
+    if (!messages.some((message) => message.id === request.messageId)) {
+      throw createNotFoundError(`Message not found: ${request.messageId}`);
+    }
+    return {
+      source: descriptor,
+      messages: messages.map((message) => toCrossChatMessage(descriptor, message))
+    };
+  }
+  async getOverview(request, options2 = {}) {
+    throwIfAborted(options2.signal);
+    const scopes = normalizeOverviewScopes(request.scopes);
+    const range = normalizeInspectionRange(request.startTs, request.endTs, request.recentDays, () => this.now());
+    const maxSessions = clampInteger(request.maxSessions, DEFAULT_MAX_SESSIONS, 1, MAX_MAX_SESSIONS);
+    const maxWallTimeMs = clampInteger(request.maxWallTimeMs, DEFAULT_MAX_WALL_TIME_MS, 1, MAX_MAX_WALL_TIME_MS);
+    const selected = scopes.slice(0, maxSessions);
+    const excludedSessionIds = new Set(this.deps.getExcludedSessionIds?.() ?? []);
+    const startedAt = this.now();
+    const items = [];
+    let failedSessions = 0;
+    const failedSessionIds = [];
+    let excludedSessions = 0;
+    let missingOwnerSessions = 0;
+    let unresolvedOwnerSessions = 0;
+    let processedSessions = 0;
+    let dataEarliestMessageTs = null;
+    let dataLatestMessageTs = null;
+    const truncatedReasons = /* @__PURE__ */ new Set();
+    if (selected.length < scopes.length) truncatedReasons.add("session_budget");
+    options2.onProgress?.({ processedSessions: 0, totalSessions: selected.length });
+    for (const [index, scope] of selected.entries()) {
+      throwIfAborted(options2.signal);
+      if (this.now() - startedAt >= maxWallTimeMs) {
+        truncatedReasons.add("time_budget");
+        break;
+      }
+      options2.onProgress?.({
+        processedSessions: index,
+        totalSessions: selected.length,
+        currentSessionId: scope.sessionId
+      });
+      throwIfAborted(options2.signal);
+      try {
+        const db = this.deps.adapter.openReadonly(scope.sessionId);
+        if (!db) {
+          failedSessions++;
+          failedSessionIds.push(scope.sessionId);
+          continue;
+        }
+        const descriptor = getSessionDescriptor(scope.sessionId, db);
+        if (!descriptor) {
+          failedSessions++;
+          failedSessionIds.push(scope.sessionId);
+          continue;
+        }
+        const facts = getCrossChatSessionActivityFacts(db, range);
+        dataEarliestMessageTs = minNullable(dataEarliestMessageTs, facts.dataEarliestMessageTs);
+        dataLatestMessageTs = maxNullable(dataLatestMessageTs, facts.dataLatestMessageTs);
+        let ownerStatus = "missing";
+        let ownerMemberId = null;
+        if (excludedSessionIds.has(scope.sessionId)) {
+          ownerStatus = "excluded";
+          excludedSessions++;
+        } else {
+          const meta = getSessionMeta(db);
+          if (!meta?.ownerId?.trim()) {
+            missingOwnerSessions++;
+          } else {
+            const owner = resolveOwnerMember(db);
+            if (!owner) {
+              ownerStatus = "unresolved";
+              unresolvedOwnerSessions++;
+            } else {
+              ownerStatus = "resolved";
+              ownerMemberId = owner.id;
+            }
+          }
+        }
+        items.push(buildOverviewItem(descriptor, db, scope, facts, ownerStatus, ownerMemberId));
+      } catch (error) {
+        failedSessions++;
+        failedSessionIds.push(scope.sessionId);
+        appLogger.warn("cross-chat-analysis", `failed to build session overview: ${scope.sessionId}`, error);
+      } finally {
+        processedSessions++;
+      }
+      await yieldToEventLoop2();
+    }
+    options2.onProgress?.({ processedSessions, totalSessions: selected.length });
+    return {
+      appliedRange: {
+        ...range,
+        dataEarliestMessageTs,
+        dataLatestMessageTs,
+        currentTs: Math.floor(this.now() / 1e3)
+      },
+      items,
+      coverage: {
+        candidateSessions: scopes.length,
+        analyzedSessions: items.length,
+        excludedSessions,
+        missingOwnerSessions,
+        unresolvedOwnerSessions,
+        failedSessions,
+        failedSessionIds,
+        complete: truncatedReasons.size === 0 && failedSessions === 0,
+        truncated: truncatedReasons.size > 0,
+        truncatedReasons: [...truncatedReasons]
+      }
+    };
+  }
+  async resolveSearchCandidates(scopes, failedSessionIds, sender, ownerResolution, maxSessions = DEFAULT_MAX_SESSIONS, deadline = Number.POSITIVE_INFINITY, signal) {
+    throwIfAborted(signal);
+    const normalizedScopes = scopes ? normalizeScopes(scopes) : (this.deps.adapter.listSessionCandidateIds?.() ?? this.deps.adapter.listSessionIds()).map((sessionId) => ({
+      sessionId
+    }));
+    const candidates = [];
+    let eligibleCandidateCount = 0;
+    let timedOut = false;
+    for (const scope of normalizedScopes) {
+      throwIfAborted(signal);
+      if (this.now() >= deadline) {
+        timedOut = true;
+        break;
+      }
+      const descriptor = this.tryGetSessionDescriptor(scope.sessionId);
+      if (!descriptor) {
+        failedSessionIds.add(scope.sessionId);
+        await yieldToEventLoop2();
+        continue;
+      }
+      if (this.now() >= deadline) {
+        timedOut = true;
+        break;
+      }
+      if (sender === "owner") {
+        const db = this.deps.adapter.openReadonly(scope.sessionId);
+        if (!db) {
+          failedSessionIds.add(scope.sessionId);
+          await yieldToEventLoop2();
+          continue;
+        }
+        const meta = getSessionMeta(db);
+        if (!meta?.ownerId?.trim()) {
+          if (ownerResolution) ownerResolution.missingOwnerSessions++;
+          await yieldToEventLoop2();
+          continue;
+        }
+        const owner = resolveOwnerMember(db);
+        if (!owner) {
+          if (ownerResolution) ownerResolution.unresolvedOwnerSessions++;
+          await yieldToEventLoop2();
+          continue;
+        }
+        if (ownerResolution) ownerResolution.resolvedSessions++;
+        eligibleCandidateCount++;
+        addBoundedSearchCandidate(candidates, { descriptor, memberIds: [owner.id] }, maxSessions);
+      } else {
+        eligibleCandidateCount++;
+        addBoundedSearchCandidate(candidates, { descriptor, memberIds: scope.memberIds }, maxSessions);
+      }
+      await yieldToEventLoop2();
+    }
+    throwIfAborted(signal);
+    if (!timedOut && this.now() >= deadline) timedOut = true;
+    return {
+      candidates,
+      candidateSessionCount: normalizedScopes.length,
+      eligibleCandidateCount,
+      timedOut
+    };
+  }
+  tryGetSessionDescriptor(sessionId) {
+    try {
+      const db = this.deps.adapter.openReadonly(sessionId);
+      return db ? getSessionDescriptor(sessionId, db) : null;
+    } catch (error) {
+      appLogger.warn("cross-chat-analysis", `failed to inspect session metadata: ${sessionId}`, error);
+      return null;
+    }
+  }
+  now() {
+    return this.deps.now?.() ?? Date.now();
+  }
+};
+function normalizeContactName(value) {
+  return value.trim().toLocaleLowerCase();
+}
+function pickPreferredContactDisplayName(platformId, ...candidates) {
+  const normalizedPlatformId = platformId.trim();
+  for (const candidate of candidates) {
+    const value = candidate?.trim();
+    if (value && value !== normalizedPlatformId) return value;
+  }
+  return candidates.find((candidate) => candidate?.trim())?.trim() ?? normalizedPlatformId;
+}
+function normalizeRecentDays(value) {
+  if (value === void 0) return void 0;
+  if (!Number.isFinite(value) || value <= 0) throw new Error("recentDays must be a positive number");
+  return Math.min(MAX_RECENT_DAYS, Math.max(1, Math.floor(value)));
+}
+function comparePrivateContactRankAccumulators(left, right, rankBy) {
+  const primaryDifference = rankBy === "active_days" ? right.activeDayKeys.size - left.activeDayKeys.size : right.totalMessages - left.totalMessages;
+  return primaryDifference || (right.lastMessageTs ?? Number.NEGATIVE_INFINITY) - (left.lastMessageTs ?? Number.NEGATIVE_INFINITY) || left.contactKey.localeCompare(right.contactKey);
+}
+function compareGroupSessionRankItems(left, right, mode) {
+  const primaryDifference = mode === "owner_activity" ? (right.ownerMessages ?? Number.NEGATIVE_INFINITY) - (left.ownerMessages ?? Number.NEGATIVE_INFINITY) : right.totalMessages - left.totalMessages;
+  return primaryDifference || (right.lastMessageTs ?? Number.NEGATIVE_INFINITY) - (left.lastMessageTs ?? Number.NEGATIVE_INFINITY) || left.sessionId.localeCompare(right.sessionId);
+}
+function roundRatio(numerator, denominator) {
+  if (denominator <= 0) return 0;
+  return Math.round(numerator / denominator * 1e4) / 1e4;
+}
+function compareSessionSearchResults(left, right) {
+  const leftPrivate = left.candidate.descriptor.sessionType === "private" /* PRIVATE */;
+  const rightPrivate = right.candidate.descriptor.sessionType === "private" /* PRIVATE */;
+  if (leftPrivate !== rightPrivate) return leftPrivate ? -1 : 1;
+  return right.totalMatches - left.totalMatches || (right.candidate.descriptor.lastMessageTs ?? Number.NEGATIVE_INFINITY) - (left.candidate.descriptor.lastMessageTs ?? Number.NEGATIVE_INFINITY);
+}
+function collectSearchEvidence(results, maxMessages, startTs, endTs, options2 = {
+  deadline: Number.POSITIVE_INFINITY,
+  now: Date.now
+}) {
+  const selected = /* @__PURE__ */ new Map();
+  let timedOut = false;
+  for (const result of results) {
+    let matchIndex = 0;
+    while (matchIndex < result.matches.length && selected.size < maxMessages) {
+      throwIfAborted(options2.signal);
+      if (options2.now() >= options2.deadline) {
+        timedOut = true;
+        break;
+      }
+      const remaining = maxMessages - selected.size;
+      const expectedBlockSize = SEARCH_CONTEXT_BEFORE + SEARCH_CONTEXT_AFTER + 1;
+      const batchSize = Math.min(
+        result.matches.length - matchIndex,
+        remaining < expectedBlockSize ? 1 : Math.max(1, Math.floor(remaining / expectedBlockSize))
+      );
+      const batch = result.matches.slice(matchIndex, matchIndex + batchSize);
+      const matchIds = new Set(batch.map((message) => message.messageId));
+      const contextMessages = getSearchMessageContext(
+        result.db,
+        [...matchIds],
+        SEARCH_CONTEXT_BEFORE,
+        SEARCH_CONTEXT_AFTER
+      ).map((message) => ({
+        ...toCrossChatMessage(result.candidate.descriptor, message),
+        evidenceRole: matchIds.has(message.id) ? "match" : "context"
+      })).filter((message) => isWithinSearchRange(message.timestamp, startTs, endTs));
+      for (const matchId of matchIds) {
+        const key = crossChatMessageKey(result.candidate.descriptor.sessionId, matchId);
+        const existing = selected.get(key);
+        if (existing?.evidenceRole === "context") selected.set(key, { ...existing, evidenceRole: "match" });
+      }
+      const unseen = contextMessages.filter(
+        (message) => !selected.has(crossChatMessageKey(message.sessionId, message.messageId))
+      );
+      const accepted = unseen.length <= remaining ? unseen : prioritizeContextMessages(unseen, matchIds).slice(0, remaining);
+      for (const message of accepted) {
+        const key = crossChatMessageKey(message.sessionId, message.messageId);
+        const existing = selected.get(key);
+        if (!existing || existing.evidenceRole === "context" && message.evidenceRole === "match") {
+          selected.set(key, message);
+        }
+      }
+      matchIndex += batchSize;
+    }
+    if (timedOut || selected.size >= maxMessages) break;
+  }
+  return { messages: [...selected.values()], timedOut };
+}
+function prioritizeContextMessages(messages, matchIds) {
+  return [...messages].sort((left, right) => {
+    const leftMatch = matchIds.has(left.messageId);
+    const rightMatch = matchIds.has(right.messageId);
+    if (leftMatch !== rightMatch) return leftMatch ? -1 : 1;
+    const leftDistance = nearestMessageIdDistance(left.messageId, matchIds);
+    const rightDistance = nearestMessageIdDistance(right.messageId, matchIds);
+    return leftDistance - rightDistance || left.messageId - right.messageId;
+  });
+}
+function nearestMessageIdDistance(messageId, matchIds) {
+  let distance = Number.POSITIVE_INFINITY;
+  for (const matchId of matchIds) distance = Math.min(distance, Math.abs(messageId - matchId));
+  return distance;
+}
+function crossChatMessageKey(sessionId, messageId) {
+  return `${sessionId}:${messageId}`;
+}
+function isWithinSearchRange(timestamp, startTs, endTs) {
+  return (startTs === void 0 || timestamp >= startTs) && (endTs === void 0 || timestamp <= endTs);
+}
+function addBoundedSearchCandidate(candidates, candidate, maxSessions) {
+  candidates.push(candidate);
+  candidates.sort(compareSearchCandidates);
+  if (candidates.length > maxSessions) candidates.length = maxSessions;
+}
+function compareSearchCandidates(left, right) {
+  return (right.descriptor.lastMessageTs ?? Number.NEGATIVE_INFINITY) - (left.descriptor.lastMessageTs ?? Number.NEGATIVE_INFINITY);
+}
+function getSessionDescriptor(sessionId, db) {
+  const meta = getSessionMeta(db);
+  if (!meta || meta.type !== "private" /* PRIVATE */ && meta.type !== "group" /* GROUP */) return null;
+  const latest = getRecentMessages(db, { limit: 1 })[0];
+  return {
+    sessionId,
+    sessionName: meta.name,
+    sessionType: meta.type,
+    platform: meta.platform,
+    lastMessageTs: latest?.timestamp ?? null
+  };
+}
+function toCrossChatMessage(descriptor, message) {
+  return {
+    ...descriptor,
+    messageId: message.id,
+    senderId: message.senderId,
+    senderName: message.senderName,
+    senderPlatformId: message.senderPlatformId,
+    content: message.content,
+    timestamp: message.timestamp,
+    messageType: message.type
+  };
+}
+function normalizeScopes(scopes) {
+  const bySession = /* @__PURE__ */ new Map();
+  for (const scope of scopes) {
+    const sessionId = scope.sessionId.trim();
+    if (!sessionId) continue;
+    const existing = bySession.get(sessionId);
+    if (!existing) {
+      bySession.set(sessionId, {
+        sessionId,
+        memberIds: scope.memberIds ? [...new Set(scope.memberIds)] : void 0,
+        label: scope.label
+      });
+      continue;
+    }
+    if (!existing.memberIds || !scope.memberIds) {
+      existing.memberIds = void 0;
+    } else {
+      existing.memberIds = [.../* @__PURE__ */ new Set([...existing.memberIds, ...scope.memberIds])];
+    }
+    existing.label ??= scope.label;
+  }
+  return [...bySession.values()];
+}
+function normalizeOverviewScopes(scopes) {
+  return scopes.flatMap((scope) => {
+    const sessionId = scope.sessionId.trim();
+    if (!sessionId) return [];
+    return [
+      {
+        sessionId,
+        memberIds: scope.memberIds ? [...new Set(scope.memberIds)] : void 0,
+        label: scope.label
+      }
+    ];
+  });
+}
+function buildOverviewItem(descriptor, db, scope, facts, ownerStatus, ownerMemberId) {
+  const rosterById = new Map(getNonSystemMembersForContacts(db).map((member) => [member.id, member]));
+  const factsByMemberId = new Map(facts.members.map((member) => [member.memberId, member]));
+  const memberActivities = (scope.memberIds ?? []).flatMap((memberId) => {
+    const rosterMember = rosterById.get(memberId);
+    if (!rosterMember) return [];
+    const activity = factsByMemberId.get(memberId);
+    return [
+      {
+        memberId,
+        platformId: rosterMember.platformId,
+        memberName: rosterMember.name,
+        messageCount: activity?.messageCount ?? 0,
+        activeDays: activity?.activeDays ?? 0,
+        firstMessageTs: activity?.firstMessageTs ?? null,
+        lastMessageTs: activity?.lastMessageTs ?? null
+      }
+    ];
+  });
+  const selectedFacts = scope.memberIds ? scope.memberIds.flatMap((memberId) => factsByMemberId.get(memberId) ?? []) : [];
+  const selectedActiveDayKeys = new Set(selectedFacts.flatMap((member) => member.activeDayKeys));
+  const ownerActivity = ownerMemberId === null ? void 0 : factsByMemberId.get(ownerMemberId);
+  const topMembers = descriptor.sessionType === "group" /* GROUP */ ? [...facts.members].sort(
+    (left, right) => right.messageCount - left.messageCount || (right.lastMessageTs ?? Number.NEGATIVE_INFINITY) - (left.lastMessageTs ?? Number.NEGATIVE_INFINITY) || left.memberId - right.memberId
+  ).slice(0, OVERVIEW_TOP_MEMBERS_LIMIT).map(toOverviewMemberActivity) : [];
+  const totalMessages = scope.memberIds ? selectedFacts.reduce((sum, member) => sum + member.messageCount, 0) : facts.totalMessages;
+  const firstMessageTs = scope.memberIds ? selectedFacts.reduce((earliest, member) => minNullable(earliest, member.firstMessageTs), null) : facts.firstMessageTs;
+  const lastMessageTs = scope.memberIds ? selectedFacts.reduce((latest, member) => maxNullable(latest, member.lastMessageTs), null) : facts.lastMessageTs;
+  return {
+    ...descriptor,
+    label: scope.label ?? descriptor.sessionName,
+    ...scope.memberIds ? {
+      memberIds: scope.memberIds,
+      memberNames: memberActivities.map((member) => member.memberName)
+    } : {},
+    memberActivities,
+    totalMessages,
+    activeDays: scope.memberIds ? selectedActiveDayKeys.size : facts.activeDays,
+    activeMembers: scope.memberIds ? selectedFacts.length : facts.activeMembers,
+    firstMessageTs,
+    lastMessageTs,
+    ownerStatus,
+    ownerMessages: ownerStatus === "resolved" ? ownerActivity?.messageCount ?? 0 : null,
+    ownerActiveDays: ownerStatus === "resolved" ? ownerActivity?.activeDays ?? 0 : null,
+    topMembers
+  };
+}
+function toOverviewMemberActivity(member) {
+  return {
+    memberId: member.memberId,
+    platformId: member.platformId,
+    memberName: member.memberName,
+    messageCount: member.messageCount,
+    activeDays: member.activeDays,
+    firstMessageTs: member.firstMessageTs,
+    lastMessageTs: member.lastMessageTs
+  };
+}
+function clampInteger(value, fallback, min, max) {
+  if (!Number.isFinite(value)) return fallback;
+  return Math.min(max, Math.max(min, Math.floor(value)));
+}
+function normalizeInspectionRange(startTs, endTs, recentDays, now) {
+  return resolveInspectionRange(normalizeInspectionRangeRequest(startTs, endTs, recentDays), now);
+}
+function normalizeInspectionRangeRequest(startTs, endTs, recentDays) {
+  const normalizedStart = normalizeOptionalTimestamp(startTs, "startTs");
+  const normalizedEnd = normalizeOptionalTimestamp(endTs, "endTs");
+  if (normalizedStart !== null && normalizedEnd !== null && normalizedStart > normalizedEnd) {
+    throw new Error("startTs must be less than or equal to endTs");
+  }
+  return {
+    startTs: normalizedStart,
+    endTs: normalizedEnd,
+    recentDays: normalizedStart === null ? normalizeRecentDays(recentDays) ?? null : null
+  };
+}
+function resolveInspectionRange(request, now) {
+  if (request.recentDays !== null) {
+    const anchor = new Date((request.endTs ?? Math.floor(now() / 1e3)) * 1e3);
+    const start = new Date(anchor);
+    start.setHours(0, 0, 0, 0);
+    start.setDate(start.getDate() - (request.recentDays - 1));
+    const endExclusive = new Date(anchor);
+    endExclusive.setHours(0, 0, 0, 0);
+    endExclusive.setDate(endExclusive.getDate() + 1);
+    return {
+      startTs: Math.floor(start.getTime() / 1e3),
+      endTs: Math.floor(endExclusive.getTime() / 1e3) - 1
+    };
+  }
+  return { startTs: request.startTs, endTs: request.endTs };
+}
+function normalizeOptionalTimestamp(value, name) {
+  if (value === void 0) return null;
+  if (!Number.isFinite(value)) throw new Error(`${name} must be a finite timestamp`);
+  return Math.floor(value);
+}
+function summarizeContactSessions(sessions, completeResult) {
+  let ownMessageCount = 0;
+  let firstOwnMessageTs = null;
+  let lastOwnMessageTs = null;
+  let privateSessions = 0;
+  let groupSessions = 0;
+  let spokeSessions = 0;
+  let rosterOnlySessions = 0;
+  for (const session of sessions) {
+    ownMessageCount += session.ownMessageCount;
+    firstOwnMessageTs = minNullable(firstOwnMessageTs, session.firstOwnMessageTs);
+    lastOwnMessageTs = maxNullable(lastOwnMessageTs, session.lastOwnMessageTs);
+    if (session.sessionType === "private" /* PRIVATE */) privateSessions++;
+    else groupSessions++;
+    if (session.presence === "spoke") spokeSessions++;
+    else rosterOnlySessions++;
+  }
+  return {
+    scope: completeResult ? "complete_result" : "current_batch",
+    matchedSessions: sessions.length,
+    privateSessions,
+    groupSessions,
+    spokeSessions,
+    rosterOnlySessions,
+    ownMessageCount,
+    firstOwnMessageTs,
+    lastOwnMessageTs
+  };
+}
+function normalizeParticipantRefs(participants) {
+  if (!Array.isArray(participants)) throw new Error("participants must be an array");
+  const deduplicated = /* @__PURE__ */ new Map();
+  for (const participant of participants) {
+    if (participant?.type === "owner") {
+      deduplicated.set("owner", { type: "owner" });
+      continue;
+    }
+    if (participant?.type === "contact") {
+      const contactKey = participant.contactKey?.trim();
+      if (!contactKey) throw new Error("participant contactKey is required");
+      deduplicated.set(`contact:${contactKey}`, { type: "contact", contactKey });
+      continue;
+    }
+    throw new Error("participant type must be owner or contact");
+  }
+  const refs = [...deduplicated.values()];
+  if (refs.length < 2 || refs.length > 5) throw new Error("participants must contain 2 to 5 distinct people");
+  return refs;
+}
+function mapSharedInteractionSession(descriptor, members, participantIndexByMemberId, facts) {
+  const participants = facts.participants.map((participant, index) => ({
+    participantIndex: participantIndexByMemberId.get(participant.memberId) ?? index,
+    memberId: participant.memberId,
+    memberName: members[index]?.name ?? String(participant.memberId),
+    messageCount: participant.messageCount,
+    firstMessageTs: participant.firstMessageTs,
+    lastMessageTs: participant.lastMessageTs,
+    activeDays: participant.activeDays,
+    presenceObservedInRange: participant.messageCount > 0
+  }));
+  const pairs = facts.pairs.map((pair) => ({
+    sourceParticipantIndex: participantIndexByMemberId.get(pair.sourceMemberId) ?? 0,
+    targetParticipantIndex: participantIndexByMemberId.get(pair.targetMemberId) ?? 0,
+    directReplyCount: pair.directReplyCount,
+    repliesFromSourceToTarget: pair.repliesFromSourceToTarget,
+    repliesFromTargetToSource: pair.repliesFromTargetToSource,
+    lastDirectReplyTs: pair.lastDirectReplyTs,
+    coOccurrenceCount: pair.coOccurrenceCount,
+    coOccurrenceRawScore: pair.coOccurrenceRawScore,
+    lastProximityTs: pair.lastProximityTs,
+    coActiveDays: pair.coActiveDays,
+    anchors: pair.anchors.map((anchor) => ({
+      sessionId: descriptor.sessionId,
+      messageId: anchor.messageId,
+      relatedMessageId: anchor.relatedMessageId,
+      timestamp: anchor.timestamp,
+      signal: anchor.signal,
+      fromParticipantIndex: participantIndexByMemberId.get(anchor.fromMemberId) ?? 0,
+      toParticipantIndex: participantIndexByMemberId.get(anchor.toMemberId) ?? 0
+    })),
+    anchorsTruncated: pair.anchorsTruncated
+  }));
+  const priorityReasons = [];
+  if (pairs.some((pair) => pair.directReplyCount > 0)) priorityReasons.push("has_direct_reply");
+  if (pairs.some((pair) => (pair.coOccurrenceCount ?? 0) > 0)) priorityReasons.push("has_proximity");
+  if (participants.every((participant) => participant.presenceObservedInRange)) {
+    priorityReasons.push("all_participants_spoke");
+  }
+  return {
+    ...descriptor,
+    lastMessageTs: facts.sessionLastMessageTs,
+    memberCount: descriptor.sessionType === "group" /* GROUP */ ? facts.memberCount : null,
+    participants,
+    overlapRange: facts.overlapRange,
+    allParticipantsCoActiveDays: facts.allParticipantsCoActiveDays,
+    pairs,
+    priorityReasons,
+    proximityStatus: facts.proximityStatus
+  };
+}
+function summarizeSharedInteractions(sessions, completeResult) {
+  return {
+    scope: completeResult ? "complete_result" : "current_batch",
+    commonSessions: sessions.length,
+    commonPrivateSessions: sessions.filter((session) => session.sessionType === "private" /* PRIVATE */).length,
+    commonGroupSessions: sessions.filter((session) => session.sessionType === "group" /* GROUP */).length,
+    sessionsWithDirectReplies: sessions.filter((session) => session.pairs.some((pair) => pair.directReplyCount > 0)).length,
+    sessionsWithProximitySignals: sessions.filter(
+      (session) => session.pairs.some((pair) => (pair.coOccurrenceCount ?? 0) > 0)
+    ).length
+  };
+}
+function emptySharedInteractionsResult(participants, unresolvedParticipantIndexes, range) {
+  return {
+    algorithmVersion: SHARED_INTERACTIONS_ALGORITHM_VERSION,
+    proximityAlgorithmVersion: PROXIMITY_ALGORITHM_VERSION,
+    participants,
+    appliedRange: {
+      ...range,
+      dataEarliestMessageTs: null,
+      dataLatestMessageTs: null
+    },
+    summary: {
+      scope: "complete_result",
+      commonSessions: 0,
+      commonPrivateSessions: 0,
+      commonGroupSessions: 0,
+      sessionsWithDirectReplies: 0,
+      sessionsWithProximitySignals: 0
+    },
+    sessions: [],
+    coverage: {
+      candidateSessions: 0,
+      scannedSessions: 0,
+      matchedSessions: 0,
+      returnedSessions: 0,
+      failedSessions: 0,
+      failedSessionIds: [],
+      complete: true,
+      nextCursor: null,
+      truncated: false,
+      truncatedReasons: [],
+      unresolvedParticipantIndexes,
+      identityCollisionSessions: 0,
+      ownerResolution: participants.some((participant) => participant.ref.type === "owner") ? { resolvedSessions: 0, missingOwnerSessions: 0, unresolvedOwnerSessions: 0 } : void 0
+    }
+  };
+}
+function compareSharedInteractionSessions(left, right) {
+  const leftReplies = left.pairs.reduce((sum, pair) => sum + pair.directReplyCount, 0);
+  const rightReplies = right.pairs.reduce((sum, pair) => sum + pair.directReplyCount, 0);
+  if (leftReplies !== rightReplies) return rightReplies - leftReplies;
+  const leftProximity = left.pairs.reduce((sum, pair) => sum + (pair.coOccurrenceRawScore ?? 0), 0);
+  const rightProximity = right.pairs.reduce((sum, pair) => sum + (pair.coOccurrenceRawScore ?? 0), 0);
+  if (leftProximity !== rightProximity) return rightProximity - leftProximity;
+  const leftCoActiveDays = left.pairs.reduce((sum, pair) => sum + pair.coActiveDays, 0);
+  const rightCoActiveDays = right.pairs.reduce((sum, pair) => sum + pair.coActiveDays, 0);
+  if (leftCoActiveDays !== rightCoActiveDays) return rightCoActiveDays - leftCoActiveDays;
+  const leftLastInteractionTs = latestPairInteractionTs(left.pairs);
+  const rightLastInteractionTs = latestPairInteractionTs(right.pairs);
+  if (leftLastInteractionTs !== rightLastInteractionTs) return rightLastInteractionTs - leftLastInteractionTs;
+  if (left.memberCount !== right.memberCount) {
+    return (left.memberCount ?? Number.POSITIVE_INFINITY) - (right.memberCount ?? Number.POSITIVE_INFINITY);
+  }
+  return left.sessionId.localeCompare(right.sessionId);
+}
+function latestPairInteractionTs(pairs) {
+  let latest = 0;
+  for (const pair of pairs) {
+    latest = Math.max(latest, pair.lastDirectReplyTs ?? 0, pair.lastProximityTs ?? 0);
+  }
+  return latest;
+}
+function emptyContactSessionsResult(contactCacheStatus, range) {
+  return {
+    algorithmVersion: CONTACT_SESSIONS_ALGORITHM_VERSION,
+    contact: null,
+    appliedRange: {
+      ...range,
+      dataEarliestMessageTs: null,
+      dataLatestMessageTs: null
+    },
+    summary: {
+      scope: "complete_result",
+      matchedSessions: 0,
+      privateSessions: 0,
+      groupSessions: 0,
+      spokeSessions: 0,
+      rosterOnlySessions: 0,
+      ownMessageCount: 0,
+      firstOwnMessageTs: null,
+      lastOwnMessageTs: null
+    },
+    sessions: [],
+    coverage: {
+      candidateSessions: 0,
+      scannedSessions: 0,
+      matchedSessions: 0,
+      returnedSessions: 0,
+      failedSessions: 0,
+      failedSessionIds: [],
+      complete: true,
+      nextCursor: null,
+      truncated: false,
+      truncatedReasons: [],
+      contactCacheStatus
+    }
+  };
+}
+function minNullable(left, right) {
+  if (left === null) return right;
+  if (right === null) return left;
+  return Math.min(left, right);
+}
+function maxNullable(left, right) {
+  if (left === null) return right;
+  if (right === null) return left;
+  return Math.max(left, right);
+}
+function createInspectionFingerprint(value) {
+  return createHash2("sha256").update(JSON.stringify(value)).digest("base64url");
+}
+function createInspectionCursor(fingerprint, afterSessionId, range) {
+  const payload = { version: 2, fingerprint, afterSessionId, range };
+  return Buffer.from(JSON.stringify(payload)).toString("base64url");
+}
+function parseInspectionCursor(value, createFingerprint, candidateSessionIds, defaultRange) {
+  if (!value) {
+    return {
+      nextCandidateIndex: 0,
+      fingerprint: createFingerprint(defaultRange),
+      range: defaultRange
+    };
+  }
+  try {
+    const payload = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+    if (payload.version !== 2 || !isInspectionRange(payload.range)) throw new Error("cursor payload is invalid");
+    const fingerprint = createFingerprint(payload.range);
+    if (payload.fingerprint !== fingerprint) throw new Error("cursor mismatch");
+    if (payload.afterSessionId === null) {
+      return { nextCandidateIndex: 0, fingerprint, range: payload.range };
+    }
+    if (typeof payload.afterSessionId !== "string") throw new Error("cursor session is missing");
+    const index = candidateSessionIds.indexOf(payload.afterSessionId);
+    if (index < 0) throw new Error("cursor session no longer exists");
+    return { nextCandidateIndex: index + 1, fingerprint, range: payload.range };
+  } catch {
+    throw new Error("cursor is invalid or does not match the current inspection request");
+  }
+}
+function isInspectionRange(value) {
+  if (!value || typeof value !== "object") return false;
+  const range = value;
+  const isTimestamp = (timestamp) => timestamp === null || typeof timestamp === "number" && Number.isFinite(timestamp);
+  return isTimestamp(range.startTs) && isTimestamp(range.endTs) && (range.startTs === null || range.endTs === null || range.startTs <= range.endTs);
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  const error = new Error("Cross-chat analysis was interrupted");
+  error.name = "AbortError";
+  throw error;
+}
+function yieldToEventLoop2() {
+  return new Promise((resolve4) => setImmediate(resolve4));
+}
+function createNotFoundError(message) {
+  return Object.assign(new Error(message), { statusCode: 404 });
+}
+
+// ../../packages/node-runtime/src/services/cross-chat-analysis/preprocess.ts
+function preprocessCrossChatMessages(adapter, sessionId, messages, config) {
+  const safeConfig = config ? { ...config, mergeConsecutive: false, anonymizeNames: false } : void 0;
+  const processed = preprocessMessages(
+    messages.map((message) => ({ ...message })),
+    safeConfig
+  );
+  if (!config?.anonymizeNames) return processed;
+  let ownerPlatformId = null;
+  try {
+    const db = adapter.openReadonly(sessionId);
+    ownerPlatformId = db ? getSessionMeta(db)?.ownerId?.trim() || null : null;
+  } catch {
+  }
+  return processed.map((message) => ({
+    ...message,
+    senderName: ownerPlatformId && message.senderPlatformId === ownerPlatformId ? "Owner" : `U${message.senderId}@${sessionId}`
+  }));
+}
+function preprocessCrossChatSummaries(adapter, sessionId, summaries, config) {
+  if (!config) return summaries.map(cloneSummary);
+  const participantPseudonyms = config.anonymizeNames ? buildParticipantPseudonyms(
+    adapter,
+    sessionId,
+    summaries.flatMap((summary) => summary.participants)
+  ) : null;
+  return summaries.flatMap((summary) => {
+    if (matchesBlacklist(summary.summary, config.blacklistKeywords)) return [];
+    let safeSummary = config.desensitize ? desensitizeText(summary.summary, config.desensitizeRules) : summary.summary;
+    if (participantPseudonyms) {
+      const anonymizedSummary = replaceKnownParticipantNames(safeSummary, participantPseudonyms);
+      if (anonymizedSummary === null) return [];
+      safeSummary = anonymizedSummary;
+    }
+    const participants = summary.participants.filter((participant) => !matchesBlacklist(participant, config.blacklistKeywords)).map((participant) => {
+      if (participantPseudonyms) return participantPseudonyms.get(participant) ?? `Participant@${sessionId}`;
+      return config.desensitize ? desensitizeText(participant, config.desensitizeRules) : participant;
+    }).filter((participant, index, values) => participant.length > 0 && values.indexOf(participant) === index);
+    return [{ ...summary, participants, summary: safeSummary }];
+  });
+}
+function preprocessCrossChatLabel(value, pseudonym, config) {
+  if (!config) return value;
+  if (config.anonymizeNames || matchesBlacklist(value, config.blacklistKeywords)) return pseudonym;
+  return config.desensitize ? desensitizeText(value, config.desensitizeRules) : value;
+}
+function cloneSummary(summary) {
+  return { ...summary, participants: [...summary.participants] };
+}
+function replaceKnownParticipantNames(summary, pseudonyms) {
+  const replacements = /* @__PURE__ */ new Map();
+  for (const [participantName, pseudonym] of pseudonyms) {
+    const trimmedName = participantName.trim();
+    if (participantName) replacements.set(participantName, pseudonym);
+    if (trimmedName) replacements.set(trimmedName, pseudonym);
+  }
+  if (replacements.size === 0) return summary;
+  const ambiguousLabels = /* @__PURE__ */ new Set();
+  const alternatives = [...replacements.keys()].sort((left, right) => Array.from(right).length - Array.from(left).length).map((participantName) => {
+    const escapedName = escapeRegExp(participantName);
+    if (/^[\p{Script=Latin}\p{N}_]+$/u.test(participantName)) {
+      return `(?<![\\p{Script=Latin}\\p{N}_])${escapedName}(?![\\p{Script=Latin}\\p{N}_])`;
+    }
+    if (Array.from(participantName).length === 1 && /[\p{L}\p{N}]/u.test(participantName)) {
+      ambiguousLabels.add(participantName);
+      return `(?<![\\p{L}\\p{N}_])${escapedName}(?![\\p{L}\\p{N}_])`;
+    }
+    return escapedName;
+  });
+  const pattern = new RegExp(alternatives.join("|"), "gu");
+  const anonymized = summary.replace(pattern, (participantName) => replacements.get(participantName) ?? participantName);
+  return [...ambiguousLabels].some((participantName) => anonymized.includes(participantName)) ? null : anonymized;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildParticipantPseudonyms(adapter, sessionId, participantNames) {
+  const pseudonyms = /* @__PURE__ */ new Map();
+  const fallbackPseudonyms = /* @__PURE__ */ new Map();
+  let ownerPlatformId = null;
+  let members = [];
+  try {
+    const db = adapter.openReadonly(sessionId);
+    if (db) {
+      ownerPlatformId = getSessionMeta(db)?.ownerId?.trim() || null;
+      members = getNonSystemMembersForContacts(db);
+    }
+  } catch {
+  }
+  for (const participantName of participantNames) {
+    if (pseudonyms.has(participantName)) continue;
+    const normalizedName = participantName.trim().toLocaleLowerCase();
+    const matches = members.filter(
+      (member) => [member.name, member.platformId, ...member.aliases].some(
+        (candidate) => candidate.trim().toLocaleLowerCase() === normalizedName
+      )
+    );
+    const uniqueMatches = [...new Map(matches.map((member) => [member.id, member])).values()];
+    if (uniqueMatches.length === 1) {
+      const member = uniqueMatches[0];
+      pseudonyms.set(
+        participantName,
+        ownerPlatformId && member.platformId === ownerPlatformId ? "Owner" : `U${member.id}@${sessionId}`
+      );
+      continue;
+    }
+    let fallback = fallbackPseudonyms.get(normalizedName);
+    if (!fallback) {
+      fallback = `Participant${fallbackPseudonyms.size + 1}@${sessionId}`;
+      fallbackPseudonyms.set(normalizedName, fallback);
+    }
+    pseudonyms.set(participantName, fallback);
+  }
+  return pseudonyms;
+}
+
+// ../../packages/node-runtime/src/services/cross-chat-analysis/index.ts
+var cross_chat_analysis_exports = {};
+__export(cross_chat_analysis_exports, {
+  createCrossChatAnalysisService: () => createCrossChatAnalysisService,
+  preprocessCrossChatLabel: () => preprocessCrossChatLabel,
+  preprocessCrossChatMessages: () => preprocessCrossChatMessages,
+  preprocessCrossChatSummaries: () => preprocessCrossChatSummaries
+});
+
 // ../../packages/node-runtime/src/services/people/relationships/signature.ts
 function buildPeopleRelationshipsSignature(adapter, timeRangePreset) {
   const parts = [
@@ -13624,7 +15515,7 @@ var LocalEmbeddingProvider = class {
 import path22 from "path";
 
 // ../../packages/node-runtime/src/semantic-index/chunker-config.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var CHUNKER_VERSION = "v1.3";
 var STRATEGY_ID = "balanced";
 var DEFAULT_CHUNKER_CONFIG = {
@@ -13639,7 +15530,7 @@ var DEFAULT_CHUNKER_CONFIG = {
   semanticVoidSkipThreshold: 20
 };
 function sha256Hex(input) {
-  return createHash2("sha256").update(input, "utf-8").digest("hex");
+  return createHash3("sha256").update(input, "utf-8").digest("hex");
 }
 function computeChunkerConfigHash(config) {
   const canonical = JSON.stringify({
@@ -14327,7 +16218,7 @@ var SemanticIndexJobQueue = class {
 };
 
 // ../../packages/node-runtime/src/semantic-index/chunker.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 var VOID_MESSAGE_TYPES = /* @__PURE__ */ new Set([
   1 /* IMAGE */,
   2 /* VOICE */,
@@ -14410,7 +16301,7 @@ function sumEffectiveChars(messages) {
   return total;
 }
 function sha256Hex2(input) {
-  return createHash3("sha256").update(input, "utf-8").digest("hex");
+  return createHash4("sha256").update(input, "utf-8").digest("hex");
 }
 var EMBEDDING_HEADER_BUDGET_RATIO = 0.25;
 var SOURCE_TITLE_HEADER_SHARE = 1 / 3;
@@ -16344,10 +18235,10 @@ async function executePushImportUnlocked(deps, sessionId, payload) {
 }
 
 // ../../packages/node-runtime/src/services/import-idempotency.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 var DEFAULT_IMPORT_IDEMPOTENCY_TTL_MS = 60 * 60 * 1e3;
 function hashImportBody(body) {
-  return createHash4("sha256").update(JSON.stringify(body ?? "")).digest("hex");
+  return createHash5("sha256").update(JSON.stringify(body ?? "")).digest("hex");
 }
 var ImportIdempotencyCache = class {
   constructor(ttlMs = DEFAULT_IMPORT_IDEMPOTENCY_TTL_MS) {
@@ -16414,6 +18305,7 @@ export {
   MessageBatchInserter,
   generateFallbackMessageKey,
   createMessageDedupState,
+  hasUnmatchedFallbackOnlyMessage,
   registerMessageAndCheckDuplicate,
   streamingImport,
   analyzeNewImport,
@@ -16454,6 +18346,11 @@ export {
   owner_profile_service_exports,
   createContactsService,
   contacts_exports,
+  createCrossChatAnalysisService,
+  preprocessCrossChatMessages,
+  preprocessCrossChatSummaries,
+  preprocessCrossChatLabel,
+  cross_chat_analysis_exports,
   createPeopleRelationshipsService,
   relationships_exports,
   createGlobalInsightService,
@@ -16525,4 +18422,4 @@ export {
   hashImportBody,
   ImportIdempotencyCache
 };
-//# sourceMappingURL=chunk-VREVDZ4Q.mjs.map
+//# sourceMappingURL=chunk-DQR2YS3I.mjs.map