chatlab-cli 0.29.0 → 0.30.1-beta.1

package/dist/{chunk-QQK7MLCR.mjs → chunk-36JGKW6K.mjs}

@@ -9,7 +9,7 @@ import {
   createEmptyContactsDiagnostics,
   normalizeContactsTimeRangePreset,
   resolveContactsTimeRange
-} from "./chunk-D4WTE7LV.mjs";
+} from "./chunk-TEX44HNL.mjs";
 import {
   PEOPLE_RELATIONSHIPS_ALGORITHM_VERSION,
   buildPeopleRelationshipsNeighborhoodGraph,
@@ -18,7 +18,7 @@ import {
   computePeopleRelationshipsSnapshot,
   normalizePeopleRelationshipsTimeRangePreset,
   resolvePeopleRelationshipsTimeRange
-} from "./chunk-2MZ6G4AC.mjs";
+} from "./chunk-WV5GSRQM.mjs";
 import {
   BUILTIN_MODELS,
   BUILTIN_PROVIDERS,
@@ -32,6 +32,7 @@ import {
   appLogger,
   batchSegmentChineseWithStats,
   batchSegmentWithFrequency,
+  buildExcludeKeywordsConditions,
   buildSessionInfo,
   clearJiebaInstance,
   clearSessionIndex,
@@ -79,7 +80,7 @@ import {
   updateMemberAliases,
   updateSessionOwnerId,
   writeAuthProfile
-} from "./chunk-WPI6YSAR.mjs";
+} from "./chunk-LVEJHB3X.mjs";
 import {
   __commonJS,
   __export,
@@ -2836,128 +2837,29 @@ function writeParseResultToDb(db, meta, members, messages) {
   return { messageCount, memberCount: members.length, skippedCount };
 }
 
-// ../../packages/node-runtime/src/import/perf-logger.ts
-import * as fs from "fs";
-import * as path from "path";
-var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
-  LogLevel2["ERROR"] = "ERROR";
-  LogLevel2["INFO"] = "INFO";
-  return LogLevel2;
-})(LogLevel || {});
-var lastLogTime = Date.now();
-var lastMessageCount = 0;
-var currentLogFile = null;
-var errorCount = 0;
-function initPerfLog(sessionId, logDir) {
-  try {
-    if (!fs.existsSync(logDir)) {
-      fs.mkdirSync(logDir, { recursive: true });
-    }
-    currentLogFile = path.join(logDir, `import_${sessionId}_${Date.now()}.log`);
-    fs.writeFileSync(currentLogFile, `=== Import Log ===
-Start time: ${(/* @__PURE__ */ new Date()).toISOString()}
-
-`, "utf-8");
-  } catch {
-  }
-}
-function logPerf(event, messagesProcessed, batchSize) {
-  const now = Date.now();
-  const duration = now - lastLogTime;
-  const messagesDelta = messagesProcessed - lastMessageCount;
-  const speed = duration > 0 ? Math.round(messagesDelta / duration * 1e3) : 0;
-  let memory = 0;
-  try {
-    const used = process.memoryUsage();
-    memory = Math.round(used.heapUsed / 1024 / 1024);
-  } catch {
-  }
-  const logLine = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${event} | messages: ${messagesProcessed.toLocaleString()} | elapsed: ${duration}ms | speed: ${speed.toLocaleString()}/s | memory: ${memory}MB` + (batchSize ? ` | batch: ${batchSize}` : "") + "\n";
-  if (currentLogFile) {
-    try {
-      fs.appendFileSync(currentLogFile, logLine, "utf-8");
-    } catch {
-    }
-  }
-  lastLogTime = now;
-  lastMessageCount = messagesProcessed;
-}
-function logPerfDetail(detail) {
-  if (currentLogFile) {
-    try {
-      fs.appendFileSync(currentLogFile, `  ${detail}
-`, "utf-8");
-    } catch {
-    }
-  }
-}
-function resetPerfLog() {
-  lastLogTime = Date.now();
-  lastMessageCount = 0;
-  currentLogFile = null;
-  errorCount = 0;
-}
-function getCurrentLogFile() {
-  return currentLogFile;
-}
-function writeLogLine(level, message) {
-  if (!currentLogFile) return;
-  const logLine = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${message}
-`;
-  try {
-    fs.appendFileSync(currentLogFile, logLine, "utf-8");
-  } catch {
-  }
-}
-function logError(message, error) {
-  errorCount++;
-  const errorDetail = error ? `: ${error.message}` : "";
-  writeLogLine("ERROR" /* ERROR */, `${message}${errorDetail}`);
-}
-function logInfo(message) {
-  writeLogLine("INFO" /* INFO */, message);
-}
-function getErrorCount() {
-  return errorCount;
-}
-function logSummary(totalMessages, totalMembers) {
-  if (!currentLogFile) return;
-  const summary = `
-=== Import Summary ===
-End time: ${(/* @__PURE__ */ new Date()).toISOString()}
-Total messages: ${totalMessages.toLocaleString()}
-Total members: ${totalMembers.toLocaleString()}
-Errors: ${errorCount}
-`;
-  try {
-    fs.appendFileSync(currentLogFile, summary, "utf-8");
-  } catch {
-  }
-}
-
 // ../../packages/parser/src/index.ts
-import * as fs18 from "fs";
-import * as path14 from "path";
+import * as fs17 from "fs";
+import * as path13 from "path";
 
 // ../../packages/parser/src/sniffer.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs from "fs";
