chatlab-cli 0.34.2 → 0.35.0

package/dist/{chunk-INBJ7SND.mjs → chunk-22YJOBA3.mjs}

@@ -40,13 +40,17 @@ var cliConfigSchema = z.object({
   /** Allow the read-only `sql` query command. */
   allow_sql: z.boolean().default(true)
 });
+var desktopConfigSchema = z.object({
+  close_behavior: z.enum(["background", "quit"]).default("background")
+});
 var configSchema = z.object({
   llm: llmConfigSchema.default({}),
   data: dataConfigSchema.default({}),
   api: apiConfigSchema.default({}),
   locale: localeConfigSchema.default({}),
   ui: uiConfigSchema.default({}),
-  cli: cliConfigSchema.default({})
+  cli: cliConfigSchema.default({}),
+  desktop: desktopConfigSchema.default({})
 });
 
 // ../../packages/config/src/loader.ts
@@ -4108,7 +4112,7 @@ function buildMsgConditions(options) {
 
 // ../../packages/core/src/query/advanced/social.ts
 function getMentionAnalysis(db, filter) {
-  const emptyResult = {
+  const emptyResult2 = {
     topMentioners: [],
     topMentioned: [],
     totalMentions: 0
@@ -4117,7 +4121,7 @@ function getMentionAnalysis(db, filter) {
     `SELECT id, platform_id as platformId, COALESCE(group_nickname, account_name, platform_id) as name
        FROM member WHERE COALESCE(account_name, '') != '\u7CFB\u7EDF\u6D88\u606F'`
   ).all();
-  if (members.length === 0) return emptyResult;
+  if (members.length === 0) return emptyResult2;
   const nameToMemberId = /* @__PURE__ */ new Map();
   const memberIdToInfo = /* @__PURE__ */ new Map();
   for (const member of members) {
@@ -4158,7 +4162,7 @@ function getMentionAnalysis(db, filter) {
       }
     }
   }
-  if (totalMentions === 0) return emptyResult;
+  if (totalMentions === 0) return emptyResult2;
   const topMentioners = [];
   for (const [memberId, count] of mentionerCount.entries()) {
     const info = memberIdToInfo.get(memberId);
@@ -4185,87 +4189,13 @@ function getMentionAnalysis(db, filter) {
   topMentioned.sort((a, b) => b.count - a.count);
   return { topMentioners, topMentioned, totalMentions };
 }
-function getMentionGraph(db, filter) {
-  const emptyResult = { nodes: [], links: [], maxLinkValue: 0 };
-  const { clause, params } = buildTimeFilter(filter);
-  const msgFilterBase = clause ? clause.replace("WHERE", "AND") : "";
-  const msgFilterWithSystem = msgFilterBase + " AND COALESCE(m.account_name, '') != '\u7CFB\u7EDF\u6D88\u606F'";
-  const members = db.prepare(
-    `SELECT m.id, m.platform_id as platformId, COALESCE(m.group_nickname, m.account_name, m.platform_id) as name,
-              COUNT(msg.id) as messageCount
-       FROM member m LEFT JOIN message msg ON m.id = msg.sender_id ${msgFilterWithSystem}
-       WHERE COALESCE(m.account_name, '') != '\u7CFB\u7EDF\u6D88\u606F' GROUP BY m.id`
-  ).all(...params);
-  if (members.length === 0) return emptyResult;
-  const nameToMemberId = /* @__PURE__ */ new Map();
-  const memberIdToInfo = /* @__PURE__ */ new Map();
-  for (const member of members) {
-    memberIdToInfo.set(member.id, { name: member.name, messageCount: member.messageCount });
-    nameToMemberId.set(member.name, member.id);
-    const history = db.prepare("SELECT name FROM member_name_history WHERE member_id = ?").all(member.id);
-    for (const h of history) {
-      if (!nameToMemberId.has(h.name)) nameToMemberId.set(h.name, member.id);
-    }
-  }
-  let whereClause = clause;
-  if (whereClause.includes("WHERE")) {
-    whereClause += " AND COALESCE(m.account_name, '') != '\u7CFB\u7EDF\u6D88\u606F' AND msg.type = 0 AND msg.content IS NOT NULL AND msg.content LIKE '%@%'";
-  } else {
-    whereClause = " WHERE COALESCE(m.account_name, '') != '\u7CFB\u7EDF\u6D88\u606F' AND msg.type = 0 AND msg.content IS NOT NULL AND msg.content LIKE '%@%'";
-  }
-  const messages = db.prepare(
-    `SELECT msg.sender_id as senderId, msg.content FROM message msg JOIN member m ON msg.sender_id = m.id ${whereClause}`
-  ).all(...params);
-  const mentionMatrix = /* @__PURE__ */ new Map();
-  const mentionRegex = /@([^\s@]+)/g;
-  for (const msg of messages) {
-    const matches = msg.content.matchAll(mentionRegex);
-    const mentionedInThisMsg = /* @__PURE__ */ new Set();
-    for (const match of matches) {
-      const mentionedId = nameToMemberId.get(match[1]);
-      if (mentionedId && mentionedId !== msg.senderId && !mentionedInThisMsg.has(mentionedId)) {
-        mentionedInThisMsg.add(mentionedId);
-        if (!mentionMatrix.has(msg.senderId)) mentionMatrix.set(msg.senderId, /* @__PURE__ */ new Map());
-        const fromMap = mentionMatrix.get(msg.senderId);
-        fromMap.set(mentionedId, (fromMap.get(mentionedId) || 0) + 1);
-      }
-    }
-  }
-  const involvedMemberIds = /* @__PURE__ */ new Set();
-  for (const [fromId, toMap] of mentionMatrix.entries()) {
-    involvedMemberIds.add(fromId);
-    for (const toId of toMap.keys()) involvedMemberIds.add(toId);
-  }
-  const maxMessageCount = Math.max(...members.filter((m) => involvedMemberIds.has(m.id)).map((m) => m.messageCount), 1);
-  const nodes = [];
-  for (const memberId of involvedMemberIds) {
-    const info = memberIdToInfo.get(memberId);
-    if (info) {
-      const symbolSize = 20 + info.messageCount / maxMessageCount * 40;
-      nodes.push({ id: memberId, name: info.name, value: info.messageCount, symbolSize: Math.round(symbolSize) });
-    }
-  }
-  const links = [];
-  let maxLinkValue = 0;
-  for (const [fromId, toMap] of mentionMatrix.entries()) {
-    const fromInfo = memberIdToInfo.get(fromId);
-    if (!fromInfo) continue;
-    for (const [toId, count] of toMap.entries()) {
-      const toInfo = memberIdToInfo.get(toId);
-      if (!toInfo) continue;
-      links.push({ source: fromInfo.name, target: toInfo.name, value: count });
-      maxLinkValue = Math.max(maxLinkValue, count);
-    }
-  }
-  return { nodes, links, maxLinkValue };
-}
 function keywordToPattern(keyword) {
   const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   if (keyword === "\u54C8\u54C8") return "\u54C8\u54C8+";
   return escaped;
 }
 function getLaughAnalysis(db, filter, keywords) {
-  const emptyResult = {
+  const emptyResult2 = {
     rankByRate: [],
     rankByCount: [],
     typeDistribution: [],
@@ -4273,7 +4203,8 @@ function getLaughAnalysis(db, filter, keywords) {
     totalMessages: 0,
     groupLaughRate: 0
   };
-  const laughKeywords = keywords && keywords.length > 0 ? keywords : [];
+  const laughKeywords = keywords?.map((keyword) => keyword.trim()).filter(Boolean) ?? [];
+  if (laughKeywords.length === 0) return emptyResult2;
   const patterns = laughKeywords.map(keywordToPattern);
   const laughRegex = new RegExp(`(${patterns.join("|")})`, "gi");
   const { clause, params } = buildTimeFilter(filter);
@@ -4288,7 +4219,7 @@ function getLaughAnalysis(db, filter, keywords) {
               COALESCE(m.group_nickname, m.account_name, m.platform_id) as name
        FROM message msg JOIN member m ON msg.sender_id = m.id ${whereClause}`
   ).all(...params);
-  if (messages.length === 0) return emptyResult;
+  if (messages.length === 0) return emptyResult2;
   const memberStats = /* @__PURE__ */ new Map();
   const typeCount = /* @__PURE__ */ new Map();
   let totalLaughs = 0;
@@ -4321,7 +4252,7 @@ function getLaughAnalysis(db, filter, keywords) {
       }
     }
   }
-  if (totalLaughs === 0) return emptyResult;
+  if (totalLaughs === 0) return emptyResult2;
   const rankItems = [];
   for (const [memberId, stats] of memberStats.entries()) {
     if (stats.laughCount > 0) {
@@ -4411,7 +4342,7 @@ function accumulateCoOccurrencePairs(messages, options) {
 }
 function getClusterGraph(db, filter, options) {
   const opts = { ...DEFAULT_CLUSTER_OPTIONS, ...options };
-  const emptyResult = {
+  const emptyResult2 = {
     nodes: [],
     links: [],
     maxLinkValue: 0,
@@ -4423,7 +4354,7 @@ function getClusterGraph(db, filter, options) {
               (SELECT COUNT(*) FROM message WHERE sender_id = member.id) as messageCount
        FROM member WHERE COALESCE(account_name, '') != '\u7CFB\u7EDF\u6D88\u606F'`
   ).all();
-  if (members.length < 2) return { ...emptyResult, stats: { ...emptyResult.stats, totalMembers: members.length } };
+  if (members.length < 2) return { ...emptyResult2, stats: { ...emptyResult2.stats, totalMembers: members.length } };
   const memberInfo = /* @__PURE__ */ new Map();
   for (const m of members)
     memberInfo.set(m.id, { name: m.name, platformId: m.platformId, messageCount: m.messageCount });
@@ -4440,8 +4371,8 @@ function getClusterGraph(db, filter, options) {
   ).all(...params);
   if (messages.length < 2)
     return {
-      ...emptyResult,
-      stats: { ...emptyResult.stats, totalMembers: members.length, totalMessages: messages.length }
+      ...emptyResult2,
+      stats: { ...emptyResult2.stats, totalMembers: members.length, totalMessages: messages.length }
     };
   const memberMsgCount = /* @__PURE__ */ new Map();
   for (const msg of messages) memberMsgCount.set(msg.senderId, (memberMsgCount.get(msg.senderId) || 0) + 1);
@@ -4480,8 +4411,8 @@ function getClusterGraph(db, filter, options) {
   const keptEdges = edges.slice(0, opts.topEdges);
   if (keptEdges.length === 0)
     return {
-      ...emptyResult,
-      stats: { ...emptyResult.stats, totalMembers: members.length, totalMessages: messages.length }
+      ...emptyResult2,
+      stats: { ...emptyResult2.stats, totalMembers: members.length, totalMessages: messages.length }
     };
   const involvedIds = /* @__PURE__ */ new Set();
   for (const edge of keptEdges) {
@@ -4754,7 +4685,7 @@ function getGroupRelationshipGraphFacts(db, ownerMemberId, options = {}) {
        ORDER BY msg.ts ASC, msg.id ASC`
   ).all(...messageTimeFilter.params);
   const edgeStats = /* @__PURE__ */ new Map();
-  const ensureEdge = (aId, bId) => {
+  const ensureEdge2 = (aId, bId) => {
     const sourceId = Math.min(aId, bId);
     const targetId = Math.max(aId, bId);
     const key = `${sourceId}:${targetId}`;
@@ -4774,7 +4705,7 @@ function getGroupRelationshipGraphFacts(db, ownerMemberId, options = {}) {
   };
   for (const pair of accumulateCoOccurrencePairs(coOccurrenceRows)) {
     if (!contactById.has(pair.sourceId) || !contactById.has(pair.targetId)) continue;
-    const edge = ensureEdge(pair.sourceId, pair.targetId);
+    const edge = ensureEdge2(pair.sourceId, pair.targetId);
     edge.coOccurrenceCount += pair.coOccurrenceCount;
     edge.coOccurrenceRawScore += pair.rawScore;
     edge.lastInteractionTs = Math.max(edge.lastInteractionTs ?? 0, pair.lastOccurrenceTs);
@@ -4796,7 +4727,7 @@ function getGroupRelationshipGraphFacts(db, ownerMemberId, options = {}) {
   for (const row of replyRows) {
     if (!contactById.has(row.replySenderId) || !contactById.has(row.targetSenderId)) continue;
     if (row.replySenderId === row.targetSenderId) continue;
-    const edge = ensureEdge(row.replySenderId, row.targetSenderId);
+    const edge = ensureEdge2(row.replySenderId, row.targetSenderId);
     if (row.replySenderId === edge.sourceId) edge.repliesFromSourceToTarget++;
     else edge.repliesFromTargetToSource++;
     edge.lastInteractionTs = Math.max(edge.lastInteractionTs ?? 0, row.replyTs);
@@ -6004,12 +5935,456 @@ function getCatchphraseAnalysis(db, filter) {
   return { members };
 }
 
+// ../../packages/core/src/query/advanced/group-relationship-galaxy.ts
+var GROUP_RELATIONSHIP_GALAXY_ALGORITHM_VERSION = "group-relationship-galaxy-v1";
+var REPLY_WEIGHT = 3;
+var MENTION_WEIGHT = 2;
+var CO_OCCURRENCE_COUNT_WEIGHT = 0.05;
+var MIN_EDGE_WEIGHT = 1e-6;
+var DEFAULT_LIMITS = {
+  nodeLimit: 400,
+  edgeLimit: 1200,
+  perNodeEdgeLimit: 10
+};
+var COMMUNITY_COLORS = [
+  "#7dd3fc",
+  "#c4b5fd",
+  "#f0abfc",
+  "#5eead4",
+  "#fda4af",
+  "#fde68a",
+  "#93c5fd",
+  "#6ee7b7",
+  "#d8b4fe",
+  "#fdba74"
+];
+function getGroupRelationshipGalaxy(db, filter, options = {}) {
+  const limits = normalizeLimits(options);
+  const allMembers = getNonSystemMembersForContacts(db);
+  const memberById = new Map(allMembers.map((member) => [member.id, member]));
+  const messageRows = queryRelationshipMessages(db, filter).filter((message) => memberById.has(message.senderId));
+  const activeMembers = buildActiveMembers(allMembers, messageRows);
+  const activeMemberById = new Map(activeMembers.map((member) => [member.id, member]));
+  if (activeMembers.length < 2) {
+    return emptyResult(allMembers.length, activeMembers.length);
+  }
+  const edgeByPair = /* @__PURE__ */ new Map();
+  for (const pair of accumulateCoOccurrencePairs(messageRows)) {
+    if (!activeMemberById.has(pair.sourceId) || !activeMemberById.has(pair.targetId)) continue;
+    const edge = ensureEdge(edgeByPair, activeMemberById, pair.sourceId, pair.targetId);
+    edge.coOccurrenceCount += pair.coOccurrenceCount;
+    edge.coOccurrenceRawScore += pair.rawScore;
+    edge.lastInteractionTs = maxTimestamp(edge.lastInteractionTs, pair.lastOccurrenceTs);
+  }
+  accumulateReplies(db, filter, activeMemberById, edgeByPair);
+  accumulateMentions(db, filter, activeMembers, activeMemberById, edgeByPair);
+  const weightedEdges = [...edgeByPair.values()].map((edge) => ({ ...edge, weight: roundNum2(computeEdgeWeight(edge)) })).filter((edge) => edge.weight >= MIN_EDGE_WEIGHT).sort(compareEdges);
+  if (weightedEdges.length === 0) {
+    return emptyResult(allMembers.length, activeMembers.length);
+  }
+  const candidateNodeKeys = selectCandidateNodeKeys(weightedEdges, limits.nodeLimit);
+  const candidateEdges = weightedEdges.filter(
+    (edge) => candidateNodeKeys.has(edge.sourceKey) && candidateNodeKeys.has(edge.targetKey)
+  );
+  const keptEdges = selectEdges(candidateEdges, limits.perNodeEdgeLimit, limits.edgeLimit);
+  const displayedNodeKeys = /* @__PURE__ */ new Set();
+  for (const edge of keptEdges) {
+    displayedNodeKeys.add(edge.sourceKey);
+    displayedNodeKeys.add(edge.targetKey);
+  }
+  const displayedMembers = activeMembers.filter((member) => displayedNodeKeys.has(member.key));
+  const degreeByKey = computeDegreeByKey(keptEdges);
+  const rankedMembers = [...displayedMembers].sort((a, b) => {
+    const degreeDiff = (degreeByKey.get(b.key) ?? 0) - (degreeByKey.get(a.key) ?? 0);
+    return degreeDiff || b.messageCount - a.messageCount || a.key.localeCompare(b.key);
+  });
+  const communityAssignments = detectWeightedCommunities(rankedMembers, keptEdges, degreeByKey);
+  const communityByNodeKey = /* @__PURE__ */ new Map();
+  for (const community of communityAssignments) {
+    for (const nodeKey of community.nodeKeys) communityByNodeKey.set(nodeKey, community);
+  }
+  const maxDegree = Math.max(...degreeByKey.values(), 1);
+  const renderNodes = [];
+  const memberDetails = [];
+  const incidentTotals = buildIncidentTotals(weightedEdges);
+  for (const [index, member] of rankedMembers.entries()) {
+    const degree = degreeByKey.get(member.key) ?? 0;
+    const score = degree / maxDegree;
+    const community = communityByNodeKey.get(member.key);
+    const position = layoutNode(member.key, index, community, rankedMembers, communityByNodeKey);
+    const totals = incidentTotals.get(member.key) ?? createIncidentTotals();
+    const rank = index + 1;
+    renderNodes.push({
+      key: member.key,
+      displayName: member.displayName,
+      avatar: member.avatar,
+      score: roundNum2(score),
+      rank,
+      communityId: community.id,
+      x: position.x,
+      y: position.y,
+      size: roundNum2(18 + Math.sqrt(score) * 30, 2),
+      color: community.color,
+      labelVisibility: rank <= 8 ? 2 : rank <= 30 ? 1 : 0
+    });
+    memberDetails.push({
+      key: member.key,
+      memberId: member.id,
+      platformId: member.platformId,
+      displayName: member.displayName,
+      avatar: member.avatar,
+      messageCount: member.messageCount,
+      lastMessageTs: member.lastMessageTs,
+      relationshipScore: roundNum2(score),
+      rank,
+      communityId: community.id,
+      replyInteractionCount: totals.replyInteractionCount,
+      mentionInteractionCount: totals.mentionInteractionCount,
+      coOccurrenceCount: totals.coOccurrenceCount,
+      coOccurrenceRawScore: roundNum2(totals.coOccurrenceRawScore),
+      lastInteractionTs: totals.lastInteractionTs
+    });
+  }
+  const maxEdgeWeight = Math.max(...keptEdges.map((edge) => edge.weight), 1);
+  const renderEdges = keptEdges.map((edge) => ({
+    id: edge.id,
+    sourceKey: edge.sourceKey,
+    targetKey: edge.targetKey,
+    weight: edge.weight,
+    visibility: edge.weight / maxEdgeWeight >= 0.35 ? 2 : 1,
+    lastInteractionTs: edge.lastInteractionTs
+  }));
+  const edgeDetails = keptEdges.map((edge) => ({
+    id: edge.id,
+    sourceKey: edge.sourceKey,
+    targetKey: edge.targetKey,
+    weight: edge.weight,
+    coOccurrenceCount: edge.coOccurrenceCount,
+    coOccurrenceRawScore: roundNum2(edge.coOccurrenceRawScore),
+    replyInteractionCount: edge.replyInteractionCount,
+    mentionInteractionCount: edge.mentionInteractionCount,
+    lastInteractionTs: edge.lastInteractionTs
+  }));
+  const renderCommunities = communityAssignments.map((community, index) => ({
+    id: community.id,
+    label: `community-${index + 1}`,
+    size: community.nodeKeys.length,
+    x: community.x,
+    y: community.y,
+    color: community.color
+  }));
+  return {
+    graph: { nodes: renderNodes, edges: renderEdges, communities: renderCommunities },
+    members: memberDetails,
+    edges: edgeDetails,
+    stats: {
+      totalMembers: allMembers.length,
+      activeMembers: activeMembers.length,
+      displayedMembers: renderNodes.length,
+      displayedEdges: renderEdges.length,
+      communityCount: renderCommunities.length
+    },
+    algorithmVersion: GROUP_RELATIONSHIP_GALAXY_ALGORITHM_VERSION
+  };
+}
+function queryRelationshipMessages(db, filter) {
+  const { clause, params } = buildTimeFilter(filter, "msg");
+  const where = appendConditions(clause, ["msg.type NOT IN (80, 81)"]);
+  return db.prepare(`SELECT msg.sender_id as senderId, msg.ts FROM message msg ${where} ORDER BY msg.ts ASC, msg.id ASC`).all(...params);
+}
+function buildActiveMembers(allMembers, messages) {
+  const messageStats = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    const stats = messageStats.get(message.senderId) ?? { count: 0, lastTs: 0 };
+    stats.count++;
+    stats.lastTs = Math.max(stats.lastTs, message.ts);
+    messageStats.set(message.senderId, stats);
+  }
+  const active = allMembers.filter((member) => messageStats.has(member.id)).map((member) => ({
+    ...member,
+    key: memberKey(member.id),
+    displayName: member.name,
+    messageCount: messageStats.get(member.id).count,
+    lastMessageTs: messageStats.get(member.id).lastTs || null
+  }));
+  const nameCounts = /* @__PURE__ */ new Map();
+  for (const member of active) nameCounts.set(member.displayName, (nameCounts.get(member.displayName) ?? 0) + 1);
+  for (const member of active) {
+    if ((nameCounts.get(member.displayName) ?? 0) > 1) {
+      member.displayName = `${member.displayName}#${member.platformId.slice(-4)}`;
+    }
+  }
+  return active;
+}
+function accumulateReplies(db, filter, activeMemberById, edgeByPair) {
+  if (!hasColumn(db, "message", "reply_to_message_id") || !hasColumn(db, "message", "platform_message_id")) return;
+  const { clause, params } = buildTimeFilter(filter, "msg");
+  const conditions = ["msg.type NOT IN (80, 81)", "target.type NOT IN (80, 81)", "msg.reply_to_message_id IS NOT NULL"];
+  const targetParams = [];
+  if (filter?.startTs !== void 0) {
+    conditions.push("target.ts >= ?");
+    targetParams.push(filter.startTs);
+  }
+  if (filter?.endTs !== void 0) {
+    conditions.push("target.ts <= ?");
+    targetParams.push(filter.endTs);
+  }
+  const rows = db.prepare(
+    `SELECT msg.sender_id as replySenderId, msg.ts as replyTs, target.sender_id as targetSenderId
+       FROM message msg
+       JOIN message target ON msg.reply_to_message_id = target.platform_message_id
+       ${appendConditions(clause, conditions)}`
+  ).all(...params, ...targetParams);
+  for (const row of rows) {
+    if (row.replySenderId === row.targetSenderId) continue;
+    if (!activeMemberById.has(row.replySenderId) || !activeMemberById.has(row.targetSenderId)) continue;
+    const edge = ensureEdge(edgeByPair, activeMemberById, row.replySenderId, row.targetSenderId);
+    edge.replyInteractionCount++;
+    edge.lastInteractionTs = maxTimestamp(edge.lastInteractionTs, row.replyTs);
+  }
+}
+function accumulateMentions(db, filter, activeMembers, activeMemberById, edgeByPair) {
+  const nameToMemberId = buildMentionNameIndex(db, activeMembers);
+  const { clause, params } = buildTimeFilter(filter, "msg");
+  const where = appendConditions(clause, ["msg.type = 0", "msg.content IS NOT NULL", "msg.content LIKE '%@%'"]);
+  const rows = db.prepare(`SELECT msg.sender_id as senderId, msg.ts, msg.content FROM message msg ${where}`).all(...params);
+  const mentionRegex = /@([^\s@]+)/g;
+  for (const row of rows) {
+    if (!activeMemberById.has(row.senderId)) continue;
+    const mentionedInMessage = /* @__PURE__ */ new Set();
+    for (const match of row.content.matchAll(mentionRegex)) {
+      const mentionedId = nameToMemberId.get(match[1]);
+      if (mentionedId === null || mentionedId === void 0 || mentionedId === row.senderId) continue;
+      if (!activeMemberById.has(mentionedId) || mentionedInMessage.has(mentionedId)) continue;
+      mentionedInMessage.add(mentionedId);
+      const edge = ensureEdge(edgeByPair, activeMemberById, row.senderId, mentionedId);
+      edge.mentionInteractionCount++;
+      edge.lastInteractionTs = maxTimestamp(edge.lastInteractionTs, row.ts);
+    }
+  }
+}
+function buildMentionNameIndex(db, members) {
+  const index = /* @__PURE__ */ new Map();
+  const addName = (name, memberId) => {
+    const trimmed = name.trim();
+    if (!trimmed) return;
+    const existing = index.get(trimmed);
+    if (existing === void 0 || existing === memberId) index.set(trimmed, memberId);
+    else index.set(trimmed, null);
+  };
+  for (const member of members) {
+    addName(member.name, member.id);
+    for (const alias of member.aliases) addName(alias, member.id);
+  }
+  if (hasTable(db, "member_name_history")) {
+    const memberIds = new Set(members.map((member) => member.id));
+    const rows = db.prepare("SELECT member_id as memberId, name FROM member_name_history").all();
+    for (const row of rows) {
+      if (memberIds.has(row.memberId)) addName(row.name, row.memberId);
+    }
+  }
+  return index;
+}
+function ensureEdge(edgeByPair, memberById, aId, bId) {
+  const sourceId = Math.min(aId, bId);
+  const targetId = Math.max(aId, bId);
+  const id = `${memberKey(sourceId)}--${memberKey(targetId)}`;
+  const existing = edgeByPair.get(id);
+  if (existing) return existing;
+  const created = {
+    id,
+    sourceId,
+    targetId,
+    sourceKey: memberById.get(sourceId).key,
+    targetKey: memberById.get(targetId).key,
+    coOccurrenceCount: 0,
+    coOccurrenceRawScore: 0,
+    replyInteractionCount: 0,
+    mentionInteractionCount: 0,
+    lastInteractionTs: null,
+    weight: 0
+  };
+  edgeByPair.set(id, created);
+  return created;
+}
+function computeEdgeWeight(edge) {
+  return edge.coOccurrenceRawScore + edge.replyInteractionCount * REPLY_WEIGHT + edge.mentionInteractionCount * MENTION_WEIGHT + edge.coOccurrenceCount * CO_OCCURRENCE_COUNT_WEIGHT;
+}
+function selectCandidateNodeKeys(edges, nodeLimit) {
+  const degree = computeDegreeByKey(edges);
+  return new Set(
+    [...degree.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, nodeLimit).map(([key]) => key)
+  );
+}
+function selectEdges(edges, perNodeLimit, edgeLimit) {
+  const incident = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    for (const key of [edge.sourceKey, edge.targetKey]) {
+      const list = incident.get(key) ?? [];
+      list.push(edge);
+      incident.set(key, list);
+    }
+  }
+  const selectedIds = /* @__PURE__ */ new Set();
+  for (const list of incident.values()) {
+    list.sort(compareEdges);
+    for (const edge of list.slice(0, perNodeLimit)) selectedIds.add(edge.id);
+  }
+  return edges.filter((edge) => selectedIds.has(edge.id)).sort(compareEdges).slice(0, edgeLimit);
+}
+function computeDegreeByKey(edges) {
+  const degree = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    degree.set(edge.sourceKey, (degree.get(edge.sourceKey) ?? 0) + edge.weight);
+    degree.set(edge.targetKey, (degree.get(edge.targetKey) ?? 0) + edge.weight);
+  }
+  return degree;
+}
+function detectWeightedCommunities(members, edges, degreeByKey) {
+  const parent = new Map(members.map((member) => [member.key, member.key]));
+  const strongestByKey = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    strongestByKey.set(edge.sourceKey, Math.max(strongestByKey.get(edge.sourceKey) ?? 0, edge.weight));
+    strongestByKey.set(edge.targetKey, Math.max(strongestByKey.get(edge.targetKey) ?? 0, edge.weight));
+  }
+  const find = (key) => {
+    const current = parent.get(key) ?? key;
+    if (current === key) return current;
+    const root = find(current);
+    parent.set(key, root);
+    return root;
+  };
+  const union = (a, b) => {
+    const aRoot = find(a);
+    const bRoot = find(b);
+    if (aRoot === bRoot) return;
+    const [source, target] = aRoot.localeCompare(bRoot) <= 0 ? [aRoot, bRoot] : [bRoot, aRoot];
+    parent.set(target, source);
+  };
+  for (const edge of edges) {
+    const sourceThreshold = (strongestByKey.get(edge.sourceKey) ?? edge.weight) * 0.6;
+    const targetThreshold = (strongestByKey.get(edge.targetKey) ?? edge.weight) * 0.6;
+    if (edge.weight >= sourceThreshold && edge.weight >= targetThreshold) union(edge.sourceKey, edge.targetKey);
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    const root = find(member.key);
+    const list = groups.get(root) ?? [];
+    list.push(member.key);
+    groups.set(root, list);
+  }
+  const sortedGroups = [...groups.values()].map((keys) => keys.sort()).sort((a, b) => {
+    const aWeight = a.reduce((sum, key) => sum + (degreeByKey.get(key) ?? 0), 0);
+    const bWeight = b.reduce((sum, key) => sum + (degreeByKey.get(key) ?? 0), 0);
+    return bWeight - aWeight || a[0].localeCompare(b[0]);
+  });
+  return sortedGroups.map((nodeKeys, index) => {
+    const center = layoutCommunity(index, sortedGroups.length);
+    return {
+      id: `community:${nodeKeys[0]}`,
+      nodeKeys,
+      color: COMMUNITY_COLORS[stableHash(nodeKeys[0]) % COMMUNITY_COLORS.length],
+      x: center.x,
+      y: center.y
+    };
+  });
+}
+function layoutCommunity(index, count) {
+  if (index === 0 || count === 1) return { x: 0, y: 0 };
+  const ringIndex = index - 1;
+  const ring = Math.floor(ringIndex / 6);
+  const position = ringIndex % 6;
+  const radius = 380 + ring * 280;
+  const angle = -Math.PI / 2 + position / 6 * Math.PI * 2 + ring * 0.31;
+  return { x: roundNum2(Math.cos(angle) * radius, 2), y: roundNum2(Math.sin(angle) * radius, 2) };
+}
+function layoutNode(nodeKey, globalIndex, community, members, communityByNodeKey) {
+  const communityMembers = members.filter((member) => communityByNodeKey.get(member.key)?.id === community.id);
+  const localIndex = communityMembers.findIndex((member) => member.key === nodeKey);
+  const angle = localIndex * 2.399963229728653 + stableHash(nodeKey) % 1e3 / 1e3;
+  const radius = localIndex === 0 ? 0 : 54 + Math.sqrt(localIndex) * 42;
+  const globalJitter = globalIndex % 3 * 2;
+  return {
+    x: roundNum2(community.x + Math.cos(angle) * (radius + globalJitter), 2),
+    y: roundNum2(community.y + Math.sin(angle) * (radius + globalJitter), 2)
+  };
+}
+function buildIncidentTotals(edges) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    for (const key of [edge.sourceKey, edge.targetKey]) {
+      const item = totals.get(key) ?? createIncidentTotals();
+      item.replyInteractionCount += edge.replyInteractionCount;
+      item.mentionInteractionCount += edge.mentionInteractionCount;
+      item.coOccurrenceCount += edge.coOccurrenceCount;
+      item.coOccurrenceRawScore += edge.coOccurrenceRawScore;
+      item.lastInteractionTs = maxTimestamp(item.lastInteractionTs, edge.lastInteractionTs);
+      totals.set(key, item);
+    }
+  }
+  return totals;
+}
+function createIncidentTotals() {
+  return {
+    replyInteractionCount: 0,
+    mentionInteractionCount: 0,
+    coOccurrenceCount: 0,
+    coOccurrenceRawScore: 0,
+    lastInteractionTs: null
+  };
+}
+function normalizeLimits(options) {
+  return {
+    nodeLimit: normalizeLimit(options.nodeLimit, DEFAULT_LIMITS.nodeLimit),
+    edgeLimit: normalizeLimit(options.edgeLimit, DEFAULT_LIMITS.edgeLimit),
+    perNodeEdgeLimit: normalizeLimit(options.perNodeEdgeLimit, DEFAULT_LIMITS.perNodeEdgeLimit)
+  };
+}
+function normalizeLimit(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function appendConditions(clause, conditions) {
+  const existing = clause.trim().replace(/^WHERE\s+/i, "");
+  return `WHERE ${[existing, ...conditions].filter(Boolean).join(" AND ")}`;
+}
+function emptyResult(totalMembers, activeMembers) {
+  return {
+    graph: { nodes: [], edges: [], communities: [] },
+    members: [],
+    edges: [],
+    stats: { totalMembers, activeMembers, displayedMembers: 0, displayedEdges: 0, communityCount: 0 },
+    algorithmVersion: GROUP_RELATIONSHIP_GALAXY_ALGORITHM_VERSION
+  };
+}
+function compareEdges(a, b) {
+  return b.weight - a.weight || a.id.localeCompare(b.id);
+}
+function memberKey(memberId) {
+  return `member:${memberId}`;
+}
+function maxTimestamp(current, next) {
+  if (next === null) return current;
+  return Math.max(current ?? 0, next) || null;
+}
+function roundNum2(value, digits = 4) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+function stableHash(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
 // ../../packages/core/src/query/advanced/relationship.ts
 var ICE_BREAK_THRESHOLD = 24 * 60 * 60;
 var DEFAULT_PERSEVERANCE_THRESHOLD = 300;
 function getRelationshipStats(db, filter, options) {
   const perseveranceThreshold = options?.perseveranceThreshold ?? DEFAULT_PERSEVERANCE_THRESHOLD;
-  const emptyResult = {
+  const emptyResult2 = {
     months: [],
     members: [],
     totalSessions: 0,
@@ -6021,7 +6396,7 @@ function getRelationshipStats(db, filter, options) {
     monthlyPerseverance: []
   };
   const sessionCount = db.prepare("SELECT COUNT(*) as count FROM segment").get();
-  if (!sessionCount || sessionCount.count === 0) return emptyResult;
+  if (!sessionCount || sessionCount.count === 0) return emptyResult2;
   const timeConditions = [];
   const params = [];
   if (filter?.startTs !== void 0) {
@@ -6223,8 +6598,8 @@ function getJourneyStats(db, filter) {
   const indexAvailable = hasSessionIndex(db) && hasTable(db, "message_context");
   const segmentRows = indexAvailable ? querySegmentRows(db, effectiveFilter) : [];
   const segmentCountByMonth = /* @__PURE__ */ new Map();
-  for (const segment2 of segmentRows) {
-    segmentCountByMonth.set(segment2.startMonth, (segmentCountByMonth.get(segment2.startMonth) ?? 0) + 1);
+  for (const segment of segmentRows) {
+    segmentCountByMonth.set(segment.startMonth, (segmentCountByMonth.get(segment.startMonth) ?? 0) + 1);
   }
   const firstRow = monthlyRows[0];
   const lastRow = monthlyRows[monthlyRows.length - 1];
@@ -6754,7 +7129,7 @@ function getCheckInAnalysis(db, filter) {
   return computeCheckIn(dailyActivity);
 }
 function computeMemeBattle(messages) {
-  const emptyResult = {
+  const emptyResult2 = {
     topBattles: [],
     rankByCount: [],
     rankByImageCount: [],
@@ -6788,7 +7163,7 @@ function computeMemeBattle(messages) {
     }
   }
   processChain();
-  if (battles.length === 0) return emptyResult;
+  if (battles.length === 0) return emptyResult2;
   const topBattles = battles.map((battle) => ({
     startTime: battle.startTime,
     endTime: battle.endTime,
@@ -6867,7 +7242,7 @@ function getMemeBattleAnalysis(db, filter) {
   return computeMemeBattle(messages);
 }
 function computeNightOwl(messages) {
-  const emptyResult = {
+  const emptyResult2 = {
     nightOwlRank: [],
     lastSpeakerRank: [],
     firstSpeakerRank: [],
@@ -6875,7 +7250,7 @@ function computeNightOwl(messages) {
     champions: [],
     totalDays: 0
   };
-  if (messages.length === 0) return emptyResult;
+  if (messages.length === 0) return emptyResult2;
   function getNightOwlTitleByCount(count) {
     if (count === 0) return "\u517B\u751F\u8FBE\u4EBA";
     if (count <= 20) return "\u5076\u5C14\u5931\u7720";
@@ -7702,7 +8077,7 @@ function mergeMembers2(sources, collidingIds) {
 }
 
 // ../../packages/core/src/schema/tables.ts
-var CURRENT_SCHEMA_VERSION = 8;
+var CURRENT_SCHEMA_VERSION = 9;
 var CHAT_DB_TABLES = `
   CREATE TABLE IF NOT EXISTS meta (
     name TEXT NOT NULL,
@@ -7776,13 +8151,6 @@ var CHAT_DB_INDEXES = `
   CREATE INDEX IF NOT EXISTS idx_context_segment ON message_context(segment_id);
 `;
 var CHAT_DB_SCHEMA = CHAT_DB_TABLES + CHAT_DB_INDEXES;
-var FTS_TABLE_SCHEMA = `
-  CREATE VIRTUAL TABLE IF NOT EXISTS message_fts USING fts5(
-    content,
-    content='',
-    content_rowid=id
-  );
-`;
 
 // ../../packages/core/src/schema/migrations.ts
 function getSchemaVersion(db) {
@@ -8040,282 +8408,30 @@ var appLogger = {
   getLogPath: () => instance?.getLogPath() ?? null
 };
 
-// ../../packages/node-runtime/src/nlp/segmenter.ts
-import * as fs8 from "fs";
-import * as path13 from "path";
-import { createRequire } from "module";
-var _nlpDir = null;
-var jiebaInstances = /* @__PURE__ */ new Map();
-var require2 = createRequire(import.meta.url);
-function initNlpDir(nlpDir) {
-  _nlpDir = nlpDir;
-}
-function getNlpDir() {
-  return _nlpDir;
-}
-function existsDictOnDisk(dictId) {
-  if (!_nlpDir) return false;
-  return fs8.existsSync(path13.join(_nlpDir, `${dictId}.dict`));
-}
-function tryLoadDictFromDisk(dictId) {
-  if (!_nlpDir) return null;
-  const dictPath = path13.join(_nlpDir, `${dictId}.dict`);
-  if (!fs8.existsSync(dictPath)) return null;
-  try {
-    return fs8.readFileSync(dictPath);
-  } catch {
-    return null;
-  }
-}
-function getJieba(dictType = "default") {
-  const effectiveType = dictType === "default" ? "zh-CN" : dictType;
-  const cached = jiebaInstances.get(effectiveType);
-  if (cached) {
-    if (cached.fromDiskDict === existsDictOnDisk(effectiveType)) return cached.instance;
-    jiebaInstances.delete(effectiveType);
-    console.error(`[NLP] jieba cache invalidated (dict ${cached.fromDiskDict ? "removed" : "added"}): ${effectiveType}`);
-  }
-  try {
-    const { Jieba } = require2("@node-rs/jieba");
-    let instance2;
-    const diskDict = tryLoadDictFromDisk(effectiveType);
-    if (diskDict) {
-      instance2 = Jieba.withDict(diskDict);
-      console.error(`[NLP] jieba dict loaded: ${effectiveType} (${diskDict.length} bytes)`);
-    } else {
-      instance2 = new Jieba();
-      console.warn(`[NLP] jieba dict missing: ${effectiveType}, fallback to built-in tokenizer`);
-    }
-    jiebaInstances.set(effectiveType, { instance: instance2, fromDiskDict: !!diskDict });
-    return instance2;
-  } catch (error) {
-    console.error(`[NLP] Failed to load jieba module (dict=${effectiveType}):`, error);
-    throw new Error(`jieba \u6A21\u5757\u52A0\u8F7D\u5931\u8D25 (${effectiveType})`);
-  }
-}
-function clearJiebaInstance(dictType) {
-  jiebaInstances.delete(dictType);
-  console.error(`[NLP] jieba instance cleared: ${dictType}`);
-}
-function segmentChinese(text, options = {}) {
-  const { posFilterMode = "meaningful", customPosTags, dictType = "default" } = options;
-  const cleaned = cleanText(text);
-  if (!cleaned) return [];
-  try {
-    const jieba = getJieba(dictType);
-    if (posFilterMode === "all") return jieba.cut(cleaned, false);
-    const tagged = jieba.tag(cleaned);
-    const allowedTags = posFilterMode === "custom" && customPosTags ? new Set(customPosTags) : MEANINGFUL_POS_TAGS;
-    return tagged.filter((item) => allowedTags.has(item.tag)).map((item) => item.word);
-  } catch (error) {
-    console.error("[NLP] Chinese segmentation failed:", error);
-    try {
-      return getJieba("default").cut(cleanText(text), false);
-    } catch {
-      return cleaned.split("");
-    }
-  }
-}
-function segmentEnglish(text) {
-  const cleaned = cleanText(text);
-  if (!cleaned) return [];
-  try {
-    const segmenter = new Intl.Segmenter("en", { granularity: "word" });
-    return [...segmenter.segment(cleaned)].filter((s) => s.isWordLike).map((s) => s.segment.toLowerCase());
-  } catch {
-    return cleaned.toLowerCase().split(/\s+/).filter((w) => w.length > 0);
-  }
-}
-function segmentJapanese(text) {
-  const cleaned = cleanText(text);
-  if (!cleaned) return [];
-  try {
-    const segmenter = new Intl.Segmenter("ja", { granularity: "word" });
-    return [...segmenter.segment(cleaned)].filter((s) => s.isWordLike).map((s) => s.segment);
-  } catch {
-    return cleaned.split("").filter((ch) => ch.trim().length > 0);
-  }
-}
-function segment(text, locale, options = {}) {
-  const {
-    minLength,
-    posFilterMode = "meaningful",
-    customPosTags,
-    enableStopwords = true,
-    dictType = "default"
-  } = options;
-  const isChinese = locale.startsWith("zh");
-  const isJapanese = locale === "ja-JP";
-  const defaultMinLength = isChinese || isJapanese ? 2 : 3;
-  const effectiveMinLength = minLength ?? defaultMinLength;
-  let words;
-  if (isChinese) {
-    words = segmentChinese(text, { posFilterMode, customPosTags, dictType });
-  } else if (isJapanese) {
-    words = segmentJapanese(text);
-  } else {
-    words = segmentEnglish(text);
-  }
-  return words.filter((word) => isValidWord(word, locale, effectiveMinLength, enableStopwords, isStopword));
-}
-function batchSegmentWithFrequency(texts, locale, options = {}) {
-  const {
-    minLength,
-    minCount = 2,
-    topN = 100,
-    posFilterMode,
-    customPosTags,
-    enableStopwords,
-    dictType,
-    excludeWords
-  } = options;
-  const wordFrequency = /* @__PURE__ */ new Map();
-  const excludeSet = excludeWords?.length ? new Set(excludeWords.map((w) => w.toLowerCase())) : null;
-  for (const text of texts) {
-    const words = segment(text, locale, { minLength, posFilterMode, customPosTags, enableStopwords, dictType });
-    for (const word of words) {
-      if (excludeSet && excludeSet.has(word.toLowerCase())) continue;
-      wordFrequency.set(word, (wordFrequency.get(word) || 0) + 1);
-    }
-  }
-  const filtered = /* @__PURE__ */ new Map();
-  let totalWords = 0;
-  for (const [word, count] of wordFrequency) {
-    if (count >= minCount) {
-      filtered.set(word, count);
-      totalWords += count;
-    }
-  }
-  const sorted = [...filtered.entries()].sort((a, b) => b[1] - a[1]).slice(0, topN);
-  return { words: new Map(sorted), uniqueWords: filtered.size, totalWords };
-}
-function batchSegmentChineseWithStats(texts, locale, options = {}) {
-  const {
-    minLength,
-    minCount = 2,
-    topN = 100,
-    posFilterMode = "meaningful",
-    customPosTags,
-    enableStopwords = true,
-    dictType = "default",
-    excludeWords
-  } = options;
-  const effectiveMinLength = minLength ?? 2;
-  const allowedTags = posFilterMode === "custom" && customPosTags ? new Set(customPosTags) : MEANINGFUL_POS_TAGS;
-  const excludeSet = excludeWords?.length ? new Set(excludeWords.map((w) => w.toLowerCase())) : null;
-  const wordFrequency = /* @__PURE__ */ new Map();
-  const posTagStats = /* @__PURE__ */ new Map();
-  try {
-    const jieba = getJieba(dictType);
-    for (const text of texts) {
-      const cleaned = cleanText(text);
-      if (!cleaned) continue;
-      for (const { tag, word } of jieba.tag(cleaned)) {
-        if (!isValidWord(word, locale, effectiveMinLength, enableStopwords, isStopword)) continue;
-        posTagStats.set(tag, (posTagStats.get(tag) || 0) + 1);
-        if (!allowedTags.has(tag)) continue;
-        if (excludeSet && excludeSet.has(word.toLowerCase())) continue;
-        wordFrequency.set(word, (wordFrequency.get(word) || 0) + 1);
-      }
-    }
-  } catch (error) {
-    console.error("[NLP] Chinese single-pass segmentation failed:", error);
-  }
-  const filtered = /* @__PURE__ */ new Map();
-  let totalWords = 0;
-  for (const [word, count] of wordFrequency) {
-    if (count >= minCount) {
-      filtered.set(word, count);
-      totalWords += count;
-    }
-  }
-  const sorted = [...filtered.entries()].sort((a, b) => b[1] - a[1]).slice(0, topN);
-  return { words: new Map(sorted), uniqueWords: filtered.size, totalWords, posTagStats };
-}
-function collectPosTagStats(texts, minWordLength = 2, enableStopwords = true, dictType = "default") {
-  const posStats = /* @__PURE__ */ new Map();
-  try {
-    const jieba = getJieba(dictType);
-    for (const text of texts) {
-      const cleaned = cleanText(text);
-      if (!cleaned) continue;
-      const tagged = jieba.tag(cleaned);
-      for (const item of tagged) {
-        if (!isValidWord(item.word, "zh-CN", minWordLength, enableStopwords, isStopword)) continue;
-        posStats.set(item.tag, (posStats.get(item.tag) || 0) + 1);
-      }
-    }
-  } catch (error) {
-    console.error("[NLP] Failed to collect POS stats:", error);
-  }
-  return posStats;
-}
-function getPosTagDefinitions() {
-  return POS_TAG_DEFINITIONS;
-}
-
-// ../../packages/node-runtime/src/nlp/fts-tokenizer.ts
-function tokenizeForFts(text) {
-  if (!text || text.trim().length === 0) return "";
-  try {
-    const jieba = getJieba();
-    const tokens = jieba.cut(text, false);
-    return tokens.map((t) => t.trim().toLowerCase()).filter((t) => t.length > 0).join(" ");
-  } catch {
-    return fallbackTokenize(text);
-  }
-}
-function fallbackTokenize(text) {
-  return text.toLowerCase().split(/\s+/).filter((t) => t.length > 0).join(" ");
-}
-function escapeToken(token) {
-  return `"${token.replace(/"/g, '""')}"`;
-}
-function tokenizeQueryForFts(keywords) {
-  if (keywords.length === 0) return "";
-  const groups = keywords.map((kw) => {
-    const trimmed = kw.trim();
-    if (!trimmed) return "";
-    try {
-      const jieba = getJieba();
-      const tokens = jieba.cut(trimmed, false).map((t) => t.trim().toLowerCase()).filter((t) => t.length > 0);
-      if (tokens.length === 0) return "";
-      if (tokens.length === 1) return escapeToken(tokens[0]);
-      return tokens.map(escapeToken).join(" ");
-    } catch {
-      const simple = trimmed.toLowerCase().trim();
-      return simple ? escapeToken(simple) : "";
-    }
-  }).filter((g) => g.length > 0);
-  if (groups.length === 0) return "";
-  if (groups.length === 1) return groups[0];
-  return groups.map((g) => g.includes(" ") ? `(${g})` : g).join(" OR ");
-}
-
 // ../../packages/node-runtime/src/migrations/electron-data-migration.ts
-import * as fs9 from "fs";
+import * as fs8 from "fs";
 import * as os3 from "os";
-import * as path14 from "path";
+import * as path13 from "path";
 var SYSTEM_SUBDIRS = ["ai", "settings", "cache", "logs", "nlp"];
 var STORAGE_CONFIG_FILE = "storage.json";
 function getElectronUserDataDir(options = {}) {
   const home = options.homeDir ?? os3.homedir();
   switch (options.platform ?? process.platform) {
     case "darwin":
-      return path14.join(home, "Library", "Application Support", "ChatLab");
+      return path13.join(home, "Library", "Application Support", "ChatLab");
     case "win32": {
-      const appData = options.appDataDir ?? process.env.APPDATA ?? path14.join(home, "AppData", "Roaming");
-      return path14.join(appData, "ChatLab");
+      const appData = options.appDataDir ?? process.env.APPDATA ?? path13.join(home, "AppData", "Roaming");
+      return path13.join(appData, "ChatLab");
     }
     default:
-      return path14.join(home, ".config", "ChatLab");
+      return path13.join(home, ".config", "ChatLab");
   }
 }
 function readElectronStorageConfig(electronUserData) {
-  const configPath = path14.join(electronUserData, STORAGE_CONFIG_FILE);
-  if (!fs9.existsSync(configPath)) return {};
+  const configPath = path13.join(electronUserData, STORAGE_CONFIG_FILE);
+  if (!fs8.existsSync(configPath)) return {};
   try {
-    return JSON.parse(fs9.readFileSync(configPath, "utf-8"));
+    return JSON.parse(fs8.readFileSync(configPath, "utf-8"));
   } catch {
     return {};
   }
@@ -8323,45 +8439,45 @@ function readElectronStorageConfig(electronUserData) {
 function resolveElectronDataDir() {
   const electronUserData = getElectronUserDataDir();
   const storageConfig = readElectronStorageConfig(electronUserData);
-  if (storageConfig.dataDir && path14.isAbsolute(storageConfig.dataDir)) {
+  if (storageConfig.dataDir && path13.isAbsolute(storageConfig.dataDir)) {
     return storageConfig.dataDir;
   }
-  return path14.join(electronUserData, "data");
+  return path13.join(electronUserData, "data");
 }
 function hasDatabases(dir) {
-  const dbDir = path14.join(dir, "databases");
-  if (!fs9.existsSync(dbDir)) return false;
+  const dbDir = path13.join(dir, "databases");
+  if (!fs8.existsSync(dbDir)) return false;
   try {
-    return fs9.readdirSync(dbDir).some((f) => f.endsWith(".db"));
+    return fs8.readdirSync(dbDir).some((f) => f.endsWith(".db"));
   } catch {
     return false;
   }
 }
 function ensureDir2(dirPath) {
-  if (!fs9.existsSync(dirPath)) {
-    fs9.mkdirSync(dirPath, { recursive: true });
+  if (!fs8.existsSync(dirPath)) {
+    fs8.mkdirSync(dirPath, { recursive: true });
   }
 }
 function copyDirMerge(src, dest) {
   const stats = { copied: 0, skipped: 0 };
-  if (!fs9.existsSync(src)) return stats;
+  if (!fs8.existsSync(src)) return stats;
   ensureDir2(dest);
   let entries;
   try {
-    entries = fs9.readdirSync(src, { withFileTypes: true });
+    entries = fs8.readdirSync(src, { withFileTypes: true });
   } catch {
     return stats;
   }
   for (const entry of entries) {
-    const srcPath = path14.join(src, entry.name);
-    const destPath = path14.join(dest, entry.name);
+    const srcPath = path13.join(src, entry.name);
+    const destPath = path13.join(dest, entry.name);
     try {
       if (entry.isDirectory()) {
         const sub = copyDirMerge(srcPath, destPath);
         stats.copied += sub.copied;
         stats.skipped += sub.skipped;
-      } else if (!fs9.existsSync(destPath)) {
-        fs9.copyFileSync(srcPath, destPath);
+      } else if (!fs8.existsSync(destPath)) {
+        fs8.copyFileSync(srcPath, destPath);
         stats.copied++;
       } else {
         stats.skipped++;
@@ -8374,22 +8490,22 @@ function copyDirMerge(src, dest) {
 function writeMigrationLog(logDir, message) {
   try {
     ensureDir2(logDir);
-    const logPath = path14.join(logDir, "app.log");
+    const logPath = path13.join(logDir, "app.log");
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
-    fs9.appendFileSync(logPath, `[${ts}] [MIGRATION] ${message}
+    fs8.appendFileSync(logPath, `[${ts}] [MIGRATION] ${message}
 `, "utf-8");
   } catch {
   }
 }
 function wasElectronUsed() {
   const electronUserData = getElectronUserDataDir();
-  if (!fs9.existsSync(electronUserData)) return false;
-  return fs9.existsSync(path14.join(electronUserData, "Preferences")) || fs9.existsSync(path14.join(electronUserData, "Local Storage")) || fs9.existsSync(path14.join(electronUserData, "Session Storage")) || fs9.existsSync(path14.join(electronUserData, "data"));
+  if (!fs8.existsSync(electronUserData)) return false;
+  return fs8.existsSync(path13.join(electronUserData, "Preferences")) || fs8.existsSync(path13.join(electronUserData, "Local Storage")) || fs8.existsSync(path13.join(electronUserData, "Session Storage")) || fs8.existsSync(path13.join(electronUserData, "data"));
 }
 function verifyCliDataPath(databaseDir) {
-  if (fs9.existsSync(databaseDir)) {
+  if (fs8.existsSync(databaseDir)) {
     try {
-      if (fs9.readdirSync(databaseDir).some((f) => f.endsWith(".db"))) return true;
+      if (fs8.readdirSync(databaseDir).some((f) => f.endsWith(".db"))) return true;
     } catch {
     }
   }
@@ -8407,9 +8523,9 @@ function migrateFromElectronIfNeeded(systemDir) {
     let totalSkipped = 0;
     const movedDirs = [];
     for (const subDir of SYSTEM_SUBDIRS) {
-      const srcDir = path14.join(electronDataDir, subDir);
-      const destDir = path14.join(systemDir, subDir);
-      if (!fs9.existsSync(srcDir)) continue;
+      const srcDir = path13.join(electronDataDir, subDir);
+      const destDir = path13.join(systemDir, subDir);
+      if (!fs8.existsSync(srcDir)) continue;
       const { copied, skipped } = copyDirMerge(srcDir, destDir);
       if (copied > 0 || skipped > 0) {
         movedDirs.push(subDir);
@@ -8419,13 +8535,13 @@ function migrateFromElectronIfNeeded(systemDir) {
       }
     }
     for (const subDir of movedDirs) {
-      const srcDir = path14.join(electronDataDir, subDir);
+      const srcDir = path13.join(electronDataDir, subDir);
       try {
-        fs9.rmSync(srcDir, { recursive: true, force: true });
+        fs8.rmSync(srcDir, { recursive: true, force: true });
       } catch {
       }
     }
-    const logsDir = path14.join(systemDir, "logs");
+    const logsDir = path13.join(systemDir, "logs");
     const summary = `CLI first-run: detected Electron data at ${electronDataDir}, pointed user_data_dir there, copied ${totalCopied} system files (${movedDirs.join(", ") || "none"})`;
     writeMigrationLog(logsDir, summary);
     console.log(`[Migration] ${summary}`);
@@ -8439,7 +8555,7 @@ function migrateFromElectronIfNeeded(systemDir) {
     const errorMsg = error instanceof Error ? error.message : String(error);
     console.error("[Migration] Electron data migration failed:", errorMsg);
     try {
-      writeMigrationLog(path14.join(systemDir, "logs"), `Electron migration failed: ${errorMsg}`);
+      writeMigrationLog(path13.join(systemDir, "logs"), `Electron migration failed: ${errorMsg}`);
     } catch {
     }
     return { migrated: false, electronDetected: true, error: errorMsg };
@@ -8447,26 +8563,26 @@ function migrateFromElectronIfNeeded(systemDir) {
 }
 
 // ../../packages/node-runtime/src/cache/session-cache.ts
-import * as fs10 from "fs";
-import * as path15 from "path";
+import * as fs9 from "fs";
+import * as path14 from "path";
 function getCachePath(sessionId, cacheDir) {
-  return path15.join(cacheDir, `${sessionId}.cache.json`);
+  return path14.join(cacheDir, `${sessionId}.cache.json`);
 }
 function readCacheFile(cachePath) {
   try {
-    if (!fs10.existsSync(cachePath)) return null;
-    return JSON.parse(fs10.readFileSync(cachePath, "utf-8"));
+    if (!fs9.existsSync(cachePath)) return null;
+    return JSON.parse(fs9.readFileSync(cachePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeCacheFile(cachePath, content) {
   try {
-    const dir = path15.dirname(cachePath);
-    if (!fs10.existsSync(dir)) {
-      fs10.mkdirSync(dir, { recursive: true });
+    const dir = path14.dirname(cachePath);
+    if (!fs9.existsSync(dir)) {
+      fs9.mkdirSync(dir, { recursive: true });
     }
-    fs10.writeFileSync(cachePath, JSON.stringify(content), "utf-8");
+    fs9.writeFileSync(cachePath, JSON.stringify(content), "utf-8");
   } catch {
   }
 }
@@ -8486,7 +8602,7 @@ function invalidateCache(sessionId, cacheDir, key) {
   const cachePath = getCachePath(sessionId, cacheDir);
   try {
     if (!key) {
-      if (fs10.existsSync(cachePath)) fs10.unlinkSync(cachePath);
+      if (fs9.existsSync(cachePath)) fs9.unlinkSync(cachePath);
     } else {
       const file = readCacheFile(cachePath);
       if (file && file[key]) {
@@ -8500,7 +8616,7 @@ function invalidateCache(sessionId, cacheDir, key) {
 function deleteSessionCache(sessionId, cacheDir) {
   const cachePath = getCachePath(sessionId, cacheDir);
   try {
-    if (fs10.existsSync(cachePath)) fs10.unlinkSync(cachePath);
+    if (fs9.existsSync(cachePath)) fs9.unlinkSync(cachePath);
   } catch {
   }
 }
@@ -8554,8 +8670,8 @@ function computeAndSetMembersCache(db, sessionId, cacheDir) {
 }
 
 // ../../packages/node-runtime/src/data-dir-compat.ts
-import fs11 from "fs";
-import path16 from "path";
+import fs10 from "fs";
+import path15 from "path";
 var DataDirCompatibilityError = class extends Error {
   code;
   userDataDir;
@@ -8575,10 +8691,10 @@ var DataDirCompatibilityError = class extends Error {
 };
 function readDataDirCompatibilityMeta(userDataDir) {
   const metaPath = getMetaPath(userDataDir);
-  if (!fs11.existsSync(metaPath)) return null;
+  if (!fs10.existsSync(metaPath)) return null;
   let parsed;
   try {
-    parsed = JSON.parse(fs11.readFileSync(metaPath, "utf-8"));
+    parsed = JSON.parse(fs10.readFileSync(metaPath, "utf-8"));
   } catch (error) {
     throw createInvalidMetaError(userDataDir, metaPath, "Invalid data directory compatibility meta JSON.", error);
   }
@@ -8661,7 +8777,7 @@ function raiseDataDirMinRuntimeVersion(pathProvider, input) {
   return nextMeta;
 }
 function getMetaPath(userDataDir) {
-  return path16.join(userDataDir, ".chatlab-meta.json");
+  return path15.join(userDataDir, ".chatlab-meta.json");
 }
 function validateDataDirCompatibilityMeta(value, userDataDir, metaPath) {
   if (!isRecord2(value)) {
@@ -8732,15 +8848,15 @@ function mergeReasons(existing, next) {
   return [.../* @__PURE__ */ new Set([...existing, next])];
 }
 function writeMetaAtomic(userDataDir, metaPath, meta) {
-  fs11.mkdirSync(userDataDir, { recursive: true });
-  const tempPath = path16.join(userDataDir, `.chatlab-meta.json.${process.pid}.${Date.now()}.tmp`);
+  fs10.mkdirSync(userDataDir, { recursive: true });
+  const tempPath = path15.join(userDataDir, `.chatlab-meta.json.${process.pid}.${Date.now()}.tmp`);
   try {
-    fs11.writeFileSync(tempPath, `${JSON.stringify(meta, null, 2)}
+    fs10.writeFileSync(tempPath, `${JSON.stringify(meta, null, 2)}
 `, "utf-8");
-    fs11.renameSync(tempPath, metaPath);
+    fs10.renameSync(tempPath, metaPath);
   } catch (error) {
     try {
-      if (fs11.existsSync(tempPath)) fs11.unlinkSync(tempPath);
+      if (fs10.existsSync(tempPath)) fs10.unlinkSync(tempPath);
     } catch {
     }
     throw error;
@@ -8777,7 +8893,7 @@ function raiseChatDbCompatibilityGate(pathProvider, runtime) {
     });
   }
 }
-function getChatDbMigrations(deps) {
+function getChatDbMigrations() {
   const hasColumn2 = (db, tableName, columnName) => {
     const tableInfo = db.pragma(`table_info(${tableName})`);
     return tableInfo.some((col) => col.name === columnName);
@@ -8856,39 +8972,8 @@ function getChatDbMigrations(deps) {
     },
     {
       version: 4,
-      description: "Add FTS5 full-text search index",
-      up: (db) => {
-        const hasTable2 = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='message_fts'").get();
-        if (hasTable2) return;
-        db.exec(`
-          CREATE VIRTUAL TABLE IF NOT EXISTS message_fts USING fts5(
-            content,
-            content='',
-            content_rowid=id
-          )
-        `);
-        const tokenize = deps?.tokenizeForFts;
-        if (!tokenize) return;
-        const BATCH_SIZE = 5e3;
-        const insertFts = db.prepare("INSERT INTO message_fts(rowid, content) VALUES (?, ?)");
-        const countRow = db.prepare("SELECT COUNT(*) as total FROM message WHERE type = 0 AND content IS NOT NULL AND content != ''").get();
-        const total = countRow?.total ?? 0;
-        let offset = 0;
-        while (offset < total) {
-          const rows = db.prepare(
-            `SELECT id, content FROM message
-               WHERE type = 0 AND content IS NOT NULL AND content != ''
-               ORDER BY id ASC LIMIT ? OFFSET ?`
-          ).all(BATCH_SIZE, offset);
-          if (rows.length === 0) break;
-          for (const row of rows) {
-            const tokens = tokenize(row.content);
-            if (tokens) {
-              insertFts.run(row.id, tokens);
-            }
-          }
-          offset += BATCH_SIZE;
-        }
+      description: "Preserve the legacy schema migration sequence",
+      up: () => {
       }
     },
     {
@@ -9076,49 +9161,56 @@ function getChatDbMigrations(deps) {
           CREATE INDEX IF NOT EXISTS idx_message_reply_to ON message(reply_to_message_id);
         `);
       }
+    },
+    {
+      version: 9,
+      description: "Remove the obsolete per-session full-text index",
+      up: (db) => {
+        db.exec("DROP TABLE IF EXISTS message_fts");
+      }
     }
   ];
 }
 
 // ../../packages/node-runtime/src/services/contacts/paths.ts
-import path17 from "path";
+import path16 from "path";
 var CONTACTS_DIR_NAME = "contacts";
 var CONTACTS_FACTS_DIR_NAME = "facts";
 function getContactsDir(userDataDir) {
-  return path17.join(userDataDir, CONTACTS_DIR_NAME);
+  return path16.join(userDataDir, CONTACTS_DIR_NAME);
 }
 function getContactsFactsCacheDir(userDataDir) {
-  return path17.join(getContactsDir(userDataDir), CONTACTS_FACTS_DIR_NAME);
+  return path16.join(getContactsDir(userDataDir), CONTACTS_FACTS_DIR_NAME);
 }
 
 // ../../packages/node-runtime/src/services/global-insight/paths.ts
-import path18 from "path";
+import path17 from "path";
 function getGlobalInsightDir(userDataDir) {
-  return path18.join(userDataDir, "insight", "annual-summary");
+  return path17.join(userDataDir, "insight", "annual-summary");
 }
 function getGlobalInsightFactsCacheDir(userDataDir) {
-  return path18.join(getGlobalInsightDir(userDataDir), "facts");
+  return path17.join(getGlobalInsightDir(userDataDir), "facts");
 }
 
 // ../../packages/node-runtime/src/services/people/relationships/paths.ts
-import path19 from "path";
+import path18 from "path";
 var PEOPLE_DIR_NAME = "people";
 var RELATIONSHIPS_DIR_NAME = "relationships";
 var RELATIONSHIPS_FACTS_DIR_NAME = "facts";
 function getPeopleRelationshipsDir(userDataDir) {
-  return path19.join(userDataDir, PEOPLE_DIR_NAME, RELATIONSHIPS_DIR_NAME);
+  return path18.join(userDataDir, PEOPLE_DIR_NAME, RELATIONSHIPS_DIR_NAME);
 }
 function getPeopleRelationshipsFactsCacheDir(userDataDir) {
-  return path19.join(getPeopleRelationshipsDir(userDataDir), RELATIONSHIPS_FACTS_DIR_NAME);
+  return path18.join(getPeopleRelationshipsDir(userDataDir), RELATIONSHIPS_FACTS_DIR_NAME);
 }
 
 // ../../packages/node-runtime/src/database-manager.ts
-import * as fs13 from "fs";
-import * as path21 from "path";
+import * as fs12 from "fs";
+import * as path20 from "path";
 
 // ../../packages/node-runtime/src/services/global-insight/snapshot.ts
-import fs12 from "fs";
-import path20 from "path";
+import fs11 from "fs";
+import path19 from "path";
 
 // ../../packages/node-runtime/src/services/global-insight/time-range.ts
 function normalizeAnnualSummaryRange(input, nowInput = /* @__PURE__ */ new Date()) {
@@ -9169,17 +9261,17 @@ function toAnnualSummaryLocalDate(range) {
 // ../../packages/node-runtime/src/services/global-insight/snapshot.ts
 var SNAPSHOT_TMP_PREFIX = "annual-summary.tmp-";
 function getAnnualSummarySnapshotPath(snapshotDir, range) {
-  return path20.join(snapshotDir, `annual-summary-${toAnnualSummaryRangeKey(range)}.json`);
+  return path19.join(snapshotDir, `annual-summary-${toAnnualSummaryRangeKey(range)}.json`);
 }
 function readAnnualSummarySnapshot(snapshotDir, range, options = {}) {
   const snapshotPath = getAnnualSummarySnapshotPath(snapshotDir, range);
-  if (!fs12.existsSync(snapshotPath)) return null;
+  if (!fs11.existsSync(snapshotPath)) return null;
   try {
-    return JSON.parse(fs12.readFileSync(snapshotPath, "utf-8"));
+    return JSON.parse(fs11.readFileSync(snapshotPath, "utf-8"));
   } catch (error) {
-    const backupPath = path20.join(snapshotDir, `annual-summary.corrupt-${options.now?.() ?? Date.now()}.json`);
+    const backupPath = path19.join(snapshotDir, `annual-summary.corrupt-${options.now?.() ?? Date.now()}.json`);
     try {
-      fs12.renameSync(snapshotPath, backupPath);
+      fs11.renameSync(snapshotPath, backupPath);
     } catch (renameError) {
       appLogger.warn("global-insight", "failed to backup corrupt annual summary snapshot", renameError);
     }
@@ -9188,28 +9280,28 @@ function readAnnualSummarySnapshot(snapshotDir, range, options = {}) {
   }
 }
 function writeAnnualSummarySnapshot(snapshotDir, snapshot) {
-  fs12.mkdirSync(snapshotDir, { recursive: true });
-  const tmpPath = path20.join(snapshotDir, `${SNAPSHOT_TMP_PREFIX}${process.pid}-${Date.now()}`);
-  fs12.writeFileSync(tmpPath, JSON.stringify(snapshot, null, 2), "utf-8");
-  fs12.renameSync(tmpPath, getAnnualSummarySnapshotPath(snapshotDir, snapshot.range));
+  fs11.mkdirSync(snapshotDir, { recursive: true });
+  const tmpPath = path19.join(snapshotDir, `${SNAPSHOT_TMP_PREFIX}${process.pid}-${Date.now()}`);
+  fs11.writeFileSync(tmpPath, JSON.stringify(snapshot, null, 2), "utf-8");
+  fs11.renameSync(tmpPath, getAnnualSummarySnapshotPath(snapshotDir, snapshot.range));
 }
 function cleanupAnnualSummarySnapshotTempFiles(snapshotDir) {
-  if (!fs12.existsSync(snapshotDir)) return;
-  for (const name of fs12.readdirSync(snapshotDir)) {
+  if (!fs11.existsSync(snapshotDir)) return;
+  for (const name of fs11.readdirSync(snapshotDir)) {
     if (!name.startsWith(SNAPSHOT_TMP_PREFIX)) continue;
     try {
-      fs12.rmSync(path20.join(snapshotDir, name), { force: true });
+      fs11.rmSync(path19.join(snapshotDir, name), { force: true });
     } catch (error) {
       appLogger.warn("global-insight", "failed to remove annual summary snapshot temp file", error);
     }
   }
 }
 function deleteAnnualSummarySnapshots(snapshotDir) {
-  if (!fs12.existsSync(snapshotDir)) return;
-  for (const name of fs12.readdirSync(snapshotDir)) {
+  if (!fs11.existsSync(snapshotDir)) return;
+  for (const name of fs11.readdirSync(snapshotDir)) {
     if (!name.startsWith("annual-summary-") && !name.startsWith("annual-summary.")) continue;
     try {
-      fs12.rmSync(path20.join(snapshotDir, name), { force: true });
+      fs11.rmSync(path19.join(snapshotDir, name), { force: true });
     } catch (error) {
       appLogger.warn("global-insight", "failed to remove annual summary snapshot", error);
     }
@@ -9217,15 +9309,9 @@ function deleteAnnualSummarySnapshots(snapshotDir) {
 }
 
 // ../../packages/node-runtime/src/database-manager.ts
-function createMigrationDeps(overrides) {
-  return {
-    tokenizeForFts,
-    ...overrides
-  };
-}
 function listDatabaseCandidateIds(databaseDir) {
-  if (!fs13.existsSync(databaseDir)) return [];
-  return fs13.readdirSync(databaseDir).filter((fileName) => fileName.endsWith(".db") && !fileName.startsWith("._")).map((fileName) => fileName.slice(0, -3));
+  if (!fs12.existsSync(databaseDir)) return [];
+  return fs12.readdirSync(databaseDir).filter((fileName) => fileName.endsWith(".db") && !fileName.startsWith("._")).map((fileName) => fileName.slice(0, -3));
 }
 var DatabaseManager = class {
   constructor(pathProvider, options = {}) {
@@ -9234,13 +9320,11 @@ var DatabaseManager = class {
       throw new Error("DatabaseManager runtime identity is required for data directory compatibility checks.");
     }
     this.nativeBinding = options?.nativeBinding;
-    this.migrationDeps = createMigrationDeps(options?.migrationDeps);
     this.runtime = options?.runtime ?? null;
   }
   pathProvider;
   cache = /* @__PURE__ */ new Map();
   nativeBinding;
-  migrationDeps;
   runtime;
   /**
    * Open a session DB (read-only by default, cached).
@@ -9251,7 +9335,7 @@ var DatabaseManager = class {
       return this.cache.get(sessionId);
     }
     const dbPath = this.getDbPath(sessionId);
-    if (!fs13.existsSync(dbPath)) return null;
+    if (!fs12.existsSync(dbPath)) return null;
     this.migrateIfNeeded(dbPath);
     this.assertCompatible();
     const adapter = openBetterSqliteDatabase(dbPath, {
@@ -9278,7 +9362,7 @@ var DatabaseManager = class {
       nativeBinding: this.nativeBinding
     });
     try {
-      const migrations = getChatDbMigrations(this.migrationDeps);
+      const migrations = getChatDbMigrations();
       this.runMigrations(adapter, migrations);
     } finally {
       adapter.close();
@@ -9297,13 +9381,13 @@ var DatabaseManager = class {
       this.cache.delete(sessionId);
     }
     const dbPath = this.getDbPath(sessionId);
-    if (!fs13.existsSync(dbPath)) return null;
+    if (!fs12.existsSync(dbPath)) return null;
     const adapter = openBetterSqliteDatabase(dbPath, {
       readonly: false,
       nativeBinding: this.nativeBinding
     });
     if (needsMigration(adapter, CURRENT_SCHEMA_VERSION)) {
-      const migrations = getChatDbMigrations(this.migrationDeps);
+      const migrations = getChatDbMigrations();
       this.runMigrations(adapter, migrations);
       this.assertCompatible();
     } else {
@@ -9365,17 +9449,17 @@ var DatabaseManager = class {
    * 获取数据库文件路径
    */
   getDbPath(sessionId) {
-    return path21.join(this.pathProvider.getDatabaseDir(), `${sessionId}.db`);
+    return path20.join(this.pathProvider.getDatabaseDir(), `${sessionId}.db`);
   }
   openRawSessionDatabase(sessionId, options = {}) {
     this.assertCompatible();
     const dbPath = this.getDbPath(sessionId);
-    if (!options.create && !fs13.existsSync(dbPath)) {
+    if (!options.create && !fs12.existsSync(dbPath)) {
       throw new Error(`Session database not found: ${sessionId}`);
     }
     if (!options.readonly) {
       this.close(sessionId);
-      fs13.mkdirSync(path21.dirname(dbPath), { recursive: true });
+      fs12.mkdirSync(path20.dirname(dbPath), { recursive: true });
     }
     const adapter = openBetterSqliteDatabase(dbPath, {
       readonly: options.readonly ?? false,
@@ -9393,17 +9477,17 @@ var DatabaseManager = class {
   deleteSessionDatabaseFiles(sessionId) {
     this.close(sessionId);
     const dbPath = this.getDbPath(sessionId);
-    const existed = ["", "-wal", "-shm"].some((suffix) => fs13.existsSync(dbPath + suffix));
+    const existed = ["", "-wal", "-shm"].some((suffix) => fs12.existsSync(dbPath + suffix));
     for (const suffix of ["", "-wal", "-shm"]) {
       try {
         const filePath = dbPath + suffix;
-        if (fs13.existsSync(filePath)) fs13.unlinkSync(filePath);
+        if (fs12.existsSync(filePath)) fs12.unlinkSync(filePath);
       } catch {
       }
     }
     const cacheDir = this.pathProvider.getCacheDir();
     deleteSessionCache(sessionId, cacheDir);
-    deleteSessionCache(sessionId, path21.join(cacheDir, "query"));
+    deleteSessionCache(sessionId, path20.join(cacheDir, "query"));
     deleteSessionCache(sessionId, getContactsFactsCacheDir(this.pathProvider.getUserDataDir()));
     deleteSessionCache(sessionId, getGlobalInsightFactsCacheDir(this.pathProvider.getUserDataDir()));
     deleteAnnualSummarySnapshots(getGlobalInsightDir(this.pathProvider.getUserDataDir()));
@@ -9444,12 +9528,12 @@ function shouldRepairCompatibilityGate(schemaVersion) {
 }
 
 // ../../packages/node-runtime/src/cache/analytics-cache.ts
-import * as fs14 from "fs";
+import * as fs13 from "fs";
 function getDbFileVersion(dbPath) {
   const parts = [];
   for (const p of [dbPath, `${dbPath}-wal`]) {
     try {
-      const st = fs14.statSync(p);
+      const st = fs13.statSync(p);
       parts.push(`${Math.floor(st.mtimeMs)}:${st.size}`);
     } catch {
       parts.push("-");
@@ -9605,9 +9689,10 @@ export {
   POS_TAG_DEFINITIONS,
   MEANINGFUL_POS_TAGS,
   isStopword,
+  cleanText,
+  isValidWord,
   buildExcludeKeywordsConditions,
   getMentionAnalysis,
-  getMentionGraph,
   getLaughAnalysis,
   getClusterGraph,
   resolveOwnerMember,
@@ -9654,6 +9739,8 @@ export {
   deleteMembers,
   deleteMember,
   getCatchphraseAnalysis,
+  GROUP_RELATIONSHIP_GALAXY_ALGORITHM_VERSION,
+  getGroupRelationshipGalaxy,
   getRelationshipStats,
   getJourneyStats,
   getLanguagePreferenceAnalysis,
@@ -9683,28 +9770,17 @@ export {
   generateMessageKey,
   writeParseResultToDb,
   getCollidingPlatformIds,
+  getCollidingPlatformIdsFromMessages,
   normalizePlatformId,
   detectConflictsInMessages,
   mergeMembers2,
   CHAT_DB_INDEXES,
   CHAT_DB_SCHEMA,
-  FTS_TABLE_SCHEMA,
   AiLogger,
   extractErrorInfo,
   extractErrorStack,
   initAppLogger,
   appLogger,
-  initNlpDir,
-  getNlpDir,
-  getJieba,
-  clearJiebaInstance,
-  segment,
-  batchSegmentWithFrequency,
-  batchSegmentChineseWithStats,
-  collectPosTagStats,
-  getPosTagDefinitions,
-  tokenizeForFts,
-  tokenizeQueryForFts,
   wasElectronUsed,
   verifyCliDataPath,
   migrateFromElectronIfNeeded,
@@ -9747,4 +9823,4 @@ export {
   StaticPathProvider,
   createDatabaseManagerAdapter
 };
-//# sourceMappingURL=chunk-INBJ7SND.mjs.map
+//# sourceMappingURL=chunk-22YJOBA3.mjs.map