chatlab-cli 0.26.2 → 0.26.3

package/dist/{chunk-TMZC3SNX.mjs → chunk-YPTJVTVJ.mjs}

@@ -1797,6 +1797,72 @@ function getMessageLengthDistribution(db, filter) {
   }));
   return { detail, grouped };
 }
+function getTextStats(db, filter) {
+  const { clause, params } = buildTimeFilter(filter);
+  const typeCondition = buildSystemMessageFilter(clause) + " AND msg.type = 0 AND msg.content IS NOT NULL AND LENGTH(msg.content) > 0";
+  const row = db.prepare(
+    `SELECT
+        COUNT(*) as textCount,
+        ROUND(AVG(LENGTH(msg.content)), 1) as avgLength,
+        MAX(LENGTH(msg.content)) as maxLength,
+        SUM(CASE WHEN LENGTH(msg.content) <= 5 THEN 1 ELSE 0 END) as shortCount
+       FROM message msg JOIN member m ON msg.sender_id = m.id
+       ${typeCondition}`
+  ).get(...params);
+  return {
+    textCount: row?.textCount ?? 0,
+    avgLength: row?.avgLength ?? 0,
+    maxLength: row?.maxLength ?? 0,
+    shortCount: row?.shortCount ?? 0
+  };
+}
+function getLongMessageCount(db, filter, minLength = 30) {
+  const { clause, params } = buildTimeFilter(filter);
+  const typeCondition = buildSystemMessageFilter(clause) + " AND msg.type = 0 AND msg.content IS NOT NULL AND LENGTH(msg.content) >= ?";
+  const row = db.prepare(
+    `SELECT COUNT(*) as cnt
+       FROM message msg JOIN member m ON msg.sender_id = m.id
+       ${typeCondition}`
+  ).get(...params, minLength);
+  return row?.cnt ?? 0;
+}
+function getMemberMonthlyTrend(db, filter) {
+  const { clause, params } = buildTimeFilter(filter);
+  const clauseWithSystem = buildSystemMessageFilter(clause);
+  return db.prepare(
+    `SELECT
+        strftime('%Y-%m', msg.ts, 'unixepoch', 'localtime') as month,
+        msg.sender_id as memberId,
+        m.account_name as memberName,
+        COUNT(*) as count
+      FROM message msg JOIN member m ON msg.sender_id = m.id
+      ${clauseWithSystem}
+      GROUP BY month, msg.sender_id
+      ORDER BY month`
+  ).all(...params);
+}
+function getTextLengthPercentiles(db, filter) {
+  const { clause, params } = buildTimeFilter(filter);
+  const typeCondition = buildSystemMessageFilter(clause) + " AND msg.type = 0 AND msg.content IS NOT NULL AND LENGTH(msg.content) > 0";
+  const rows = db.prepare(
+    `SELECT LENGTH(msg.content) as len
+       FROM message msg JOIN member m ON msg.sender_id = m.id
+       ${typeCondition}
+       ORDER BY len`
+  ).all(...params);
+  if (rows.length === 0) return { p25: 0, p50: 0, p75: 0, p90: 0 };
+  const lengths = rows.map((r) => r.len);
+  const getPercentile = (arr, p) => {
+    const idx = Math.ceil(p / 100 * arr.length) - 1;
+    return arr[Math.max(0, idx)];
+  };
+  return {
+    p25: getPercentile(lengths, 25),
+    p50: getPercentile(lengths, 50),
+    p75: getPercentile(lengths, 75),
+    p90: getPercentile(lengths, 90)
+  };
+}
 
 // ../../packages/core/src/query/session-queries.ts
 function buildSessionInfo(meta, overview, summaryCount = 0) {
@@ -2081,14 +2147,16 @@ function updateSessionOwnerId(db, ownerId) {
 function renameSession(db, newName) {
   db.prepare("UPDATE meta SET name = ?").run(newName);
 }
-function clearSessionIndex(db) {
+function clearSessionIndexRows(db) {
   db.exec("DELETE FROM message_context");
   db.exec("DELETE FROM segment");
 }
+function clearSessionIndex(db) {
+  db.transaction(() => clearSessionIndexRows(db));
+}
 function generateSessionIndex(db, gapThreshold = DEFAULT_SESSION_GAP_THRESHOLD, onProgress) {
   const countRow = db.prepare("SELECT COUNT(*) as count FROM message").get();
   if (!countRow || countRow.count === 0) return 0;
-  clearSessionIndex(db);
   const sessionMarkSQL = `
     WITH message_ordered AS (
       SELECT id, ts, LAG(ts) OVER (ORDER BY ts, id) AS prev_ts FROM message
@@ -2121,6 +2189,7 @@ function generateSessionIndex(db, gapThreshold = DEFAULT_SESSION_GAP_THRESHOLD,
   );
   const insertContext = db.prepare("INSERT INTO message_context (message_id, segment_id, topic_id) VALUES (?, ?, NULL)");
   return db.transaction(() => {
+    clearSessionIndexRows(db);
     let processed = 0;
     const total = sessionMap.size;
     for (const [, data] of sessionMap) {
@@ -2772,6 +2841,35 @@ function deleteMember(db, memberId) {
   }
 }
 
+// ../../packages/core/src/query/advanced/text-filters.ts
+var SYSTEM_PLACEHOLDER_CONTENTS = /* @__PURE__ */ new Set([
+  "[\u56FE\u7247]",
+  "[\u89C6\u9891]",
+  "[\u8BED\u97F3]",
+  "[\u6587\u4EF6]",
+  "[\u52A8\u753B\u8868\u60C5]",
+  "[\u8868\u60C5]",
+  "[\u94FE\u63A5]",
+  "[\u4F4D\u7F6E]",
+  "[\u5730\u7406\u4F4D\u7F6E]",
+  "[\u540D\u7247]",
+  "[\u7EA2\u5305]",
+  "[\u8F6C\u8D26]",
+  "[\u97F3\u4E50]",
+  "[\u56DE\u590D\u6D88\u606F]",
+  "[Image]",
+  "[Photo]",
+  "[Video]",
+  "[Voice]",
+  "[File]",
+  "[Sticker]",
+  "[Link]",
+  "[Location]"
+]);
+function isSystemPlaceholderContent(content) {
+  return SYSTEM_PLACEHOLDER_CONTENTS.has(content.trim());
+}
+
 // ../../packages/core/src/query/advanced/repeat.ts
 function getCatchphraseAnalysis(db, filter) {
   const { clause, params } = buildTimeFilter(filter);
@@ -2798,6 +2896,7 @@ function getCatchphraseAnalysis(db, filter) {
   ).all(...params);
   const memberMap = /* @__PURE__ */ new Map();
   for (const row of rows) {
+    if (isSystemPlaceholderContent(row.content)) continue;
     if (!memberMap.has(row.memberId)) {
       memberMap.set(row.memberId, {
         memberId: row.memberId,
@@ -3625,6 +3724,7 @@ function getLanguagePreferenceAnalysis(db, params) {
   if (rows.length === 0) return { members: [], sharedWords: [], similarityScore: 0 };
   const memberMessages = /* @__PURE__ */ new Map();
   for (const row of rows) {
+    if (isSystemPlaceholderContent(row.content)) continue;
     let entry = memberMessages.get(row.memberId);
     if (!entry) {
       entry = { name: row.name, messages: [] };
@@ -3736,6 +3836,743 @@ function getLanguagePreferenceAnalysis(db, params) {
   return { members: memberProfiles, sharedWords, similarityScore };
 }
 
+// ../../packages/core/src/query/advanced/ranking.ts
+var SYSTEM_FILTER = "AND COALESCE(m.account_name, '') != '\u7CFB\u7EDF\u6D88\u606F'";
+function buildFilter(filter) {
+  const parts = [];
+  const params = [];
+  if (filter?.startTs != null) {
+    parts.push("AND msg.ts >= ?");
+    params.push(filter.startTs);
+  }
+  if (filter?.endTs != null) {
+    parts.push("AND msg.ts <= ?");
+    params.push(filter.endTs);
+  }
+  if (filter?.memberId != null) {
+    parts.push("AND msg.sender_id = ?");
+    params.push(filter.memberId);
+  }
+  return { conditions: parts.join(" "), params };
+}
+function getDragonKingAnalysis(db, filter) {
+  const { conditions, params } = buildFilter(filter);
+  const rankRows = db.prepare(
+    `WITH daily_counts AS (
+        SELECT
+          strftime('%Y-%m-%d', msg.ts, 'unixepoch', 'localtime') as date,
+          msg.sender_id,
+          m.platform_id,
+          COALESCE(m.group_nickname, m.account_name, m.platform_id) as name,
+          COUNT(*) as msg_count
+        FROM message msg
+        JOIN member m ON msg.sender_id = m.id
+        WHERE 1=1 ${SYSTEM_FILTER} ${conditions}
+        GROUP BY date, msg.sender_id
+      ),
+      daily_max AS (
+        SELECT date, MAX(msg_count) as max_count
+        FROM daily_counts
+        GROUP BY date
+      )
+      SELECT dc.sender_id, dc.platform_id, dc.name, COUNT(*) as dragon_days
+      FROM daily_counts dc
+      JOIN daily_max dm ON dc.date = dm.date AND dc.msg_count = dm.max_count
+      GROUP BY dc.sender_id
+      ORDER BY dragon_days DESC`
+  ).all(...params);
+  const totalRow = db.prepare(
+    `SELECT COUNT(DISTINCT strftime('%Y-%m-%d', msg.ts, 'unixepoch', 'localtime')) as total
+       FROM message msg
+       JOIN member m ON msg.sender_id = m.id
+       WHERE 1=1 ${SYSTEM_FILTER} ${conditions}`
+  ).get(...params);
+  const totalDays = totalRow?.total ?? 0;
+  const rank = rankRows.map((item) => ({
+    memberId: item.sender_id,
+    platformId: item.platform_id,
+    name: item.name,
+    count: item.dragon_days,
+    percentage: totalDays > 0 ? Math.round(item.dragon_days / totalDays * 1e4) / 100 : 0
+  }));
+  return { rank, totalDays };
+}
+function getDivingAnalysis(db, filter) {
+  const { conditions, params } = buildFilter(filter);
+  const rows = db.prepare(
+    `SELECT
+        m.id as member_id,
+        m.platform_id,
+        COALESCE(m.group_nickname, m.account_name, m.platform_id) as name,
+        MAX(msg.ts) as last_ts
+      FROM member m
+      JOIN message msg ON m.id = msg.sender_id
+      WHERE 1=1 ${SYSTEM_FILTER} ${conditions}
+      GROUP BY m.id
+      ORDER BY last_ts ASC`
+  ).all(...params);
+  const now = Math.floor(Date.now() / 1e3);
+  const rank = rows.map((item) => ({
+    memberId: item.member_id,
+    platformId: item.platform_id,
+    name: item.name,
+    lastMessageTs: item.last_ts,
+    daysSinceLastMessage: Math.floor((now - item.last_ts) / 86400)
+  }));
+  return { rank };
+}
+function computeCheckIn(dailyActivity) {
+  if (dailyActivity.length === 0) {
+    return { streakRank: [], loyaltyRank: [], totalDays: 0 };
+  }
+  const allDays = new Set(dailyActivity.map((r) => r.day));
+  const totalDays = allDays.size;
+  const sortedDays = Array.from(allDays).sort();
+  const lastDay = sortedDays[sortedDays.length - 1];
+  const memberDays = /* @__PURE__ */ new Map();
+  for (const record of dailyActivity) {
+    if (!memberDays.has(record.senderId)) {
+      memberDays.set(record.senderId, { name: record.name, days: /* @__PURE__ */ new Set() });
+    }
+    memberDays.get(record.senderId).days.add(record.day);
+  }
+  const streakData = [];
+  const loyaltyData = [];
+  for (const [memberId, data] of memberDays) {
+    const sortedMemberDays = Array.from(data.days).sort();
+    const totalMemberDays = sortedMemberDays.length;
+    let maxStreak = 1;
+    let maxStreakStart = sortedMemberDays[0];
+    let maxStreakEnd = sortedMemberDays[0];
+    let currentStreakCount = 1;
+    let currentStreakStart = sortedMemberDays[0];
+    for (let i = 1; i < sortedMemberDays.length; i++) {
+      const prevDate = new Date(sortedMemberDays[i - 1]);
+      const currDate = new Date(sortedMemberDays[i]);
+      const diffDays = Math.round((currDate.getTime() - prevDate.getTime()) / (1e3 * 60 * 60 * 24));
+      if (diffDays === 1) {
+        currentStreakCount++;
+      } else {
+        if (currentStreakCount > maxStreak) {
+          maxStreak = currentStreakCount;
+          maxStreakStart = currentStreakStart;
+          maxStreakEnd = sortedMemberDays[i - 1];
+        }
+        currentStreakCount = 1;
+        currentStreakStart = sortedMemberDays[i];
+      }
+    }
+    if (currentStreakCount > maxStreak) {
+      maxStreak = currentStreakCount;
+      maxStreakStart = currentStreakStart;
+      maxStreakEnd = sortedMemberDays[sortedMemberDays.length - 1];
+    }
+    let finalCurrentStreak = 0;
+    if (sortedMemberDays[sortedMemberDays.length - 1] === lastDay) {
+      finalCurrentStreak = 1;
+      for (let i = sortedMemberDays.length - 2; i >= 0; i--) {
+        const currDate = new Date(sortedMemberDays[i + 1]);
+        const prevDate = new Date(sortedMemberDays[i]);
+        const diffDays = Math.round((currDate.getTime() - prevDate.getTime()) / (1e3 * 60 * 60 * 24));
+        if (diffDays === 1) {
+          finalCurrentStreak++;
+        } else {
+          break;
+        }
+      }
+    }
+    streakData.push({
+      memberId,
+      name: data.name,
+      maxStreak,
+      maxStreakStart,
+      maxStreakEnd,
+      currentStreak: finalCurrentStreak
+    });
+    loyaltyData.push({
+      memberId,
+      name: data.name,
+      totalDays: totalMemberDays
+    });
+  }
+  const streakRank = streakData.sort((a, b) => b.maxStreak - a.maxStreak);
+  const sortedLoyalty = loyaltyData.sort((a, b) => b.totalDays - a.totalDays);
+  const maxLoyaltyDays = sortedLoyalty.length > 0 ? sortedLoyalty[0].totalDays : 1;
+  const loyaltyRank = sortedLoyalty.map((item) => ({
+    ...item,
+    percentage: Math.round(item.totalDays / maxLoyaltyDays * 100)
+  }));
+  return { streakRank, loyaltyRank, totalDays };
+}
+function getCheckInAnalysis(db, filter) {
+  const { conditions, params } = buildFilter(filter);
+  const dailyActivity = db.prepare(
+    `SELECT
+        msg.sender_id as senderId,
+        COALESCE(m.group_nickname, m.account_name, m.platform_id) as name,
+        DATE(msg.ts, 'unixepoch', 'localtime') as day
+      FROM message msg
+      JOIN member m ON msg.sender_id = m.id
+      WHERE 1=1 ${SYSTEM_FILTER} ${conditions}
+      GROUP BY msg.sender_id, day
+      ORDER BY msg.sender_id, day`
+  ).all(...params);
+  if (dailyActivity.length === 0) {
+    return { streakRank: [], loyaltyRank: [], totalDays: 0 };
+  }
+  return computeCheckIn(dailyActivity);
+}
+function computeMemeBattle(messages) {
+  const emptyResult = {
+    topBattles: [],
+    rankByCount: [],
+    rankByImageCount: [],
+    totalBattles: 0
+  };
+  const battles = [];
+  let currentChain = [];
+  const processChain = () => {
+    if (currentChain.length >= 3) {
+      const senders = new Set(currentChain.map((m) => m.senderId));
+      if (senders.size >= 2) {
+        battles.push({
+          startTime: currentChain[0].ts,
+          endTime: currentChain[currentChain.length - 1].ts,
+          msgs: currentChain.map(({ senderId, name, platformId }) => ({ senderId, name, platformId }))
+        });
+      }
+    }
+    currentChain = [];
+  };
+  for (const msg of messages) {
+    if (msg.type === 1 || msg.type === 5) {
+      currentChain.push({
+        senderId: msg.senderId,
+        name: msg.name,
+        platformId: msg.platformId,
+        ts: msg.ts
+      });
+    } else {
+      processChain();
+    }
+  }
+  processChain();
+  if (battles.length === 0) return emptyResult;
+  const topBattles = battles.map((battle) => ({
+    startTime: battle.startTime,
+    endTime: battle.endTime,
+    totalImages: battle.msgs.length,
+    participantCount: new Set(battle.msgs.map((m) => m.senderId)).size,
+    participants: Object.values(
+      battle.msgs.reduce((acc, curr) => {
+        if (!acc[curr.senderId]) {
+          acc[curr.senderId] = { memberId: curr.senderId, name: curr.name, imageCount: 0 };
+        }
+        acc[curr.senderId].imageCount++;
+        return acc;
+      }, {})
+    ).sort((a, b) => b.imageCount - a.imageCount)
+  })).sort((a, b) => b.totalImages - a.totalImages).slice(0, 30);
+  const memberStats = /* @__PURE__ */ new Map();
+  for (const battle of battles) {
+    const participantsInBattle = /* @__PURE__ */ new Set();
+    for (const msg of battle.msgs) {
+      if (!memberStats.has(msg.senderId)) {
+        memberStats.set(msg.senderId, {
+          memberId: msg.senderId,
+          platformId: msg.platformId,
+          name: msg.name,
+          battleCount: 0,
+          imageCount: 0
+        });
+      }
+      memberStats.get(msg.senderId).imageCount++;
+      participantsInBattle.add(msg.senderId);
+    }
+    for (const memberId of participantsInBattle) {
+      memberStats.get(memberId).battleCount++;
+    }
+  }
+  const allStats = Array.from(memberStats.values());
+  const rankByCount = [...allStats].sort((a, b) => b.battleCount - a.battleCount).map((item) => ({
+    memberId: item.memberId,
+    platformId: item.platformId,
+    name: item.name,
+    count: item.battleCount,
+    percentage: battles.length > 0 ? Math.round(item.battleCount / battles.length * 1e4) / 100 : 0
+  }));
+  const totalBattleImages = battles.reduce((sum, b) => sum + b.msgs.length, 0);
+  const rankByImageCount = [...allStats].sort((a, b) => b.imageCount - a.imageCount).map((item) => ({
+    memberId: item.memberId,
+    platformId: item.platformId,
+    name: item.name,
+    count: item.imageCount,
+    percentage: totalBattleImages > 0 ? Math.round(item.imageCount / totalBattleImages * 1e4) / 100 : 0
+  }));
+  return {
+    topBattles,
+    rankByCount,
+    rankByImageCount,
+    totalBattles: battles.length
+  };
+}
+function getMemeBattleAnalysis(db, filter) {
+  const { conditions, params } = buildFilter(filter);
+  const messages = db.prepare(
+    `SELECT
+        msg.sender_id as senderId,
+        msg.type,
+        msg.ts,
+        m.platform_id as platformId,
+        COALESCE(m.group_nickname, m.account_name, m.platform_id) as name
+      FROM message msg
+      JOIN member m ON msg.sender_id = m.id
+      WHERE msg.type != 6 ${conditions}
+      ORDER BY msg.ts ASC`
+  ).all(...params);
+  if (messages.length === 0) {
+    return { topBattles: [], rankByCount: [], rankByImageCount: [], totalBattles: 0 };
+  }
+  return computeMemeBattle(messages);
+}
+function computeNightOwl(messages) {
+  const emptyResult = {
+    nightOwlRank: [],
+    lastSpeakerRank: [],
+    firstSpeakerRank: [],
+    consecutiveRecords: [],
+    champions: [],
+    totalDays: 0
+  };
+  if (messages.length === 0) return emptyResult;
+  function getNightOwlTitleByCount(count) {
+    if (count === 0) return "\u517B\u751F\u8FBE\u4EBA";
+    if (count <= 20) return "\u5076\u5C14\u5931\u7720";
+    if (count <= 50) return "\u7ECF\u5E38\u5931\u7720";
+    if (count <= 100) return "\u591C\u732B\u5B50";
+    if (count <= 200) return "\u79C3\u5934\u9884\u5907\u5F79";
+    if (count <= 500) return "\u4FEE\u4ED9\u7EC3\u4E60\u751F";
+    return "\u5B88\u591C\u51A0\u519B";
+  }
+  function getAdjustedDate(ts) {
+    const date = new Date(ts * 1e3);
+    const hour = date.getHours();
+    if (hour < 5) {
+      date.setDate(date.getDate() - 1);
+    }
+    return date.toISOString().split("T")[0];
+  }
+  function formatMinutes(minutes) {
+    const h = Math.floor(minutes / 60);
+    const m = Math.round(minutes % 60);
+    return `${h.toString().padStart(2, "0")}:${m.toString().padStart(2, "0")}`;
+  }
+  const memberInfo = /* @__PURE__ */ new Map();
+  const nightStats = /* @__PURE__ */ new Map();
+  const dailyMessages = /* @__PURE__ */ new Map();
+  const memberNightDays = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    if (!memberInfo.has(msg.senderId)) {
+      memberInfo.set(msg.senderId, { platformId: msg.platformId, name: msg.name });
+    }
+    const date = new Date(msg.ts * 1e3);
+    const hour = date.getHours();
+    const minute = date.getMinutes();
+    const adjustedDate = getAdjustedDate(msg.ts);
+    if (!nightStats.has(msg.senderId)) {
+      nightStats.set(msg.senderId, { total: 0, h23: 0, h0: 0, h1: 0, h2: 0, h3to4: 0, totalMessages: 0 });
+    }
+    const stats = nightStats.get(msg.senderId);
+    stats.totalMessages++;
+    if (hour === 23) {
+      stats.h23++;
+      stats.total++;
+    } else if (hour === 0) {
+      stats.h0++;
+      stats.total++;
+    } else if (hour === 1) {
+      stats.h1++;
+      stats.total++;
+    } else if (hour === 2) {
+      stats.h2++;
+      stats.total++;
+    } else if (hour >= 3 && hour < 5) {
+      stats.h3to4++;
+      stats.total++;
+    }
+    if (hour >= 23 || hour < 5) {
+      if (!memberNightDays.has(msg.senderId)) {
+        memberNightDays.set(msg.senderId, /* @__PURE__ */ new Set());
+      }
+      memberNightDays.get(msg.senderId).add(adjustedDate);
+    }
+    if (!dailyMessages.has(adjustedDate)) {
+      dailyMessages.set(adjustedDate, []);
+    }
+    dailyMessages.get(adjustedDate).push({ senderId: msg.senderId, ts: msg.ts, hour, minute });
+  }
+  const totalDays = dailyMessages.size;
+  const nightOwlRank = [];
+  for (const [memberId, stats] of nightStats.entries()) {
+    if (stats.total === 0) continue;
+    const info = memberInfo.get(memberId);
+    nightOwlRank.push({
+      memberId,
+      platformId: info.platformId,
+      name: info.name,
+      totalNightMessages: stats.total,
+      title: getNightOwlTitleByCount(stats.total),
+      hourlyBreakdown: { h23: stats.h23, h0: stats.h0, h1: stats.h1, h2: stats.h2, h3to4: stats.h3to4 },
+      percentage: stats.totalMessages > 0 ? Math.round(stats.total / stats.totalMessages * 1e4) / 100 : 0
+    });
+  }
+  nightOwlRank.sort((a, b) => b.totalNightMessages - a.totalNightMessages);
+  const lastSpeakerStats = /* @__PURE__ */ new Map();
+  const firstSpeakerStats = /* @__PURE__ */ new Map();
+  for (const [, dayMessages] of dailyMessages.entries()) {
+    if (dayMessages.length === 0) continue;
+    const lastMsg = dayMessages[dayMessages.length - 1];
+    if (!lastSpeakerStats.has(lastMsg.senderId)) {
+      lastSpeakerStats.set(lastMsg.senderId, { count: 0, times: [] });
+    }
+    const lastStats = lastSpeakerStats.get(lastMsg.senderId);
+    lastStats.count++;
+    lastStats.times.push(lastMsg.hour * 60 + lastMsg.minute);
+    const firstMsg = dayMessages[0];
+    if (!firstSpeakerStats.has(firstMsg.senderId)) {
+      firstSpeakerStats.set(firstMsg.senderId, { count: 0, times: [] });
+    }
+    const firstStats = firstSpeakerStats.get(firstMsg.senderId);
+    firstStats.count++;
+    firstStats.times.push(firstMsg.hour * 60 + firstMsg.minute);
+  }
+  const lastSpeakerRank = [];
+  for (const [memberId, stats] of lastSpeakerStats.entries()) {
+    const info = memberInfo.get(memberId);
+    const avgMinutes = stats.times.reduce((a, b) => a + b, 0) / stats.times.length;
+    const maxMinutes = Math.max(...stats.times);
+    lastSpeakerRank.push({
+      memberId,
+      platformId: info.platformId,
+      name: info.name,
+      count: stats.count,
+      avgTime: formatMinutes(avgMinutes),
+      extremeTime: formatMinutes(maxMinutes),
+      percentage: totalDays > 0 ? Math.round(stats.count / totalDays * 1e4) / 100 : 0
+    });
+  }
+  lastSpeakerRank.sort((a, b) => b.count - a.count);
+  const firstSpeakerRank = [];
+  for (const [memberId, stats] of firstSpeakerStats.entries()) {
+    const info = memberInfo.get(memberId);
+    const avgMinutes = stats.times.reduce((a, b) => a + b, 0) / stats.times.length;
+    const minMinutes = Math.min(...stats.times);
+    firstSpeakerRank.push({
+      memberId,
+      platformId: info.platformId,
+      name: info.name,
+      count: stats.count,
+      avgTime: formatMinutes(avgMinutes),
+      extremeTime: formatMinutes(minMinutes),
+      percentage: totalDays > 0 ? Math.round(stats.count / totalDays * 1e4) / 100 : 0
+    });
+  }
+  firstSpeakerRank.sort((a, b) => b.count - a.count);
+  const consecutiveRecords = [];
+  for (const [memberId, nightDaysSet] of memberNightDays.entries()) {
+    if (nightDaysSet.size === 0) continue;
+    const info = memberInfo.get(memberId);
+    const sortedNightDays = Array.from(nightDaysSet).sort();
+    let maxStreak = 1;
+    let currentStreak = 1;
+    for (let i = 1; i < sortedNightDays.length; i++) {
+      const prevDate = new Date(sortedNightDays[i - 1]);
+      const currDate = new Date(sortedNightDays[i]);
+      const diffDays = (currDate.getTime() - prevDate.getTime()) / (1e3 * 60 * 60 * 24);
+      if (diffDays === 1) {
+        currentStreak++;
+        maxStreak = Math.max(maxStreak, currentStreak);
+      } else {
+        currentStreak = 1;
+      }
+    }
+    const lastNightDay = sortedNightDays[sortedNightDays.length - 1];
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const yesterday = new Date(Date.now() - 864e5).toISOString().split("T")[0];
+    const isCurrentStreak = lastNightDay === today || lastNightDay === yesterday;
+    consecutiveRecords.push({
+      memberId,
+      platformId: info.platformId,
+      name: info.name,
+      maxConsecutiveDays: maxStreak,
+      currentStreak: isCurrentStreak ? currentStreak : 0
+    });
+  }
+  consecutiveRecords.sort((a, b) => b.maxConsecutiveDays - a.maxConsecutiveDays);
+  const championScores = /* @__PURE__ */ new Map();
+  for (const item of nightOwlRank) {
+    if (!championScores.has(item.memberId)) {
+      championScores.set(item.memberId, { nightMessages: 0, lastSpeakerCount: 0, consecutiveDays: 0 });
+    }
+    championScores.get(item.memberId).nightMessages = item.totalNightMessages;
+  }
+  for (const item of lastSpeakerRank) {
+    if (!championScores.has(item.memberId)) {
+      championScores.set(item.memberId, { nightMessages: 0, lastSpeakerCount: 0, consecutiveDays: 0 });
+    }
+    championScores.get(item.memberId).lastSpeakerCount = item.count;
+  }
+  for (const item of consecutiveRecords) {
+    if (!championScores.has(item.memberId)) {
+      championScores.set(item.memberId, { nightMessages: 0, lastSpeakerCount: 0, consecutiveDays: 0 });
+    }
+    championScores.get(item.memberId).consecutiveDays = item.maxConsecutiveDays;
+  }
+  const champions = [];
+  for (const [memberId, scores] of championScores.entries()) {
+    const info = memberInfo.get(memberId);
+    const score = scores.nightMessages * 1 + scores.lastSpeakerCount * 10 + scores.consecutiveDays * 20;
+    if (score > 0) {
+      champions.push({
+        memberId,
+        platformId: info.platformId,
+        name: info.name,
+        score,
+        nightMessages: scores.nightMessages,
+        lastSpeakerCount: scores.lastSpeakerCount,
+        consecutiveDays: scores.consecutiveDays
+      });
+    }
+  }
+  champions.sort((a, b) => b.score - a.score);
+  return { nightOwlRank, lastSpeakerRank, firstSpeakerRank, consecutiveRecords, champions, totalDays };
+}
+function getNightOwlAnalysis(db, filter) {
+  const { conditions, params } = buildFilter(filter);
+  const messages = db.prepare(
+    `SELECT
+        msg.id,
+        msg.sender_id as senderId,
+        msg.ts,
+        m.platform_id as platformId,
+        COALESCE(m.group_nickname, m.account_name, m.platform_id) as name
+      FROM message msg
+      JOIN member m ON msg.sender_id = m.id
+      WHERE 1=1 ${SYSTEM_FILTER} ${conditions}
+      ORDER BY msg.ts ASC`
+  ).all(...params);
+  if (messages.length === 0) {
+    return {
+      nightOwlRank: [],
+      lastSpeakerRank: [],
+      firstSpeakerRank: [],
+      consecutiveRecords: [],
+      champions: [],
+      totalDays: 0
+    };
+  }
+  return computeNightOwl(messages);
+}
+function computeRepeat(messages) {
+  const originatorCount = /* @__PURE__ */ new Map();
+  const initiatorCount = /* @__PURE__ */ new Map();
+  const breakerCount = /* @__PURE__ */ new Map();
+  const memberMessageCount = /* @__PURE__ */ new Map();
+  const memberInfo = /* @__PURE__ */ new Map();
+  const chainLengthCount = /* @__PURE__ */ new Map();
+  const contentStats = /* @__PURE__ */ new Map();
+  let currentContent = null;
+  let repeatChain = [];
+  let totalRepeatChains = 0;
+  let totalChainLength = 0;
+  const fastestRepeaterStats = /* @__PURE__ */ new Map();
+  const processRepeatChain = (chain8, breakerId) => {
+    if (chain8.length < 3) return;
+    totalRepeatChains++;
+    const chainLength = chain8.length;
+    totalChainLength += chainLength;
+    const oId = chain8[0].senderId;
+    originatorCount.set(oId, (originatorCount.get(oId) || 0) + 1);
+    const iId = chain8[1].senderId;
+    initiatorCount.set(iId, (initiatorCount.get(iId) || 0) + 1);
+    if (breakerId !== void 0) {
+      breakerCount.set(breakerId, (breakerCount.get(breakerId) || 0) + 1);
+    }
+    chainLengthCount.set(chainLength, (chainLengthCount.get(chainLength) || 0) + 1);
+    const content = chain8[0].content;
+    const chainTs = chain8[0].ts;
+    const firstMsgId = chain8[0].id;
+    const existing = contentStats.get(content);
+    if (existing) {
+      existing.count++;
+      existing.lastTs = Math.max(existing.lastTs, chainTs);
+      if (chainLength > existing.maxChainLength) {
+        existing.maxChainLength = chainLength;
+        existing.originatorId = oId;
+        existing.firstMessageId = firstMsgId;
+      }
+    } else {
+      contentStats.set(content, {
+        count: 1,
+        maxChainLength: chainLength,
+        originatorId: oId,
+        lastTs: chainTs,
+        firstMessageId: firstMsgId
+      });
+    }
+    for (let i = 1; i < chain8.length; i++) {
+      const currentMsg = chain8[i];
+      const prevMsg = chain8[i - 1];
+      const diff = (currentMsg.ts - prevMsg.ts) * 1e3;
+      if (diff <= 20 * 1e3) {
+        if (!fastestRepeaterStats.has(currentMsg.senderId)) {
+          fastestRepeaterStats.set(currentMsg.senderId, { totalDiff: 0, count: 0 });
+        }
+        const stats = fastestRepeaterStats.get(currentMsg.senderId);
+        stats.totalDiff += diff;
+        stats.count++;
+      }
+    }
+  };
+  for (const msg of messages) {
+    if (!memberInfo.has(msg.senderId)) {
+      memberInfo.set(msg.senderId, { platformId: msg.platformId, name: msg.name });
+    }
+    memberMessageCount.set(msg.senderId, (memberMessageCount.get(msg.senderId) || 0) + 1);
+    const content = msg.content.trim();
+    if (content === currentContent) {
+      const lastSender = repeatChain[repeatChain.length - 1]?.senderId;
+      if (lastSender !== msg.senderId) {
+        repeatChain.push({ id: msg.id, senderId: msg.senderId, content, ts: msg.ts });
+      }
+    } else {
+      processRepeatChain(repeatChain, msg.senderId);
+      currentContent = content;
+      repeatChain = [{ id: msg.id, senderId: msg.senderId, content, ts: msg.ts }];
+    }
+  }
+  processRepeatChain(repeatChain);
+  const buildRankList = (countMap, total) => {
+    const items = [];
+    for (const [memberId, count] of countMap.entries()) {
+      const info = memberInfo.get(memberId);
+      if (info) {
+        items.push({
+          memberId,
+          platformId: info.platformId,
+          name: info.name,
+          count,
+          percentage: total > 0 ? Math.round(count / total * 1e4) / 100 : 0
+        });
+      }
+    }
+    return items.sort((a, b) => b.count - a.count);
+  };
+  const buildRateList = (countMap) => {
+    const items = [];
+    for (const [memberId, count] of countMap.entries()) {
+      const info = memberInfo.get(memberId);
+      const totalMessages = memberMessageCount.get(memberId) || 0;
+      if (info && totalMessages > 0) {
+        items.push({
+          memberId,
+          platformId: info.platformId,
+          name: info.name,
+          count,
+          totalMessages,
+          rate: Math.round(count / totalMessages * 1e4) / 100
+        });
+      }
+    }
+    return items.sort((a, b) => b.rate - a.rate);
+  };
+  const buildFastestList = () => {
+    const items = [];
+    for (const [memberId, stats] of fastestRepeaterStats.entries()) {
+      if (stats.count < 5) continue;
+      const info = memberInfo.get(memberId);
+      if (info) {
+        items.push({
+          memberId,
+          platformId: info.platformId,
+          name: info.name,
+          count: stats.count,
+          avgTimeDiff: Math.round(stats.totalDiff / stats.count)
+        });
+      }
+    }
+    return items.sort((a, b) => a.avgTimeDiff - b.avgTimeDiff);
+  };
+  const chainLengthDistribution = [];
+  for (const [length, count] of chainLengthCount.entries()) {
+    chainLengthDistribution.push({ length, count });
+  }
+  chainLengthDistribution.sort((a, b) => a.length - b.length);
+  const hotContents = [];
+  for (const [content, stats] of contentStats.entries()) {
+    const originatorInfo = memberInfo.get(stats.originatorId);
+    hotContents.push({
+      content,
+      count: stats.count,
+      maxChainLength: stats.maxChainLength,
+      originatorName: originatorInfo?.name || "\u672A\u77E5",
+      lastTs: stats.lastTs,
+      firstMessageId: stats.firstMessageId
+    });
+  }
+  hotContents.sort((a, b) => b.maxChainLength - a.maxChainLength);
+  const top50HotContents = hotContents.slice(0, 100);
+  return {
+    originators: buildRankList(originatorCount, totalRepeatChains),
+    initiators: buildRankList(initiatorCount, totalRepeatChains),
+    breakers: buildRankList(breakerCount, totalRepeatChains),
+    fastestRepeaters: buildFastestList(),
+    originatorRates: buildRateList(originatorCount),
+    initiatorRates: buildRateList(initiatorCount),
+    breakerRates: buildRateList(breakerCount),
+    chainLengthDistribution,
+    hotContents: top50HotContents,
+    avgChainLength: totalRepeatChains > 0 ? Math.round(totalChainLength / totalRepeatChains * 100) / 100 : 0,
+    totalRepeatChains
+  };
+}
+function getRepeatAnalysis(db, filter) {
+  const { conditions, params } = buildFilter(filter);
+  const messages = db.prepare(
+    `SELECT
+        msg.id,
+        msg.sender_id as senderId,
+        msg.content,
+        msg.ts,
+        m.platform_id as platformId,
+        COALESCE(m.group_nickname, m.account_name, m.platform_id) as name
+      FROM message msg
+      JOIN member m ON msg.sender_id = m.id
+      WHERE 1=1 ${SYSTEM_FILTER}
+        AND msg.type = 0
+        AND msg.content IS NOT NULL
+        AND TRIM(msg.content) != ''
+        ${conditions}
+      ORDER BY msg.ts ASC, msg.id ASC`
+  ).all(...params);
+  if (messages.length === 0) {
+    return {
+      originators: [],
+      initiators: [],
+      breakers: [],
+      fastestRepeaters: [],
+      originatorRates: [],
+      initiatorRates: [],
+      breakerRates: [],
+      chainLengthDistribution: [],
+      hotContents: [],
+      avgChainLength: 0,
+      totalRepeatChains: 0
+    };
+  }
+  return computeRepeat(messages);
+}
+
 // ../../packages/core/src/version.ts
 function parseStableVersion(version) {
   const normalized = version.trim().replace(/^v/i, "");
@@ -4797,8 +5634,9 @@ var PUNCTUATION_REGEX = /[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~，。！？、；
 var URL_REGEX = /https?:\/\/[^\s]+/g;
 var MENTION_REGEX = /@[^\s@]+/g;
 var PURE_NUMBER_REGEX = /^\d+$/;
+var SYSTEM_PLACEHOLDER_REGEX = /\[(?:图片|视频|语音|文件|动画表情|表情|链接|位置|名片|红包|转账|音乐|Image|Video|Voice|File|Sticker|Link)\]/gi;
 function cleanText(text) {
-  return text.replace(URL_REGEX, " ").replace(MENTION_REGEX, " ").replace(EMOJI_REGEX, " ").replace(PUNCTUATION_REGEX, " ").replace(/\s+/g, " ").trim();
+  return text.replace(URL_REGEX, " ").replace(MENTION_REGEX, " ").replace(SYSTEM_PLACEHOLDER_REGEX, " ").replace(EMOJI_REGEX, " ").replace(PUNCTUATION_REGEX, " ").replace(/\s+/g, " ").trim();
 }
 function isValidWord(word, locale, minLength, enableStopwords, isStopwordFn) {
   if (!word || word.trim().length === 0) return false;
@@ -6442,7 +7280,7 @@ function mergeMembers2(sources, collidingIds) {
 }
 
 // ../../packages/core/src/schema/tables.ts
-var CURRENT_SCHEMA_VERSION = 6;
+var CURRENT_SCHEMA_VERSION = 7;
 var CHAT_DB_TABLES = `
   CREATE TABLE IF NOT EXISTS meta (
     name TEXT NOT NULL,
@@ -10423,6 +11261,49 @@ function batchSegmentWithFrequency(texts, locale, options = {}) {
   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 {
@@ -10490,12 +11371,7 @@ function computeWordFrequency(db, params) {
     return { words: [], totalWords: 0, totalMessages: 0, uniqueWords: 0 };
   }
   const texts = messages.map((m) => m.content);
-  let posTagStats;
-  if (locale.startsWith("zh")) {
-    const posStatsMap = collectPosTagStats(texts, minWordLength ?? 2, enableStopwords, dictType);
-    posTagStats = [...posStatsMap.entries()].map(([tag, count]) => ({ tag, count }));
-  }
-  const result = batchSegmentWithFrequency(texts, locale, {
+  const segmentOptions = {
     minLength: minWordLength,
     minCount,
     topN,
@@ -10504,7 +11380,20 @@ function computeWordFrequency(db, params) {
     enableStopwords,
     dictType,
     excludeWords
-  });
+  };
+  let posTagStats;
+  let result;
+  if (locale.startsWith("zh") && posFilterMode !== "all") {
+    const combined = batchSegmentChineseWithStats(texts, locale, segmentOptions);
+    result = { words: combined.words, uniqueWords: combined.uniqueWords, totalWords: combined.totalWords };
+    posTagStats = [...combined.posTagStats.entries()].map(([tag, count]) => ({ tag, count }));
+  } else {
+    if (locale.startsWith("zh")) {
+      const posStatsMap = collectPosTagStats(texts, minWordLength ?? 2, enableStopwords, dictType);
+      posTagStats = [...posStatsMap.entries()].map(([tag, count]) => ({ tag, count }));
+    }
+    result = batchSegmentWithFrequency(texts, locale, segmentOptions);
+  }
   let topNTotalWords = 0;
   for (const count of result.words.values()) topNTotalWords += count;
   const words = [...result.words.entries()].map(([word, count]) => ({
@@ -11947,8 +12836,8 @@ var AssistantManager = class {
   }
   // ==================== Init ====================
   init() {
-    const { fs: fs42, assistantsDir } = this.deps;
-    fs42.ensureDir(assistantsDir);
+    const { fs: fs43, assistantsDir } = this.deps;
+    fs43.ensureDir(assistantsDir);
     const generalCreated = this.ensureGeneralAssistants();
     this.loadAll();
     this.initialized = true;
@@ -11959,26 +12848,26 @@ var AssistantManager = class {
     return { total: this.cache.size, generalCreated };
   }
   ensureGeneralAssistants() {
-    const { fs: fs42, assistantsDir } = this.deps;
+    const { fs: fs43, assistantsDir } = this.deps;
     let anyCreated = false;
     for (const id of this.generalIds) {
       const config = this.getBuiltinConfig(id);
       if (!config) continue;
-      const filePath = fs42.joinPath(assistantsDir, `${id}.md`);
-      if (fs42.fileExists(filePath)) continue;
-      fs42.writeFile(filePath, serializeAssistant({ ...config, builtinId: config.id }));
+      const filePath = fs43.joinPath(assistantsDir, `${id}.md`);
+      if (fs43.fileExists(filePath)) continue;
+      fs43.writeFile(filePath, serializeAssistant({ ...config, builtinId: config.id }));
       anyCreated = true;
     }
     return anyCreated;
   }
   loadAll() {
-    const { fs: fs42, assistantsDir } = this.deps;
+    const { fs: fs43, assistantsDir } = this.deps;
     this.cache.clear();
-    const files = fs42.listFiles(assistantsDir, ".md");
+    const files = fs43.listFiles(assistantsDir, ".md");
     for (const file of files) {
       try {
-        const filePath = fs42.joinPath(assistantsDir, file);
-        const content = fs42.readFile(filePath);
+        const filePath = fs43.joinPath(assistantsDir, file);
+        const content = fs43.readFile(filePath);
         const config = parseAssistantFile(content, filePath);
         if (config) {
           this.cache.set(config.id, config);
@@ -12986,21 +13875,21 @@ var SkillManagerCore = class {
   }
   // ==================== Init ====================
   init() {
-    const { fs: fs42, skillsDir } = this.deps;
-    fs42.ensureDir(skillsDir);
+    const { fs: fs43, skillsDir } = this.deps;
+    fs43.ensureDir(skillsDir);
     this.loadAll();
     this.initialized = true;
     this.deps.logger?.info("SkillManager", "Initialized", { total: this.cache.size });
     return { total: this.cache.size };
   }
   loadAll() {
-    const { fs: fs42, skillsDir } = this.deps;
+    const { fs: fs43, skillsDir } = this.deps;
     this.cache.clear();
-    const files = fs42.listFiles(skillsDir, ".md");
+    const files = fs43.listFiles(skillsDir, ".md");
     for (const file of files) {
       try {
-        const filePath = fs42.joinPath(skillsDir, file);
-        const content = fs42.readFile(filePath);
+        const filePath = fs43.joinPath(skillsDir, file);
+        const content = fs43.readFile(filePath);
         const def = parseSkillFile(content, filePath);
         if (def) {
           this.cache.set(def.id, def);
@@ -18642,8 +19531,8 @@ var SQLiteVectorStore = class {
     const dimRow = this.db.prepare("SELECT dimensions FROM vectors LIMIT 1").get();
     let sizeBytes;
     try {
-      const fs42 = await import("fs");
-      const stats = fs42.statSync(this.dbPath);
+      const fs43 = await import("fs");
+      const stats = fs43.statSync(this.dbPath);
       sizeBytes = stats.size;
     } catch {
     }
@@ -20663,6 +21552,69 @@ function getChatDbMigrations(deps) {
           CREATE INDEX IF NOT EXISTS idx_context_segment ON message_context(segment_id);
         `);
       }
+    },
+    {
+      version: 7,
+      description: "Repair fully missing segment message contexts",
+      up: (db) => {
+        const counts = db.prepare(
+          `SELECT
+              (SELECT COUNT(*) FROM message) AS messageCount,
+              (SELECT COUNT(*) FROM segment) AS segmentCount,
+              (SELECT COUNT(*) FROM message_context) AS contextCount,
+              (SELECT COALESCE(SUM(message_count), 0) FROM segment) AS declaredMessageCount`
+        ).get();
+        if (!counts || counts.messageCount === 0 || counts.segmentCount === 0 || counts.contextCount > 0) {
+          return;
+        }
+        if (counts.declaredMessageCount !== counts.messageCount) {
+          throw new Error(
+            "Cannot safely repair missing message_context rows: segment message counts do not match message table"
+          );
+        }
+        const invalidRange = db.prepare(
+          `WITH ordered_segments AS (
+              SELECT
+                id,
+                start_ts,
+                end_ts,
+                LAG(end_ts) OVER (ORDER BY start_ts, id) AS previousEndTs
+              FROM segment
+            )
+            SELECT COUNT(*) AS count
+            FROM ordered_segments
+            WHERE start_ts > end_ts OR (previousEndTs IS NOT NULL AND start_ts <= previousEndTs)`
+        ).get();
+        if ((invalidRange?.count ?? 0) > 0) {
+          throw new Error(
+            "Cannot safely repair missing message_context rows: segment time ranges are invalid or overlapping"
+          );
+        }
+        const mismatchedSegments = db.prepare(
+          `SELECT COUNT(*) AS count
+            FROM (
+              SELECT s.id
+              FROM segment s
+              LEFT JOIN message m ON m.ts >= s.start_ts AND m.ts <= s.end_ts
+              GROUP BY s.id
+              HAVING COUNT(m.id) != s.message_count
+            )`
+        ).get();
+        if ((mismatchedSegments?.count ?? 0) > 0) {
+          throw new Error(
+            "Cannot safely repair missing message_context rows: messages do not match segment time ranges"
+          );
+        }
+        const result = db.prepare(
+          `INSERT INTO message_context (message_id, segment_id, topic_id)
+            SELECT m.id, s.id, NULL
+            FROM segment s
+            JOIN message m ON m.ts >= s.start_ts AND m.ts <= s.end_ts`
+        ).run();
+        if (result.changes !== counts.messageCount) {
+          throw new Error("Cannot safely repair missing message_context rows: rebuilt row count is inconsistent");
+        }
+      }
     }
   ];
 }
@@ -21263,8 +22215,32 @@ function exportWithFormat(params, openDatabase) {
   }
 }
 
-// ../../packages/node-runtime/src/preferences.ts
+// ../../packages/node-runtime/src/cache/analytics-cache.ts
 import * as fs39 from "fs";
+function getDbFileVersion(dbPath) {
+  const parts = [];
+  for (const p of [dbPath, `${dbPath}-wal`]) {
+    try {
+      const st = fs39.statSync(p);
+      parts.push(`${Math.floor(st.mtimeMs)}:${st.size}`);
+    } catch {
+      parts.push("-");
+    }
+  }
+  return parts.join("|");
+}
+function getOrComputeAnalysisCache(sessionId, key, queryCacheDir, version, compute) {
+  const cached = getCache(sessionId, key, queryCacheDir);
+  if (cached && cached.v === version) {
+    return cached.data;
+  }
+  const data = compute();
+  setCache(sessionId, key, { v: version, data }, queryCacheDir);
+  return data;
+}
+
+// ../../packages/node-runtime/src/preferences.ts
+import * as fs40 from "fs";
 import * as path37 from "path";
 var DEFAULTS = {
   pinnedSessionIds: [],
@@ -21316,8 +22292,8 @@ var PreferencesManager = class {
   load() {
     if (this.cache) return this.cache;
     try {
-      if (fs39.existsSync(this.filePath)) {
-        const raw = fs39.readFileSync(this.filePath, "utf-8");
+      if (fs40.existsSync(this.filePath)) {
+        const raw = fs40.readFileSync(this.filePath, "utf-8");
         const parsed = JSON.parse(raw);
         const migrated = this.migrateLegacyDesensitizeRules(parsed, raw);
         this.cache = this.mergeDefaults(migrated.preferences);
@@ -21433,20 +22409,20 @@ var PreferencesManager = class {
   }
   backupLegacyPreferences(rawContent) {
     const backupDir = path37.join(path37.dirname(this.filePath), "backups");
-    if (!fs39.existsSync(backupDir)) {
-      fs39.mkdirSync(backupDir, { recursive: true });
+    if (!fs40.existsSync(backupDir)) {
+      fs40.mkdirSync(backupDir, { recursive: true });
     }
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const backupPath = path37.join(backupDir, `preferences-pre-desensitize-groups-${timestamp}.json`);
-    fs39.writeFileSync(backupPath, rawContent, "utf-8");
+    fs40.writeFileSync(backupPath, rawContent, "utf-8");
     console.info(`[Preferences] Backed up legacy desensitize rules to ${backupPath}`);
   }
   writePreferences(preferences) {
     const dir = path37.dirname(this.filePath);
-    if (!fs39.existsSync(dir)) {
-      fs39.mkdirSync(dir, { recursive: true });
+    if (!fs40.existsSync(dir)) {
+      fs40.mkdirSync(dir, { recursive: true });
     }
-    fs39.writeFileSync(this.filePath, JSON.stringify(preferences, null, 2), "utf-8");
+    fs40.writeFileSync(this.filePath, JSON.stringify(preferences, null, 2), "utf-8");
   }
   /**
    * Deep merge: arrays are replaced (not concatenated), objects are merged.
@@ -21566,7 +22542,7 @@ function* serializeChatLabToJsonl(data) {
 }
 
 // ../../packages/node-runtime/src/merger/temp-db.ts
-import * as fs40 from "fs";
+import * as fs41 from "fs";
 import * as path38 from "path";
 var TEMP_DB_SCHEMA = `
   CREATE TABLE IF NOT EXISTS meta (
@@ -21812,18 +22788,18 @@ function exportSessionToJson(db) {
 }
 function deleteTempDatabase(dbPath) {
   try {
-    if (fs40.existsSync(dbPath)) fs40.unlinkSync(dbPath);
+    if (fs41.existsSync(dbPath)) fs41.unlinkSync(dbPath);
     const walPath = dbPath + "-wal";
     const shmPath = dbPath + "-shm";
-    if (fs40.existsSync(walPath)) fs40.unlinkSync(walPath);
-    if (fs40.existsSync(shmPath)) fs40.unlinkSync(shmPath);
+    if (fs41.existsSync(walPath)) fs41.unlinkSync(walPath);
+    if (fs41.existsSync(shmPath)) fs41.unlinkSync(shmPath);
   } catch {
   }
 }
 function cleanupTempDatabases(tempDir) {
   try {
-    if (!fs40.existsSync(tempDir)) return;
-    const files = fs40.readdirSync(tempDir);
+    if (!fs41.existsSync(tempDir)) return;
+    const files = fs41.readdirSync(tempDir);
     for (const file of files) {
       if (file.startsWith("merge_") && file.endsWith(".db")) {
         deleteTempDatabase(path38.join(tempDir, file));
@@ -22220,7 +23196,7 @@ function createDatabaseManagerAdapter(dbManager) {
 }
 
 // ../../packages/node-runtime/src/services/merge-cache.ts
-import * as fs41 from "fs";
+import * as fs42 from "fs";
 import * as path39 from "path";
 import * as crypto from "crypto";
 var MergeSessionCache = class {
@@ -22230,8 +23206,8 @@ var MergeSessionCache = class {
   constructor(pathProvider, options) {
     this.tempDir = pathProvider.getTempDir();
     this.nativeBinding = options?.nativeBinding;
-    if (!fs41.existsSync(this.tempDir)) {
-      fs41.mkdirSync(this.tempDir, { recursive: true });
+    if (!fs42.existsSync(this.tempDir)) {
+      fs42.mkdirSync(this.tempDir, { recursive: true });
     }
   }
   generateTempDbPath(filename) {
@@ -22249,7 +23225,7 @@ var MergeSessionCache = class {
   /** Open a TempDbReader for a given handle. Caller must close the reader. */
   openReader(handle) {
     const entry = this.cache.get(handle);
-    if (!entry || !fs41.existsSync(entry.tempDbPath)) return null;
+    if (!entry || !fs42.existsSync(entry.tempDbPath)) return null;
     const adapter = openBetterSqliteDatabase(entry.tempDbPath, {
       readonly: true,
       nativeBinding: this.nativeBinding
@@ -22325,6 +23301,10 @@ export {
   getMonthlyActivity,
   getYearlyActivity,
   getMessageLengthDistribution,
+  getTextStats,
+  getLongMessageCount,
+  getMemberMonthlyTrend,
+  getTextLengthPercentiles,
   getSessionInfo,
   getSessionMeta,
   getSessionOverview,
@@ -22356,6 +23336,12 @@ export {
   getClusterGraph,
   getRelationshipStats,
   getLanguagePreferenceAnalysis,
+  getDragonKingAnalysis,
+  getDivingAnalysis,
+  getCheckInAnalysis,
+  getMemeBattleAnalysis,
+  getNightOwlAnalysis,
+  getRepeatAnalysis,
   isNewerStableVersion,
   buildChartPayload,
   POS_TAG_DEFINITIONS,
@@ -22557,6 +23543,8 @@ export {
   createJiebaNlpProvider,
   exportFilterResultToMarkdown,
   exportWithFormat,
+  getDbFileVersion,
+  getOrComputeAnalysisCache,
   PreferencesManager,
   checkConflictsFromSources,
   buildMergedOutput,
@@ -22576,4 +23564,4 @@ export {
   createDatabaseManagerAdapter,
   MergeSessionCache
 };
-//# sourceMappingURL=chunk-TMZC3SNX.mjs.map
+//# sourceMappingURL=chunk-YPTJVTVJ.mjs.map