+import * as path from "path";
 var HEAD_SIZE = 64 * 1024;
 function readFileHead(filePath, size = HEAD_SIZE) {
-  const fd = fs2.openSync(filePath, "r");
+  const fd = fs.openSync(filePath, "r");
   const buffer = Buffer.alloc(size);
-  const bytesRead = fs2.readSync(fd, buffer, 0, size, 0);
-  fs2.closeSync(fd);
+  const bytesRead = fs.readSync(fd, buffer, 0, size, 0);
+  fs.closeSync(fd);
   return buffer.slice(0, bytesRead).toString("utf-8");
 }
 function getExtension(filePath) {
-  return path2.extname(filePath).toLowerCase();
+  return path.extname(filePath).toLowerCase();
 }
 function matchHeadSignatures(headContent, patterns) {
   return patterns.some((pattern) => pattern.test(headContent));
 }
 function matchFilenameSignatures(filePath, patterns) {
-  const filename = path2.basename(filePath);
+  const filename = path.basename(filePath);
   return patterns.some((pattern) => pattern.test(filename));
 }
 function matchRequiredFields(headContent, fields) {
@@ -3105,18 +3007,18 @@ var import_stream_json = __toESM(require_stream_json(), 1);
 var import_Pick = __toESM(require_Pick(), 1);
 var import_StreamValues = __toESM(require_StreamValues(), 1);
 var import_stream_chain = __toESM(require_stream_chain(), 1);
-import * as fs4 from "fs";
+import * as fs3 from "fs";
 
 // ../../packages/parser/src/utils.ts
-import * as fs3 from "fs";
+import * as fs2 from "fs";
 function getFileSize(filePath) {
-  return fs3.statSync(filePath).size;
+  return fs2.statSync(filePath).size;
 }
 function readFileHeadBytes(filePath, size) {
-  const fd = fs3.openSync(filePath, "r");
+  const fd = fs2.openSync(filePath, "r");
   const buffer = Buffer.alloc(size);
-  const bytesRead = fs3.readSync(fd, buffer, 0, size, 0);
-  fs3.closeSync(fd);
+  const bytesRead = fs2.readSync(fd, buffer, 0, size, 0);
+  fs2.closeSync(fd);
   return buffer.slice(0, bytesRead).toString("utf-8");
 }
 var createProgress = (stage, bytesRead, totalBytes, messagesProcessed, message) => {
@@ -3146,13 +3048,185 @@ function isValidYear(timestampSeconds) {
 }
 
 // ../../packages/parser/src/formats/chatlab.ts
-import * as path3 from "path";
+import * as path2 from "path";
+
+// ../../packages/parser/src/native/loader.ts
+import { createRequire } from "module";
+var cachedModule;
+var cachedLoadError;
+function isNativeDisabled() {
+  return process.env.CHATLAB_DISABLE_NATIVE_PERF === "1";
+}
+function isNativeParserModule(value) {
+  return typeof value?.NativeParser === "function";
+}
+function requireNativeModule() {
+  const requireFn = createRequire(import.meta.url);
+  const module = requireFn("@openchatlab/parser-native");
+  if (!isNativeParserModule(module)) {
+    throw new Error("Native parser module missing NativeParser export");
+  }
+  return module;
+}
+function loadNativeParser() {
+  if (isNativeDisabled()) return null;
+  if (cachedModule !== void 0) return cachedModule;
+  try {
+    cachedModule = requireNativeModule();
+  } catch (error) {
+    cachedModule = null;
+    cachedLoadError = error instanceof Error ? error.message : String(error);
+  }
+  return cachedModule;
+}
+function getNativeParserStatus() {
+  if (isNativeDisabled()) return { available: false, disabled: true };
+  const module = loadNativeParser();
+  return { available: module !== null, disabled: false, error: module ? void 0 : cachedLoadError };
+}
+
+// ../../packages/parser/src/native/create-native-parser.ts
+var PROGRESS_POLL_INTERVAL_MS = 200;
+async function* pumpNativeParser(adapter, options2, parser11, fallback) {
+  const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
+  const totalBytes = getFileSize(filePath);
+  const initialProgress = createProgress("parsing", 0, totalBytes, 0, "");
+  yield { type: "progress", data: initialProgress };
+  onProgress?.(initialProgress);
+  onLog?.(
+    "info",
+    `[NativeParser] Parsing ${adapter.label} with Rust kernel, size: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`
+  );
+  const progressTimer = setInterval(() => {
+    const progress = parser11.progress();
+    onProgress?.(
+      createProgress(
+        "parsing",
+        progress.bytesRead,
+        totalBytes,
+        progress.messagesProcessed,
+        `\u5DF2\u5904\u7406 ${progress.messagesProcessed} \u6761\u6D88\u606F...`
+      )
+    );
+  }, PROGRESS_POLL_INTERVAL_MS);
+  try {
+    await parser11.parse();
+  } catch (error) {
+    onLog?.(
+      "warn",
+      `[NativeParser] Rust parse failed, falling back to TS parser: ${error instanceof Error ? error.message : String(error)}`
+    );
+    yield* fallback(options2);
+    return;
+  } finally {
+    clearInterval(progressTimer);
+  }
+  const metaJson = JSON.parse(parser11.metaJson());
+  yield { type: "meta", data: adapter.mapMeta(metaJson) };
+  const members = adapter.mapMembers(parser11.takeMembers(), metaJson);
+  yield { type: "members", data: members };
+  let messagesProcessed = 0;
+  while (true) {
+    const batch = parser11.takeBatch(batchSize);
+    if (!batch) break;
+    messagesProcessed += batch.length;
+    yield { type: "messages", data: batch.map((message) => adapter.mapMessage(message, metaJson)) };
+    await new Promise((resolve2) => setImmediate(resolve2));
+  }
+  const doneProgress = createProgress("done", totalBytes, totalBytes, messagesProcessed, "");
+  yield { type: "progress", data: doneProgress };
+  onProgress?.(doneProgress);
+  onLog?.("info", `\u89E3\u6790\u5B8C\u6210: ${messagesProcessed} \u6761\u6D88\u606F, ${members.length} \u4E2A\u6210\u5458`);
+  yield { type: "done", data: { messageCount: messagesProcessed, memberCount: members.length } };
+}
+function createNativeFirstParser(adapter, fallback) {
+  return async function* (options2) {
+    const native = loadNativeParser();
+    if (!native) {
+      yield* fallback(options2);
+      return;
+    }
+    let parser11;
+    try {
+      parser11 = new native.NativeParser(
+        adapter.formatId,
+        options2.filePath,
+        options2.formatOptions ? JSON.stringify(options2.formatOptions) : void 0
+      );
+    } catch (error) {
+      options2.onLog?.(
+        "warn",
+        `[NativeParser] Failed to create Rust parser, falling back to TS parser: ${error instanceof Error ? error.message : String(error)}`
+      );
+      yield* fallback(options2);
+      return;
+    }
+    yield* pumpNativeParser(adapter, options2, parser11, fallback);
+  };
+}
+
+// ../../packages/parser/src/native/chatlab-native.ts
+function toParsedMember(member, fromHead) {
+  if (!fromHead) {
+    return {
+      platformId: member.platformId,
+      accountName: member.accountName,
+      groupNickname: member.groupNickname
+    };
+  }
+  return {
+    platformId: member.platformId,
+    accountName: member.accountName,
+    groupNickname: member.groupNickname,
+    avatar: member.avatar,
+    // Role objects pass through with their original key set ({id} or {id, name}).
+    roles: member.roles?.map((role) => role.name !== void 0 ? { id: role.id, name: role.name } : { id: role.id })
+  };
+}
+var chatlabAdapter = {
+  formatId: "chatlab",
+  label: "ChatLab JSON",
+  mapMeta(metaJson) {
+    const meta = metaJson;
+    return {
+      name: meta.name,
+      platform: meta.platform,
+      type: meta.chatType,
+      groupId: meta.groupId ?? void 0,
+      groupAvatar: meta.groupAvatar ?? void 0
+    };
+  },
+  mapMembers(members, metaJson) {
+    const fromHead = metaJson.membersFromHead;
+    return members.map((member) => toParsedMember(member, fromHead));
+  },
+  mapMessage(message) {
+    return {
+      senderPlatformId: message.senderPlatformId,
+      senderAccountName: message.senderAccountName,
+      senderGroupNickname: message.senderGroupNickname,
+      // The kernel rejects non-number timestamps, so this is always set.
+      timestamp: message.timestamp,
+      type: message.messageType,
+      // The kernel rejects a missing content key, so undefined here always
+      // means the source value was JSON null.
+      content: message.content ?? null,
+      platformMessageId: message.platformMessageId,
+      replyToMessageId: message.replyToMessageId
+    };
+  }
+};
+function withNativeChatlab(fallback) {
+  return createNativeFirstParser(chatlabAdapter, fallback);
+}
+
+// ../../packages/parser/src/formats/chatlab.ts
 var { parser } = import_stream_json.default;
 var { pick } = import_Pick.default;
 var { streamValues } = import_StreamValues.default;
 var { chain } = import_stream_chain.default;
 function extractNameFromFilePath(filePath) {
-  const basename13 = path3.basename(filePath);
+  const basename13 = path2.basename(filePath);
   const name = basename13.replace(/\.json$/i, "");
   return name || "\u672A\u77E5\u7FA4\u804A";
 }
@@ -3241,7 +3315,7 @@ async function* parseChatLab(options2) {
   const memberMapFromMessages = /* @__PURE__ */ new Map();
   const messageBatch = [];
   await new Promise((resolve2, reject) => {
-    const readStream = fs4.createReadStream(filePath, { encoding: "utf-8" });
+    const readStream = fs3.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
@@ -3310,9 +3384,10 @@ async function* parseChatLab(options2) {
     }
   };
 }
+var parseChatLabAccelerated = withNativeChatlab(parseChatLab);
 var parser_ = {
   feature,
-  parse: parseChatLab
+  parse: parseChatLabAccelerated
 };
 var module_ = {
   feature,
@@ -3321,11 +3396,11 @@ var module_ = {
 var chatlab_default = module_;
 
 // ../../packages/parser/src/formats/chatlab-jsonl.ts
-import * as fs5 from "fs";
+import * as fs4 from "fs";
 import * as readline from "readline";
-import * as path4 from "path";
+import * as path3 from "path";
 function extractNameFromFilePath2(filePath) {
-  const basename13 = path4.basename(filePath);
+  const basename13 = path3.basename(filePath);
   const name = basename13.replace(/\.jsonl$/i, "");
   return name || "\u672A\u77E5\u7FA4\u804A";
 }
@@ -3366,7 +3441,7 @@ async function* parseChatLabJsonl(options2) {
   const messageBatch = [];
   let meta = null;
   let headerParsed = false;
-  const fileStream = fs5.createReadStream(filePath, { encoding: "utf-8" });
+  const fileStream = fs4.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline.createInterface({
     input: fileStream,
     crlfDelay: Infinity
@@ -3489,16 +3564,16 @@ var import_stream_json3 = __toESM(require_stream_json(), 1);
 var import_Pick3 = __toESM(require_Pick(), 1);
 var import_StreamValues3 = __toESM(require_StreamValues(), 1);
 var import_stream_chain3 = __toESM(require_stream_chain(), 1);
-import * as fs7 from "fs";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as path5 from "path";
 
 // ../../packages/parser/src/formats/shuakami-qq-preprocessor.ts
 var import_stream_json2 = __toESM(require_stream_json(), 1);
 var import_Pick2 = __toESM(require_Pick(), 1);
 var import_StreamValues2 = __toESM(require_StreamValues(), 1);
 var import_stream_chain2 = __toESM(require_stream_chain(), 1);
-import * as fs6 from "fs";
-import * as path5 from "path";
+import * as fs5 from "fs";
+import * as path4 from "path";
 import * as os from "os";
 var { parser: parser3 } = import_stream_json2.default;
 var { pick: pick2 } = import_Pick2.default;
@@ -3506,11 +3581,11 @@ var { streamValues: streamValues2 } = import_StreamValues2.default;
 var { chain: chain2 } = import_stream_chain2.default;
 var PREPROCESS_THRESHOLD = 50 * 1024 * 1024;
 function getTempDir() {
-  return path5.join(os.tmpdir(), "chatlab");
+  return path4.join(os.tmpdir(), "chatlab");
 }
 function ensureDir(dir) {
-  if (!fs6.existsSync(dir)) {
-    fs6.mkdirSync(dir, { recursive: true });
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
   }
 }
 function extractJsonObject(content, key) {
@@ -3552,12 +3627,12 @@ function extractJsonObject(content, key) {
 }
 function readAvatarsFromFile(filePath) {
   try {
-    const stats = fs6.statSync(filePath);
+    const stats = fs5.statSync(filePath);
     const tailSize = Math.min(stats.size, 5e6);
-    const fd = fs6.openSync(filePath, "r");
+    const fd = fs5.openSync(filePath, "r");
     const buffer = Buffer.alloc(tailSize);
-    fs6.readSync(fd, buffer, 0, tailSize, stats.size - tailSize);
-    fs6.closeSync(fd);
+    fs5.readSync(fd, buffer, 0, tailSize, stats.size - tailSize);
+    fs5.closeSync(fd);
     const tailContent = buffer.toString("utf-8");
     return extractJsonObject(tailContent, "avatars");
   } catch {
@@ -3616,15 +3691,15 @@ async function preprocessQQJson(inputPath, onProgress) {
   let messagesProcessed = 0;
   const tempDir = getTempDir();
   ensureDir(tempDir);
-  const outputFilename = `slim_${Date.now()}_${path5.basename(inputPath)}`;
-  const outputPath = path5.join(tempDir, outputFilename);
+  const outputFilename = `slim_${Date.now()}_${path4.basename(inputPath)}`;
+  const outputPath = path4.join(tempDir, outputFilename);
   onProgress?.(createProgress("parsing", 0, totalBytes, 0, ""));
   const avatarsStr = readAvatarsFromFile(inputPath);
   return new Promise((resolve2, reject) => {
     const headChunks = [];
     let headSize = 0;
     const maxHeadSize = 1e5;
-    const headStream = fs6.createReadStream(inputPath, { encoding: "utf-8" });
+    const headStream = fs5.createReadStream(inputPath, { encoding: "utf-8" });
     let chatInfo = { name: "\u672A\u77E5\u7FA4\u804A", type: "group" };
     let metadata;
     let statistics;
@@ -3661,8 +3736,8 @@ async function preprocessQQJson(inputPath, onProgress) {
       } catch {
       }
       onProgress?.(createProgress("parsing", 0, totalBytes, 0, ""));
-      const readStream = fs6.createReadStream(inputPath, { encoding: "utf-8" });
-      const writeStream = fs6.createWriteStream(outputPath, { encoding: "utf-8" });
+      const readStream = fs5.createReadStream(inputPath, { encoding: "utf-8" });
+      const writeStream = fs5.createWriteStream(outputPath, { encoding: "utf-8" });
       readStream.on("data", (chunk) => {
         bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
       });
@@ -3707,8 +3782,8 @@ async function preprocessQQJson(inputPath, onProgress) {
       });
       pipeline2.on("error", (err) => {
         writeStream.destroy();
-        if (fs6.existsSync(outputPath)) {
-          fs6.unlinkSync(outputPath);
+        if (fs5.existsSync(outputPath)) {
+          fs5.unlinkSync(outputPath);
         }
         onProgress?.(createProgress("error", bytesRead, totalBytes, messagesProcessed, err.message));
         reject(err);
@@ -3719,8 +3794,8 @@ async function preprocessQQJson(inputPath, onProgress) {
 }
 function cleanupTempFile(filePath) {
   try {
-    if (fs6.existsSync(filePath) && filePath.includes(getTempDir())) {
-      fs6.unlinkSync(filePath);
+    if (fs5.existsSync(filePath) && filePath.includes(getTempDir())) {
+      fs5.unlinkSync(filePath);
     }
   } catch {
   }
@@ -3787,7 +3862,7 @@ function extractJsonObject2(content, key) {
   return null;
 }
 function extractNameFromFilePath3(filePath) {
-  const basename13 = path6.basename(filePath);
+  const basename13 = path5.basename(filePath);
   return basename13.replace(/\.json$/i, "") || "\u672A\u77E5\u7FA4\u804A";
 }
 function countSenders(content) {
@@ -3872,7 +3947,7 @@ async function* parseV4(options2) {
   const memberMap = /* @__PURE__ */ new Map();
   const messageBatch = [];
   await new Promise((resolve2, reject) => {
-    const readStream = fs7.createReadStream(filePath, { encoding: "utf-8" });
+    const readStream = fs6.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
@@ -3930,12 +4005,12 @@ async function* parseV4(options2) {
   });
   const avatarsMap = /* @__PURE__ */ new Map();
   try {
-    const stats = fs7.statSync(filePath);
+    const stats = fs6.statSync(filePath);
     const tailSize = Math.min(stats.size, 5e6);
-    const fd = fs7.openSync(filePath, "r");
+    const fd = fs6.openSync(filePath, "r");
     const buffer = Buffer.alloc(tailSize);
-    fs7.readSync(fd, buffer, 0, tailSize, stats.size - tailSize);
-    fs7.closeSync(fd);
+    fs6.readSync(fd, buffer, 0, tailSize, stats.size - tailSize);
+    fs6.closeSync(fd);
     const tailContent = buffer.toString("utf-8");
     const avatarsStr = extractJsonObject2(tailContent, "avatars");
     if (avatarsStr) {
@@ -3987,8 +4062,8 @@ var module_3 = {
 var shuakami_qq_exporter_default = module_3;
 
 // ../../packages/parser/src/formats/shuakami-qq-exporter-chunked.ts
-import * as fs8 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path6 from "path";
 import * as readline2 from "readline";
 var feature4 = {
   id: "shuakami-qq-exporter-chunked",
@@ -4037,7 +4112,7 @@ function convertMessageType2(msgType, content, isRecalled) {
   return 0 /* TEXT */;
 }
 function readManifest(manifestPath) {
-  const content = fs8.readFileSync(manifestPath, "utf-8");
+  const content = fs7.readFileSync(manifestPath, "utf-8");
   return JSON.parse(content);
 }
 function getChunkRelativePath(chunk) {
@@ -4055,9 +4130,9 @@ function calculateTotalBytes(manifest, baseDir) {
   let total = 0;
   for (const chunk of manifest.chunked.chunks) {
     const relativePath = getChunkRelativePath(chunk);
-    const chunkPath = path7.join(baseDir, relativePath);
-    if (fs8.existsSync(chunkPath)) {
-      total += fs8.statSync(chunkPath).size;
+    const chunkPath = path6.join(baseDir, relativePath);
+    if (fs7.existsSync(chunkPath)) {
+      total += fs7.statSync(chunkPath).size;
     }
   }
   return total;
@@ -4065,10 +4140,10 @@ function calculateTotalBytes(manifest, baseDir) {
 function readAvatars(baseDir, avatarsInfo) {
   const avatarsMap = /* @__PURE__ */ new Map();
   if (!avatarsInfo?.file) return avatarsMap;
-  const avatarsPath = path7.join(baseDir, avatarsInfo.file);
-  if (!fs8.existsSync(avatarsPath)) return avatarsMap;
+  const avatarsPath = path6.join(baseDir, avatarsInfo.file);
+  if (!fs7.existsSync(avatarsPath)) return avatarsMap;
   try {
-    const content = fs8.readFileSync(avatarsPath, "utf-8");
+    const content = fs7.readFileSync(avatarsPath, "utf-8");
     const avatars = JSON.parse(content);
     for (const [uin, avatar] of Object.entries(avatars)) {
       if (avatar && typeof avatar === "string" && avatar.startsWith("data:image/")) {
@@ -4086,7 +4161,7 @@ async function* readJsonlFile(filePath, onParseError) {
   let parseErrorCount = 0;
   const MAX_PARSE_ERRORS_TO_LOG = 10;
   try {
-    fileStream = fs8.createReadStream(filePath, { encoding: "utf-8" });
+    fileStream = fs7.createReadStream(filePath, { encoding: "utf-8" });
     rl = readline2.createInterface({
       input: fileStream,
       crlfDelay: Infinity
@@ -4117,7 +4192,7 @@ async function* readJsonlFile(filePath, onParseError) {
 async function* parseChunkedJsonl(options2) {
   const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const manifestPath = filePath;
-  const baseDir = path7.dirname(manifestPath);
+  const baseDir = path6.dirname(manifestPath);
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 manifest: ${manifestPath}`);
   onLog?.("info", `\u57FA\u7840\u76EE\u5F55: ${baseDir}`);
   let manifest;
@@ -4171,13 +4246,13 @@ async function* parseChunkedJsonl(options2) {
   for (let chunkIndex = 0; chunkIndex < manifest.chunked.chunks.length; chunkIndex++) {
     const chunkInfo = manifest.chunked.chunks[chunkIndex];
     const relativePath = getChunkRelativePath(chunkInfo);
-    const chunkPath = path7.join(baseDir, relativePath);
+    const chunkPath = path6.join(baseDir, relativePath);
     const chunkMessageCount = getChunkMessageCount(chunkInfo);
-    if (!fs8.existsSync(chunkPath)) {
+    if (!fs7.existsSync(chunkPath)) {
       onLog?.("error", `\u5206\u5757\u6587\u4EF6\u4E0D\u5B58\u5728: ${chunkPath}`);
       continue;
     }
-    const chunkSize = fs8.statSync(chunkPath).size;
+    const chunkSize = fs7.statSync(chunkPath).size;
     let chunkMessagesRead = 0;
     let chunkParseErrors = 0;
     onLog?.(
@@ -4299,8 +4374,49 @@ var import_stream_json4 = __toESM(require_stream_json(), 1);
 var import_Pick4 = __toESM(require_Pick(), 1);
 var import_StreamValues4 = __toESM(require_StreamValues(), 1);
 var import_stream_chain4 = __toESM(require_stream_chain(), 1);
-import * as fs9 from "fs";
-import * as path8 from "path";
+import * as fs8 from "fs";
+import * as path7 from "path";
+
+// ../../packages/parser/src/native/weflow-native.ts
+var weflowAdapter = {
+  formatId: "weflow",
+  label: "WeFlow export",
+  mapMeta(metaJson) {
+    const meta = metaJson;
+    return {
+      name: meta.name,
+      platform: KNOWN_PLATFORMS.WECHAT,
+      type: meta.chatType === "private" ? "private" /* PRIVATE */ : "group" /* GROUP */,
+      groupId: meta.groupId ?? void 0,
+      groupAvatar: meta.groupAvatar ?? void 0,
+      ownerId: meta.ownerId ?? void 0
+    };
+  },
+  mapMembers(members) {
+    return members.map((member) => ({
+      platformId: member.platformId,
+      accountName: member.accountName,
+      avatar: member.avatar
+    }));
+  },
+  mapMessage(message) {
+    return {
+      // The kernel always emits an id string (String(localId), JS semantics).
+      platformMessageId: message.platformMessageId,
+      senderPlatformId: message.senderPlatformId,
+      senderAccountName: message.senderAccountName,
+      // WeFlow has no separate group nickname field (same as the TS parser).
+      senderGroupNickname: void 0,
+      // The TS parser passes createTime through as-is, including null.
+      timestamp: message.timestamp ?? null,
+      type: message.messageType,
+      content: message.content ?? null
+    };
+  }
+};
+function withNativeWeflow(fallback) {
+  return createNativeFirstParser(weflowAdapter, fallback);
+}
 
 // ../../packages/parser/src/formats/weflow-preprocessor.ts
 var weflowPreprocessor = {
@@ -4332,7 +4448,7 @@ var { pick: pick4 } = import_Pick4.default;
 var { streamValues: streamValues4 } = import_StreamValues4.default;
 var { chain: chain4 } = import_stream_chain4.default;
 function extractNameFromFilePath4(filePath) {
-  const basename13 = path8.basename(filePath);
+  const basename13 = path7.basename(filePath);
   const name = basename13.replace(/\.json$/i, "");
   return name || "\u672A\u77E5\u804A\u5929";
 }
@@ -4401,7 +4517,7 @@ async function* parseWeFlow(options2) {
   let session = null;
   try {
     await new Promise((resolve2) => {
-      const sessionStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
+      const sessionStream = fs8.createReadStream(filePath, { encoding: "utf-8" });
       let sessionContent = "";
       let inSession = false;
       let braceDepth = 0;
@@ -4524,7 +4640,7 @@ async function* parseWeFlow(options2) {
   if (avatarsMap.size === 0) {
     try {
       await new Promise((resolve2) => {
-        const avatarStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
+        const avatarStream = fs8.createReadStream(filePath, { encoding: "utf-8" });
         let avatarsContent = "";
         let inAvatars = false;
         let braceDepth = 0;
@@ -4591,7 +4707,7 @@ async function* parseWeFlow(options2) {
   let ownerId;
   try {
     await new Promise((resolve2) => {
-      const scanStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
+      const scanStream = fs8.createReadStream(filePath, { encoding: "utf-8" });
       const scanPipeline = chain4([scanStream, parser5(), pick4({ filter: /^messages\.\d+$/ }), streamValues4()]);
       scanPipeline.on("data", ({ value }) => {
         if (value.isSend === 1 && value.senderUsername && !value.senderUsername.endsWith("@chatroom")) {
@@ -4617,7 +4733,7 @@ async function* parseWeFlow(options2) {
   const memberMap = /* @__PURE__ */ new Map();
   const messageBatch = [];
   await new Promise((resolve2, reject) => {
-    const readStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
+    const readStream = fs8.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
@@ -4712,9 +4828,10 @@ async function* parseWeFlow(options2) {
     data: { messageCount: messagesProcessed, memberCount: memberMap.size }
   };
 }
+var parseWeFlowAccelerated = withNativeWeflow(parseWeFlow);
 var parser_4 = {
   feature: feature5,
-  parse: parseWeFlow
+  parse: parseWeFlowAccelerated
 };
 var module_5 = {
   feature: feature5,
@@ -4739,7 +4856,7 @@ var feature6 = {
 };
 var parser_5 = {
   feature: feature6,
-  parse: parseWeFlow
+  parse: parseWeFlowAccelerated
 };
 var module_6 = {
   feature: feature6,
@@ -4753,7 +4870,7 @@ var import_stream_json5 = __toESM(require_stream_json(), 1);
 var import_Pick5 = __toESM(require_Pick(), 1);
 var import_StreamValues5 = __toESM(require_StreamValues(), 1);
 var import_stream_chain5 = __toESM(require_stream_chain(), 1);
-import * as fs10 from "fs";
+import * as fs9 from "fs";
 var { parser: parser6 } = import_stream_json5.default;
 var { pick: pick5 } = import_Pick5.default;
 var { streamValues: streamValues5 } = import_StreamValues5.default;
@@ -4903,7 +5020,7 @@ async function* parseDiscordExporter(options2) {
   const memberMap = /* @__PURE__ */ new Map();
   const messageBatch = [];
   await new Promise((resolve2, reject) => {
-    const readStream = fs10.createReadStream(filePath, { encoding: "utf-8" });
+    const readStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
@@ -5019,7 +5136,7 @@ var import_stream_chain6 = __toESM(require_stream_chain(), 1);
 var import_stream_json6 = __toESM(require_stream_json(), 1);
 var import_Pick6 = __toESM(require_Pick(), 1);
 var import_StreamValues6 = __toESM(require_StreamValues(), 1);
-import * as fs11 from "fs";
+import * as fs10 from "fs";
 
 // ../../packages/parser/src/formats/utils/telegram-utils.ts
 function mapChatType(telegramType) {
@@ -5105,7 +5222,7 @@ var feature8 = {
 async function scanChats(filePath) {
   const chats = [];
   return new Promise((resolve2, reject) => {
-    const readStream = fs11.createReadStream(filePath, { encoding: "utf-8" });
+    const readStream = fs10.createReadStream(filePath, { encoding: "utf-8" });
     const pipeline2 = chain6([readStream, parser7(), pick6({ filter: /^chats\.list\.\d+$/ }), streamValues6()]);
     pipeline2.on("data", ({ value }) => {
       const chat = value;
@@ -5138,7 +5255,7 @@ async function* parseTelegram(options2) {
   onLog?.("info", `\u76EE\u6807\u804A\u5929\u7D22\u5F15: ${chatIndex}`);
   const chatPathFilter = `chats.list.${chatIndex}`;
   const chatData = await new Promise((resolve2, reject) => {
-    const readStream = fs11.createReadStream(filePath, { encoding: "utf-8" });
+    const readStream = fs10.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
@@ -5246,7 +5363,7 @@ var telegram_native_default = module_8;
 var import_stream_chain7 = __toESM(require_stream_chain(), 1);
 var import_stream_json7 = __toESM(require_stream_json(), 1);
 var import_StreamValues7 = __toESM(require_StreamValues(), 1);
-import * as fs12 from "fs";
+import * as fs11 from "fs";
 var { chain: chain7 } = import_stream_chain7.default;
 var { parser: parser8 } = import_stream_json7.default;
 var { streamValues: streamValues7 } = import_StreamValues7.default;
@@ -5276,7 +5393,7 @@ async function* parseTelegramSingle(options2) {
   onProgress?.(initialProgress);
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 Telegram \u5355\u804A\u5929 JSON \u6587\u4EF6\uFF0C\u5927\u5C0F: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`);
   const chatData = await new Promise((resolve2, reject) => {
-    const readStream = fs12.createReadStream(filePath, { encoding: "utf-8" });
+    const readStream = fs11.createReadStream(filePath, { encoding: "utf-8" });
     const pipeline2 = chain7([readStream, parser8(), streamValues7()]);
     let found = false;
     pipeline2.on("data", ({ value }) => {
@@ -5374,11 +5491,11 @@ var module_9 = {
 var telegram_native_single_default = module_9;
 
 // ../../packages/parser/src/formats/whatsapp-native-txt.ts
-import * as fs13 from "fs";
-import * as path9 from "path";
+import * as fs12 from "fs";
+import * as path8 from "path";
 import * as readline3 from "readline";
 function extractNameFromFilePath5(filePath) {
-  const basename13 = path9.basename(filePath);
+  const basename13 = path8.basename(filePath);
   const matchZhCn = basename13.match(/^与(.+?)的\s*WhatsApp\s*聊天\.txt$/i);
   if (matchZhCn) return matchZhCn[1].trim();
   const matchZhTw = basename13.match(/^與(.+?)的\s*WhatsApp\s*對話\.txt$/i);
@@ -5582,7 +5699,7 @@ async function* parseWhatsApp(options2) {
       messagesProcessed++;
     }
   };
-  const fileStream = fs13.createReadStream(filePath, { encoding: "utf-8" });
+  const fileStream = fs12.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline3.createInterface({
     input: fileStream,
     crlfDelay: Infinity
@@ -5702,11 +5819,11 @@ var module_10 = {
 var whatsapp_native_txt_default = module_10;
 
 // ../../packages/parser/src/formats/qq-native-txt.ts
-import * as fs14 from "fs";
-import * as path10 from "path";
+import * as fs13 from "fs";
+import * as path9 from "path";
 import * as readline4 from "readline";
 function extractNameFromFilePath6(filePath) {
-  const basename13 = path10.basename(filePath);
+  const basename13 = path9.basename(filePath);
   const name = basename13.replace(/\.txt$/i, "");
   return name || "\u672A\u77E5\u7FA4\u804A";
 }
@@ -5788,7 +5905,7 @@ async function* parseTxt(options2) {
       messagesProcessed++;
     }
   };
-  const fileStream = fs14.createReadStream(filePath, { encoding: "utf-8" });
+  const fileStream = fs13.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline4.createInterface({
     input: fileStream,
     crlfDelay: Infinity
@@ -5888,8 +6005,8 @@ var module_11 = {
 var qq_native_txt_default = module_11;
 
 // ../../packages/parser/src/formats/instagram-native.ts
-import * as fs15 from "fs";
-import * as path11 from "path";
+import * as fs14 from "fs";
+import * as path10 from "path";
 var feature12 = {
   id: "instagram-native",
   name: "Instagram \u5B98\u65B9\u5BFC\u51FA",
@@ -5915,7 +6032,7 @@ function decodeInstagramText(text) {
   }
 }
 function extractNameFromFilePath7(filePath) {
-  const basename13 = path11.basename(filePath);
+  const basename13 = path10.basename(filePath);
   return basename13.replace(/\.json$/i, "") || "\u672A\u77E5\u5BF9\u8BDD";
 }
 function isSystemMessage2(content) {
@@ -5984,7 +6101,7 @@ async function* parseInstagram(options2) {
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 Instagram \u804A\u5929\u8BB0\u5F55\uFF0C\u5927\u5C0F: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`);
   let data;
   try {
-    const content = fs15.readFileSync(filePath, "utf-8");
+    const content = fs14.readFileSync(filePath, "utf-8");
     data = JSON.parse(content);
   } catch (error) {
     const err = new Error(`\u65E0\u6CD5\u89E3\u6790 Instagram JSON \u6587\u4EF6: ${error}`);
@@ -6079,8 +6196,8 @@ var import_stream_chain8 = __toESM(require_stream_chain(), 1);
 var import_stream_json8 = __toESM(require_stream_json(), 1);
 var import_Pick7 = __toESM(require_Pick(), 1);
 var import_StreamValues8 = __toESM(require_StreamValues(), 1);
-import * as fs16 from "fs";
-import * as path12 from "path";
+import * as fs15 from "fs";
+import * as path11 from "path";
 var { chain: chain8 } = import_stream_chain8.default;
 var { parser: parser9 } = import_stream_json8.default;
 var { pick: pick7 } = import_Pick7.default;
@@ -6163,12 +6280,12 @@ function normalizeIdentity(user) {
   };
 }
 function readJson(filePath) {
-  return JSON.parse(fs16.readFileSync(filePath, "utf8"));
+  return JSON.parse(fs15.readFileSync(filePath, "utf8"));
 }
 function resolveManifestFile(manifestDir, relativePath) {
-  const resolved = path12.resolve(manifestDir, relativePath);
-  const relative2 = path12.relative(manifestDir, resolved);
-  if (relative2.startsWith("..") || path12.isAbsolute(relative2)) {
+  const resolved = path11.resolve(manifestDir, relativePath);
+  const relative2 = path11.relative(manifestDir, resolved);
+  if (relative2.startsWith("..") || path11.isAbsolute(relative2)) {
     throw new Error(`Google Chat manifest path escapes its directory: ${relativePath}`);
   }
   return resolved;
@@ -6181,7 +6298,7 @@ function readManifest2(filePath) {
   if (manifest.chatType !== "private" && manifest.chatType !== "group") {
     throw new Error("Invalid Google Chat chat type");
   }
-  const manifestDir = path12.dirname(filePath);
+  const manifestDir = path11.dirname(filePath);
   return {
     manifest,
     userInfoPath: resolveManifestFile(manifestDir, manifest.userInfoFile),
@@ -6259,7 +6376,7 @@ async function* parseGoogleChat(options2) {
     });
   }
   yield { type: "members", data: Array.from(memberMap.values()) };
-  const readStream = fs16.createReadStream(messagesPath, { encoding: "utf8" });
+  const readStream = fs15.createReadStream(messagesPath, { encoding: "utf8" });
   let bytesRead = 0;
   let messagesProcessed = 0;
   readStream.on("data", (chunk) => {
@@ -6312,8 +6429,8 @@ var module_13 = {
 var google_chat_takeout_default = module_13;
 
 // ../../packages/parser/src/formats/line-native-txt.ts
-import * as fs17 from "fs";
-import * as path13 from "path";
+import * as fs16 from "fs";
+import * as path12 from "path";
 var feature14 = {
   id: "line-native-txt",
   name: "LINE \u5B98\u65B9\u5BFC\u51FA TXT",
@@ -6341,7 +6458,7 @@ var feature14 = {
   }
 };
 function extractNameFromFilePath8(filePath) {
-  const basename13 = path13.basename(filePath, ".txt");
+  const basename13 = path12.basename(filePath, ".txt");
   const name = basename13.replace(/^\[LINE\]\s*/i, "").trim();
   return name || "\u672A\u77E5\u804A\u5929";
 }
@@ -6521,7 +6638,7 @@ async function* parseLINE(options2) {
   yield { type: "progress", data: initialProgress };
   onProgress?.(initialProgress);
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 LINE \u5BFC\u51FA\u6587\u4EF6\uFF0C\u5927\u5C0F: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`);
-  const content = fs17.readFileSync(filePath, "utf-8");
+  const content = fs16.readFileSync(filePath, "utf-8");
   const lines = content.split("\n").map((line) => line.replace(/\r$/, ""));
   let currentDate = null;
   let chatName = extractNameFromFilePath8(filePath);
@@ -6829,12 +6946,12 @@ function findEntryFileInDirectory(dirPath, maxDepth = 1) {
     if (depth > maxDepth) return null;
     let entries;
     try {
-      entries = fs18.readdirSync(current, { withFileTypes: true });
+      entries = fs17.readdirSync(current, { withFileTypes: true });
     } catch {
       return null;
     }
     for (const entry of entries) {
-      const full = path14.join(current, entry.name);
+      const full = path13.join(current, entry.name);
       if (entry.isFile() && entry.name.endsWith(".json")) {
         const format = detectFormat(full);
         if (format) return full;
@@ -6842,7 +6959,7 @@ function findEntryFileInDirectory(dirPath, maxDepth = 1) {
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const found = walk(path14.join(current, entry.name), depth + 1);
+        const found = walk(path13.join(current, entry.name), depth + 1);
         if (found) return found;
       }
     }
@@ -6873,8 +6990,124 @@ async function streamParseFile(filePath, callbacks, formatId) {
   }
 }
 
+// ../../packages/node-runtime/src/import/native-parser-status.ts
+var logged = false;
+function logNativeParserStatus() {
+  if (logged) return;
+  logged = true;
+  const status = getNativeParserStatus();
+  if (status.available) {
+    appLogger.info("import", "Native parser kernels available (Rust module loaded)");
+  } else if (status.disabled) {
+    appLogger.info("import", "Native parser kernels disabled via CHATLAB_DISABLE_NATIVE_PERF=1; using TS parsers");
+  } else {
+    appLogger.warn("import", "Native parser kernels unavailable; imports fall back to TS parsers", {
+      reason: status.error ?? "unknown"
+    });
+  }
+}
+
+// ../../packages/node-runtime/src/import/perf-logger.ts
+import * as fs18 from "fs";
+import * as path14 from "path";
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2["ERROR"] = "ERROR";
+  LogLevel2["INFO"] = "INFO";
+  return LogLevel2;
+})(LogLevel || {});
+var lastLogTime = Date.now();
+var lastMessageCount = 0;
+var currentLogFile = null;
+var errorCount = 0;
+function initPerfLog(sessionId, logDir) {
+  try {
+    if (!fs18.existsSync(logDir)) {
+      fs18.mkdirSync(logDir, { recursive: true });
+    }
+    currentLogFile = path14.join(logDir, `import_${sessionId}_${Date.now()}.log`);
+    fs18.writeFileSync(currentLogFile, `=== Import Log ===
+Start time: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+`, "utf-8");
+  } catch {
+  }
+}
+function logPerf(event, messagesProcessed, batchSize) {
+  const now = Date.now();
+  const duration = now - lastLogTime;
+  const messagesDelta = messagesProcessed - lastMessageCount;
+  const speed = duration > 0 ? Math.round(messagesDelta / duration * 1e3) : 0;
+  let memory = 0;
+  try {
+    const used = process.memoryUsage();
+    memory = Math.round(used.heapUsed / 1024 / 1024);
+  } catch {
+  }
+  const logLine = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${event} | messages: ${messagesProcessed.toLocaleString()} | elapsed: ${duration}ms | speed: ${speed.toLocaleString()}/s | memory: ${memory}MB` + (batchSize ? ` | batch: ${batchSize}` : "") + "\n";
+  if (currentLogFile) {
+    try {
+      fs18.appendFileSync(currentLogFile, logLine, "utf-8");
+    } catch {
+    }
+  }
+  lastLogTime = now;
+  lastMessageCount = messagesProcessed;
+}
+function logPerfDetail(detail) {
+  if (currentLogFile) {
+    try {
+      fs18.appendFileSync(currentLogFile, `  ${detail}
+`, "utf-8");
+    } catch {
+    }
+  }
+}
+function resetPerfLog() {
+  lastLogTime = Date.now();
+  lastMessageCount = 0;
+  currentLogFile = null;
+  errorCount = 0;
+}
+function getCurrentLogFile() {
+  return currentLogFile;
+}
+function writeLogLine(level, message) {
+  if (!currentLogFile) return;
+  const logLine = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${message}
+`;
+  try {
+    fs18.appendFileSync(currentLogFile, logLine, "utf-8");
+  } catch {
+  }
+}
+function logError(message, error) {
+  errorCount++;
+  const errorDetail = error ? `: ${error.message}` : "";
+  writeLogLine("ERROR" /* ERROR */, `${message}${errorDetail}`);
+}
+function logInfo(message) {
+  writeLogLine("INFO" /* INFO */, message);
+}
+function getErrorCount() {
+  return errorCount;
+}
+function logSummary(totalMessages, totalMembers) {
+  if (!currentLogFile) return;
+  const summary = `
+=== Import Summary ===
+End time: ${(/* @__PURE__ */ new Date()).toISOString()}
+Total messages: ${totalMessages.toLocaleString()}
+Total members: ${totalMembers.toLocaleString()}
+Errors: ${errorCount}
+`;
+  try {
+    fs18.appendFileSync(currentLogFile, summary, "utf-8");
+  } catch {
+  }
+}
+
 // ../../packages/node-runtime/src/nlp/word-frequency.ts
-function buildMessageQuery(timeFilter, memberId) {
+function buildMessageQuery(timeFilter, memberId, excludeKeywords) {
   const conditions = [];
   const params = [];
   if (timeFilter?.startTs !== void 0) {
@@ -6889,6 +7122,11 @@ function buildMessageQuery(timeFilter, memberId) {
     conditions.push("msg.sender_id = ?");
     params.push(memberId);
   }
+  if (excludeKeywords && excludeKeywords.length > 0) {
+    const exclude = buildExcludeKeywordsConditions(excludeKeywords);
+    conditions.push(...exclude.conditions);
+    params.push(...exclude.params);
+  }
   conditions.push("COALESCE(m.account_name, '') != '\u7CFB\u7EDF\u6D88\u606F'");
   conditions.push("msg.type = 0");
   conditions.push("msg.content IS NOT NULL");
@@ -6910,9 +7148,10 @@ function computeWordFrequency(db, params) {
     customPosTags,
     enableStopwords = true,
     dictType = "default",
-    excludeWords
+    excludeWords,
+    excludeKeywords
   } = params;
-  const { clause, params: filterParams } = buildMessageQuery(timeFilter, memberId);
+  const { clause, params: filterParams } = buildMessageQuery(timeFilter, memberId, excludeKeywords);
   const messages = db.prepare(`SELECT msg.content FROM message msg JOIN member m ON msg.sender_id = m.id${clause}`).all(...filterParams);
   if (messages.length === 0) {
     return { words: [], totalWords: 0, totalMessages: 0, uniqueWords: 0 };
@@ -7173,6 +7412,7 @@ function searchByFts(db, keywords, limit = 1e3, offset = 0) {
 import * as fs20 from "fs";
 var BATCH_COMMIT_SIZE = 5e4;
 var CHECKPOINT_INTERVAL = 2e5;
+var yieldToEventLoop = () => new Promise((resolve2) => setImmediate(resolve2));
 function defaultGenerateSessionId() {
   const ts = Date.now();
   const rand = Math.random().toString(36).substring(2, 8);
@@ -7254,7 +7494,13 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
     `INSERT INTO meta (name, platform, type, imported_at, group_id, group_avatar, owner_id) VALUES (?, ?, ?, ?, ?, ?, ?)`
   );
   const insertMember = db.prepare(
-    `INSERT OR IGNORE INTO member (platform_id, account_name, group_nickname, avatar, roles) VALUES (?, ?, ?, ?, ?)`
+    `INSERT INTO member (platform_id, account_name, group_nickname, avatar, roles)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(platform_id) DO UPDATE SET
+       account_name = COALESCE(NULLIF(excluded.account_name, ''), account_name),
+       group_nickname = COALESCE(NULLIF(excluded.group_nickname, ''), group_nickname),
+       avatar = COALESCE(NULLIF(excluded.avatar, ''), avatar),
+       roles = CASE WHEN excluded.roles != '[]' THEN excluded.roles ELSE roles END`
   );
   const getMemberId = db.prepare(`SELECT id FROM member WHERE platform_id = ?`);
   const insertMessage = db.prepare(
@@ -7297,7 +7543,7 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
         lastCheckpointCount = totalMessageCount;
       }
       onProgress({
-        stage: "importing",
+        stage: "saving",
         bytesRead: 0,
         totalBytes: 0,
         messagesProcessed: totalMessageCount,
@@ -7469,13 +7715,14 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
       inTransaction = false;
     }
     onProgress({
-      stage: "importing",
+      stage: "saving",
       bytesRead: 0,
       totalBytes: 0,
       messagesProcessed: totalMessageCount,
       percentage: 100,
       message: ""
     });
+    await yieldToEventLoop();
     logger?.perf("Writing nickname history", totalMessageCount);
     db.exec("BEGIN TRANSACTION");
     let historyCount = 0;
@@ -7491,13 +7738,14 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
     db.exec("COMMIT");
     logger?.perf(`Nickname history written (${historyCount} entries)`, totalMessageCount);
     onProgress({
-      stage: "importing",
+      stage: "indexing",
       bytesRead: 0,
       totalBytes: 0,
       messagesProcessed: totalMessageCount,
       percentage: 100,
       message: ""
     });
+    await yieldToEventLoop();
     logger?.perf("Creating indexes", totalMessageCount);
     db.exec(CHAT_DB_INDEXES);
     logger?.perf("Indexes created", totalMessageCount);
@@ -7508,13 +7756,14 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
       logger?.error("FTS index build failed (non-fatal)", ftsError instanceof Error ? ftsError : void 0);
     }
     onProgress({
-      stage: "importing",
+      stage: "indexing",
       bytesRead: 0,
       totalBytes: 0,
       messagesProcessed: totalMessageCount,
       percentage: 100,
       message: ""
     });
+    await yieldToEventLoop();
     doCheckpoint();
     logger?.perf("WAL checkpoint done", totalMessageCount);
     try {
@@ -10550,45 +10799,65 @@ var defaultLogger4 = {
   warn: () => {
   }
 };
+function emptyStats(count) {
+  return {
+    input: count,
+    output: count,
+    cleaned: 0,
+    blacklistRemoved: 0,
+    denoiseRemoved: 0,
+    mergeCombined: 0,
+    desensitizeRulesApplied: 0
+  };
+}
 function preprocessMessages(messages, config, logger = defaultLogger4) {
-  if (!config || !hasAnyEnabled(config)) return messages;
-  if (messages.length === 0) return messages;
-  const inputCount = messages.length;
+  return preprocessMessagesWithStats(messages, config, logger).messages;
+}
+function preprocessMessagesWithStats(messages, config, logger = defaultLogger4) {
+  if (!config || !hasAnyEnabled(config)) return { messages, stats: emptyStats(messages.length) };
+  if (messages.length === 0) return { messages, stats: emptyStats(0) };
+  const stats = emptyStats(messages.length);
   let result = [...messages];
   const applied = [];
   if (config.dataCleaning !== false) {
     const cleaned = applyDataCleaning(result);
     if (cleaned.changed > 0) {
       result = cleaned.messages;
+      stats.cleaned = cleaned.changed;
       applied.push(`dataCleaning: ${cleaned.changed} messages cleaned`);
     }
   }
   if (config.blacklistKeywords.length > 0) {
     const before = result.length;
     result = applyBlacklistFilter(result, config.blacklistKeywords);
+    stats.blacklistRemoved = before - result.length;
     applied.push(`blacklist: ${before} \u2192 ${result.length} (-${before - result.length})`);
   }
   if (config.denoise) {
     const before = result.length;
     result = applyDenoise(result);
+    stats.denoiseRemoved = before - result.length;
     applied.push(`denoise: ${before} \u2192 ${result.length} (-${before - result.length})`);
   }
   if (config.mergeConsecutive) {
     const before = result.length;
     result = applyMergeConsecutive(result, config.mergeWindowSeconds ?? MERGE_WINDOW_DEFAULT);
+    stats.mergeCombined = before - result.length;
     applied.push(`merge: ${before} \u2192 ${result.length} (-${before - result.length})`);
   }
   if (config.desensitize) {
     const enabledRules = (config.desensitizeRules || []).filter((r) => r.enabled);
     if (enabledRules.length > 0) {
       result = applyDesensitize(result, enabledRules, logger);
+      stats.desensitizeRulesApplied = enabledRules.length;
       applied.push(`desensitize: ${enabledRules.length} rules applied`);
     }
   }
-  logger.info("Preprocess", `Pipeline: ${inputCount} \u2192 ${result.length} messages`, {
+  stats.output = result.length;
+  logger.info("Preprocess", `Pipeline: ${stats.input} \u2192 ${result.length} messages`, {
     strategies: applied
   });
-  return result;
+  return { messages: result, stats };
 }
 function hasAnyEnabled(config) {
   return config.dataCleaning !== false || config.mergeConsecutive || config.blacklistKeywords.length > 0 || config.denoise || config.desensitize;
@@ -10683,9 +10952,16 @@ function applyMergeConsecutive(messages, windowSeconds) {
     const sameSender = isSameSender(current, msg);
     const withinWindow = Math.abs(msg.timestamp - current.timestamp) <= windowSeconds;
     if (sameSender && withinWindow) {
+      const mergedIds = [
+        ...current.mergedIds ?? (current.id != null ? [current.id] : []),
+        ...msg.mergedIds ?? (msg.id != null ? [msg.id] : [])
+      ];
       current = {
         ...current,
-        content: [current.content, msg.content].filter(Boolean).join("\n")
+        content: [current.content, msg.content].filter(Boolean).join("\n"),
+        // keep first message's id, track last id for [#start-end] range citations
+        mergedEndId: msg.id ?? current.mergedEndId,
+        ...mergedIds.length > 0 ? { mergedIds } : {}
       };
     } else {
       merged.push(current);
@@ -10706,15 +10982,29 @@ function applyDesensitize(messages, rules, logger) {
   if (compiledRules.length === 0) return messages;
   return messages.map((msg) => {
     if (!msg.content) return msg;
-    let content = msg.content;
-    for (const { regex, replacement } of compiledRules) {
-      regex.lastIndex = 0;
-      content = content.replace(regex, replacement);
-    }
+    const content = applyCompiledRules(msg.content, compiledRules);
     if (content === msg.content) return msg;
     return { ...msg, content };
   });
 }
+function applyCompiledRules(text, compiledRules) {
+  let result = text;
+  for (const { regex, replacement } of compiledRules) {
+    regex.lastIndex = 0;
+    result = result.replace(regex, replacement);
+  }
+  return result;
+}
+function desensitizeText(text, rules, logger = defaultLogger4) {
+  const enabledRules = rules.filter((r) => r.enabled);
+  if (enabledRules.length === 0 || !text) return text;
+  return applyCompiledRules(text, compileRules(enabledRules, logger));
+}
+function matchesBlacklist(text, keywords) {
+  if (keywords.length === 0 || !text) return false;
+  const lower = text.toLowerCase();
+  return keywords.some((kw) => lower.includes(kw.toLowerCase()));
+}
 var regexCache = /* @__PURE__ */ new Map();
 function compileRules(rules, logger) {
   const result = [];
@@ -11040,14 +11330,26 @@ function t(key, locale) {
   return "";
 }
 var MAX_MESSAGE_CONTENT_LENGTH = 200;
-function formatMessageCompact(msg, locale) {
+function formatMessageCompact(msg, locale, options2) {
   const localeStr = isChineseLocale(locale) ? "zh-CN" : "en-US";
   const time = new Date(msg.timestamp * 1e3).toLocaleString(localeStr);
   let content = msg.content || t("noContent", locale);
-  if (content.length > MAX_MESSAGE_CONTENT_LENGTH) {
-    content = content.slice(0, MAX_MESSAGE_CONTENT_LENGTH) + "...";
+  const maxLength = options2?.maxContentLength ?? MAX_MESSAGE_CONTENT_LENGTH;
+  if (maxLength > 0 && content.length > maxLength) {
+    content = content.slice(0, maxLength) + "...";
+  }
+  let idPrefix = "";
+  if (options2?.includeMessageId && msg.id != null) {
+    const range = msg.mergedEndId != null && msg.mergedEndId !== msg.id ? `${msg.id}-${msg.mergedEndId}` : `${msg.id}`;
+    const hitMark = isHitMessage(msg, options2.hitIds) ? "*" : "";
+    idPrefix = `[#${range}${hitMark}] `;
   }
-  return `${time} ${msg.senderName}: ${content}`;
+  return `${idPrefix}${time} ${msg.senderName}: ${content}`;
+}
+function isHitMessage(msg, hitIds) {
+  if (!hitIds) return false;
+  if (msg.id != null && hitIds.has(msg.id)) return true;
+  return msg.mergedIds?.some((id) => hitIds.has(id)) ?? false;
 }
 function formatTimeRange(timeFilter, locale) {
   if (!timeFilter) return t("allTime", locale);
@@ -11081,16 +11383,19 @@ function formatToolResultAsText(details) {
     lines.push("");
     let lastDate = "";
     for (const msg of messages) {
-      const spaceIdx = msg.indexOf(" ");
-      const secondSpaceIdx = msg.indexOf(" ", spaceIdx + 1);
+      const prefixMatch = /^(\[#[^\]]+\] )/.exec(msg);
+      const prefix = prefixMatch ? prefixMatch[1] : "";
+      const body = prefix ? msg.slice(prefix.length) : msg;
+      const spaceIdx = body.indexOf(" ");
+      const secondSpaceIdx = body.indexOf(" ", spaceIdx + 1);
       if (spaceIdx > 0 && secondSpaceIdx > 0) {
-        const date = msg.slice(0, spaceIdx);
-        const rest = msg.slice(spaceIdx + 1);
+        const date = body.slice(0, spaceIdx);
+        const rest = body.slice(spaceIdx + 1);
         if (date !== lastDate) {
           lines.push(`--- ${date} ---`);
           lastDate = date;
         }
-        lines.push(rest);
+        lines.push(prefix + rest);
       } else {
         lines.push(msg);
       }
@@ -11163,14 +11468,26 @@ function applyPreprocessingPipeline(options2) {
     maxToolResultTokens,
     truncationStrategy = "keep_last",
     extraDetails = {},
-    logger
+    logger,
+    includeMessageIds = false,
+    hitIds,
+    maxContentChars
   } = options2;
-  const processed = preprocessMessages(rawMessages, preprocessConfig, logger);
+  const { messages: processed, stats: preprocessStats } = preprocessMessagesWithStats(
+    rawMessages,
+    preprocessConfig,
+    logger
+  );
   let nameMapLine = "";
   if (anonymizeNames) {
     nameMapLine = anonymizeMessageNames(processed, ownerPlatformId);
   }
-  let formatted = processed.map((m) => formatMessageCompact(m, locale));
+  const formatOptions = includeMessageIds || maxContentChars != null ? {
+    includeMessageId: includeMessageIds,
+    hitIds: hitIds ? new Set(hitIds) : void 0,
+    maxContentLength: maxContentChars
+  } : void 0;
+  let formatted = processed.map((m) => formatMessageCompact(m, locale, formatOptions));
   let wasTruncated = false;
   const originalCount = formatted.length;
   if (maxToolResultTokens && maxToolResultTokens > 0) {
@@ -11190,7 +11507,12 @@ function applyPreprocessingPipeline(options2) {
   if (nameMapLine) {
     textContent = nameMapLine + "\n" + textContent;
   }
-  return { text: textContent, details: finalDetails };
+  const stats = {
+    ...preprocessStats,
+    renderedBlocks: formatted.length,
+    truncated: wasTruncated
+  };
+  return { text: textContent, details: finalDetails, stats };
 }
 
 // ../../packages/node-runtime/src/ai/agent/constants.ts
@@ -16731,6 +17053,7 @@ __export(relationships_exports, {
 // ../../packages/node-runtime/src/semantic-index/config.ts
 import fs30 from "fs";
 import path27 from "path";
+var DEFAULT_SEMANTIC_INDEX_MODEL_DOWNLOAD_SOURCE = "huggingface";
 var SEMANTIC_INDEX_CONFIG_VERSION = 1;
 var SEARCH_MAX_RESULTS_DEFAULT = 10;
 var SEARCH_MAX_RESULTS_MIN = 5;
@@ -16745,7 +17068,7 @@ function defaultSemanticIndexConfig() {
     version: SEMANTIC_INDEX_CONFIG_VERSION,
     enabled: true,
     mode: "local",
-    local: { modelId: "" },
+    local: { modelId: "", downloadSource: DEFAULT_SEMANTIC_INDEX_MODEL_DOWNLOAD_SOURCE },
     api: null,
     searchMaxResults: SEARCH_MAX_RESULTS_DEFAULT
   };
@@ -16790,7 +17113,10 @@ function normalizeConfig(raw) {
     // 旧配置无 enabled 字段时默认开启，保证既有用户功能不被意外关闭
     enabled: raw.enabled ?? true,
     mode,
-    local: { modelId: raw.local?.modelId ?? base.local.modelId },
+    local: {
+      modelId: raw.local?.modelId ?? base.local.modelId,
+      downloadSource: raw.local?.downloadSource === "hf-mirror" ? "hf-mirror" : DEFAULT_SEMANTIC_INDEX_MODEL_DOWNLOAD_SOURCE
+    },
     api,
     searchMaxResults: SEARCH_MAX_RESULTS_DEFAULT
   };
@@ -16840,7 +17166,7 @@ import path28 from "path";
 
 // ../../packages/node-runtime/src/semantic-index/chunker-config.ts
 import { createHash as createHash2 } from "crypto";
-var CHUNKER_VERSION = "v1.2";
+var CHUNKER_VERSION = "v1.3";
 var STRATEGY_ID = "balanced";
 var DEFAULT_CHUNKER_CONFIG = {
   parentGapSeconds: 1800,
@@ -16888,6 +17214,44 @@ function parseParentBounds(parentId) {
   return { startMessageId, endMessageId };
 }
 
+// ../../packages/node-runtime/src/semantic-index/tokens.ts
+import { Buffer as Buffer2 } from "buffer";
+var UTF8_BYTES_PER_ESTIMATED_TOKEN = 4;
+function isCjkCharacter(char) {
+  return /[\u3400-\u9fff\uf900-\ufaff]/u.test(char);
+}
+function estimateTokens2(text) {
+  let cjk = 0;
+  let other = 0;
+  for (const ch of text) {
+    if (isCjkCharacter(ch)) cjk++;
+    else other++;
+  }
+  return cjk + Math.ceil(other / 4);
+}
+function clampEstimatedTokens(text, maxTokens) {
+  const limit = Math.max(0, Math.floor(maxTokens));
+  if (limit === 0) return "";
+  const byteLimit = limit * UTF8_BYTES_PER_ESTIMATED_TOKEN;
+  if (estimateTokens2(text) <= limit && Buffer2.byteLength(text, "utf8") <= byteLimit) return text;
+  let cjk = 0;
+  let other = 0;
+  let bytes = 0;
+  let end = 0;
+  for (const char of text) {
+    const isCjk = isCjkCharacter(char);
+    const nextCjk = cjk + (isCjk ? 1 : 0);
+    const nextOther = other + (isCjk ? 0 : 1);
+    const nextBytes = bytes + Buffer2.byteLength(char, "utf8");
+    if (nextCjk + Math.ceil(nextOther / 4) > limit || nextBytes > byteLimit) break;
+    cjk = nextCjk;
+    other = nextOther;
+    bytes = nextBytes;
+    end += char.length;
+  }
+  return text.slice(0, end);
+}
+
 // ../../packages/node-runtime/src/semantic-index/embedding/api.ts
 var API_DOCUMENT_BATCH_SIZE = 8;
 var defaultFetchFn = (url, init) => fetch(url, init);
@@ -16927,7 +17291,19 @@ var OpenAICompatibleEmbeddingProvider = class {
     });
     if (!response.ok) {
       await response.text().catch(() => "");
-      throw new Error(`Embedding API request failed: ${response.status}`);
+      const estimatedTokens = texts.map(estimateTokens2);
+      const traceId = response.headers?.get("x-siliconcloud-trace-id")?.trim();
+      const diagnostics = [
+        `model=${this.config.model}`,
+        `batchSize=${texts.length}`,
+        `maxInputTokens=${Math.max(...estimatedTokens)}`,
+        `totalInputTokens=${estimatedTokens.reduce((sum, count) => sum + count, 0)}`,
+        `maxInputChars=${Math.max(...texts.map((text) => text.length))}`
+      ];
+      if (traceId) diagnostics.push(`traceId=${traceId}`);
+      const error = new Error(`Embedding API request failed: ${response.status} (${diagnostics.join(", ")})`);
+      appLogger.error("semantic-index", "embedding API request failed", error);
+      throw error;
     }
     const payload = await response.json();
     const sorted = [...payload.data].sort((a, b) => a.index - b.index);
@@ -16959,6 +17335,11 @@ function clampTextChars(text, maxChars) {
 // ../../packages/node-runtime/src/semantic-index/embedding/local.ts
 var SOCKS_PROXY_PROTOCOLS = /* @__PURE__ */ new Set(["socks:", "socks4:", "socks5:"]);
 var LOCAL_ONNX_SESSION_OPTIONS = { intraOpNumThreads: 1, interOpNumThreads: 1 };
+var HUGGING_FACE_MODEL_HOST = "https://huggingface.co/";
+var HF_MIRROR_MODEL_HOST = "https://hf-mirror.com/";
+function resolveModelDownloadRemoteHost(source) {
+  return source === "hf-mirror" ? HF_MIRROR_MODEL_HOST : HUGGING_FACE_MODEL_HOST;
+}
 async function createProxyFetch(proxyUrl) {
   const parsed = new URL(proxyUrl);
   if (SOCKS_PROXY_PROTOCOLS.has(parsed.protocol)) {
@@ -16973,8 +17354,15 @@ async function createProxyFetch(proxyUrl) {
     return undiciFetch(input, nextInit);
   });
 }
-var defaultPipelineFactory = async ({ modelId, dtype, cacheDir, modelDownloadProxyUrl }) => {
+var defaultPipelineFactory = async ({
+  modelId,
+  dtype,
+  cacheDir,
+  modelDownloadProxyUrl,
+  modelDownloadSource
+}) => {
   const transformers = await import("./transformers.node-PUMHAODN.mjs");
+  transformers.env.remoteHost = resolveModelDownloadRemoteHost(modelDownloadSource);
   if (cacheDir) {
     transformers.env.cacheDir = cacheDir;
     transformers.env.allowRemoteModels = true;
@@ -17015,6 +17403,7 @@ var LocalEmbeddingProvider = class {
         dtype: this.profile.dtype,
         cacheDir: this.options.cacheDir,
         modelDownloadProxyUrl: this.options.modelDownloadProxyUrl,
+        modelDownloadSource: this.options.modelDownloadSource,
         sessionOptions: LOCAL_ONNX_SESSION_OPTIONS
       }).catch((error) => {
         this.extractorPromise = null;
@@ -17108,6 +17497,7 @@ function createEmbedder(config, deps = {}) {
   return new LocalEmbeddingProvider(profile, {
     cacheDir: deps.modelsCacheDir,
     modelDownloadProxyUrl: deps.modelDownloadProxyUrl,
+    modelDownloadSource: config.local.downloadSource,
     pipelineFactory: deps.localPipelineFactory
   });
 }
@@ -17659,19 +18049,6 @@ var SemanticIndexJobQueue = class {
 
 // ../../packages/node-runtime/src/semantic-index/chunker.ts
 import { createHash as createHash3 } from "crypto";
-
-// ../../packages/node-runtime/src/semantic-index/tokens.ts
-function estimateTokens2(text) {
-  let cjk = 0;
-  let other = 0;
-  for (const ch of text) {
-    if (/[\u3400-\u9fff\uf900-\ufaff]/u.test(ch)) cjk++;
-    else other++;
-  }
-  return cjk + Math.ceil(other / 4);
-}
-
-// ../../packages/node-runtime/src/semantic-index/chunker.ts
 var VOID_MESSAGE_TYPES = /* @__PURE__ */ new Set([
   1 /* IMAGE */,
   2 /* VOICE */,
@@ -17756,6 +18133,9 @@ function sumEffectiveChars(messages) {
 function sha256Hex2(input) {
   return createHash3("sha256").update(input, "utf-8").digest("hex");
 }
+var EMBEDDING_HEADER_BUDGET_RATIO = 0.25;
+var SOURCE_TITLE_HEADER_SHARE = 1 / 3;
+var SENDER_NAMES_BODY_BUDGET_RATIO = 0.1;
 function pad2(n) {
   return String(n).padStart(2, "0");
 }
@@ -17773,23 +18153,51 @@ function formatTimeRange2(startTs, endTs) {
   const sameDay = start.getFullYear() === end.getFullYear() && start.getMonth() === end.getMonth() && start.getDate() === end.getDate();
   return `${formatDateTime(startTs)} - ${sameDay ? formatTime2(endTs) : formatDateTime(endTs)}`;
 }
-function buildEmbeddingInput(source, messages) {
+function resolveSenderNameTokenCap(nameTokenCounts, totalLimit) {
+  const total = nameTokenCounts.reduce((sum, count) => sum + count, 0);
+  if (total <= totalLimit) return null;
+  const sorted = [...nameTokenCounts].sort((a, b) => a - b);
+  let consumed = 0;
+  for (let i = 0; i < sorted.length; i++) {
+    const cap = Math.floor((totalLimit - consumed) / (sorted.length - i));
+    if (sorted[i] > cap) return cap;
+    consumed += sorted[i];
+  }
+  return null;
+}
+function buildEmbeddingInput(source, messages, maxTokens) {
+  const limit = Math.max(0, Math.floor(maxTokens));
+  if (limit === 0) return "";
   const effective = messages.filter((m) => !isSemanticVoid(m));
   const startTs = messages[0].ts;
   const endTs = messages[messages.length - 1].ts;
-  const lines = [];
+  const headerLimit = Math.max(1, Math.floor(limit * EMBEDDING_HEADER_BUDGET_RATIO));
+  const bodyFloor = Math.max(1, limit - headerLimit);
+  const sourceTitleLimit = Math.max(1, Math.floor(headerLimit * SOURCE_TITLE_HEADER_SHARE));
+  const senderNamesTotalLimit = Math.floor(bodyFloor * SENDER_NAMES_BODY_BUDGET_RATIO);
+  const bodySenderNameCap = resolveSenderNameTokenCap(
+    effective.map((m) => estimateTokens2(m.senderName)),
+    senderNamesTotalLimit
+  );
+  const clampHeaderSenderName = (name) => clampEstimatedTokens(name, sourceTitleLimit);
+  const clampBodySenderName = (name) => bodySenderNameCap === null ? name : clampEstimatedTokens(name, bodySenderNameCap);
+  const headerLines = [];
   const kindLabel = source.kind === "group" ? "\u7FA4\u804A" : "\u79C1\u804A";
-  lines.push(`[\u6765\u6E90] ${source.title}\uFF08${kindLabel}\uFF09`);
-  lines.push(`[\u65F6\u95F4\u8303\u56F4] ${formatTimeRange2(startTs, endTs)}`);
+  headerLines.push(`[\u6765\u6E90] ${clampEstimatedTokens(source.title, sourceTitleLimit)}\uFF08${kindLabel}\uFF09`);
+  headerLines.push(`[\u65F6\u95F4\u8303\u56F4] ${formatTimeRange2(startTs, endTs)}`);
   if (source.kind === "group") {
-    const participants = [...new Set(effective.map((m) => m.senderName))];
-    lines.push(`[\u53C2\u4E0E\u8005] ${participants.join("\u3001")}`);
-  }
-  lines.push("");
-  for (const m of effective) {
-    lines.push(`${m.senderName}: ${(m.content ?? "").trim()}`);
-  }
-  return lines.join("\n");
+    const participants = [...new Set(effective.map((m) => clampHeaderSenderName(m.senderName)))];
+    headerLines.push(`[\u53C2\u4E0E\u8005] ${participants.join("\u3001")}`);
+  }
+  const header = clampEstimatedTokens(headerLines.join("\n"), headerLimit);
+  const separator = "\n\n";
+  const remaining = Math.max(0, limit - estimateTokens2(header) - estimateTokens2(separator));
+  const body = clampEstimatedTokens(
+    effective.map((m) => `${clampBodySenderName(m.senderName)}: ${(m.content ?? "").trim()}`).join("\n"),
+    remaining
+  );
+  const combined = body ? `${header}${separator}${body}` : header;
+  return clampEstimatedTokens(combined, limit);
 }
 function rawContentHashOf(messages) {
   return sha256Hex2(messages.map((m) => `${m.id}:${m.content ?? ""}`).join("\n"));
@@ -17864,7 +18272,7 @@ function chunkMessages(input) {
       }
       const startMessageId = draft[0].id;
       const endMessageId = draft[draft.length - 1].id;
-      const embeddingInput = buildEmbeddingInput(input.source, draft);
+      const embeddingInput = buildEmbeddingInput(input.source, draft, config.childHardMaxTokens);
       chunks.push({
         localChunkId: `${parentId}#${startMessageId}-${endMessageId}`,
         parentId,
@@ -18312,6 +18720,7 @@ var SemanticIndexService = class {
   embedder = null;
   embedderModelId = null;
   modelPreloadStatus = "idle";
+  modelPreloadGeneration = 0;
   /** 当前激活的 chunker 身份（version + 参数 hash），随索引记录用于重建判定 */
   chunkerVersion = CHUNKER_VERSION;
   chunkerConfigHash = computeChunkerConfigHash(DEFAULT_CHUNKER_CONFIG);
@@ -18360,6 +18769,7 @@ var SemanticIndexService = class {
       apiKey: options2?.apiKey,
       writeAuthProfile: this.options.writeAuthProfile
     });
+    const preloadGeneration = ++this.modelPreloadGeneration;
     this.embedder = null;
     this.embedderModelId = null;
     this.modelPreloadStatus = "idle";
@@ -18368,15 +18778,26 @@ var SemanticIndexService = class {
     }
     if (saved.enabled && isSemanticIndexConfigured(saved) && saved.mode === "local") {
       const modelId = saved.local.modelId;
+      const downloadSource = saved.local.downloadSource ?? DEFAULT_SEMANTIC_INDEX_MODEL_DOWNLOAD_SOURCE;
       const cacheDir = this.options.modelsCacheDir;
       this.modelPreloadStatus = "downloading";
-      appLogger.info("semantic-index", "local embedding model preload started", { modelId, cacheDir });
+      appLogger.info("semantic-index", "local embedding model preload started", { modelId, downloadSource, cacheDir });
       void this.getEmbedder().preload?.().then(() => {
+        if (preloadGeneration !== this.modelPreloadGeneration) return;
         this.modelPreloadStatus = "ready";
-        appLogger.info("semantic-index", "local embedding model preload completed", { modelId, cacheDir });
+        appLogger.info("semantic-index", "local embedding model preload completed", {
+          modelId,
+          downloadSource,
+          cacheDir
+        });
       }).catch((error) => {
+        if (preloadGeneration !== this.modelPreloadGeneration) return;
         this.modelPreloadStatus = "error";
-        appLogger.error("semantic-index", `local embedding model preload failed: ${modelId}`, error);
+        appLogger.error(
+          "semantic-index",
+          `local embedding model preload failed: ${modelId} via ${downloadSource}`,
+          error
+        );
       });
     }
     return saved;
@@ -18805,7 +19226,9 @@ ${text}`;
       checkStop
     });
     const currentConfig = this.configStore.get();
-    if (result.status === "completed" && result.chunksWritten > 0 && jobConfig.mode === "local" && currentConfig.mode === "local" && currentConfig.local.modelId === jobConfig.local.modelId) {
+    const jobDownloadSource = jobConfig.mode === "local" ? jobConfig.local.downloadSource ?? DEFAULT_SEMANTIC_INDEX_MODEL_DOWNLOAD_SOURCE : null;
+    const currentDownloadSource = currentConfig.mode === "local" ? currentConfig.local.downloadSource ?? DEFAULT_SEMANTIC_INDEX_MODEL_DOWNLOAD_SOURCE : null;
+    if (result.status === "completed" && result.chunksWritten > 0 && jobConfig.mode === "local" && currentConfig.mode === "local" && currentConfig.local.modelId === jobConfig.local.modelId && currentDownloadSource === jobDownloadSource) {
       this.modelPreloadStatus = "ready";
     }
     appLogger.info("semantic-index", "warmup job finished", {
@@ -19245,6 +19668,13 @@ async function pushImport(dbManager, sessionId, payload) {
 
 export {
   writeParseResultToDb,
+  detectFormat,
+  detectAllFormats,
+  getSupportedFormats,
+  getFormatFeatureById,
+  scanMultiChatFile,
+  findEntryFileInDirectory,
+  logNativeParserStatus,
   LogLevel,
   initPerfLog,
   logPerf,
@@ -19255,12 +19685,6 @@ export {
   logInfo,
   getErrorCount,
   logSummary,
-  detectFormat,
-  detectAllFormats,
-  getSupportedFormats,
-  getFormatFeatureById,
-  scanMultiChatFile,
-  findEntryFileInDirectory,
   computeWordFrequency,
   segmentText,
   isDictDownloaded,
@@ -19316,6 +19740,9 @@ export {
   manualCompress,
   createCompressionLlmAdapter,
   preprocessMessages,
+  preprocessMessagesWithStats,
+  desensitizeText,
+  matchesBlacklist,
   DESENSITIZE_RULES_SCHEMA_VERSION,
   BUILTIN_DESENSITIZE_RULES,
   getDefaultRulesForLocale,
@@ -19399,6 +19826,7 @@ export {
   deriveParentId,
   parseParentBounds,
   estimateTokens2 as estimateTokens,
+  DEFAULT_SEMANTIC_INDEX_MODEL_DOWNLOAD_SOURCE,
   SEMANTIC_INDEX_CONFIG_VERSION,
   SEARCH_MAX_RESULTS_DEFAULT,
   SEARCH_MAX_RESULTS_MIN,
@@ -19440,4 +19868,4 @@ export {
   MergeSessionCache,
   pushImport
 };
-//# sourceMappingURL=chunk-QQK7MLCR.mjs.map
+//# sourceMappingURL=chunk-36JGKW6K.mjs.map