chatlab-cli 0.34.0 → 0.34.2

package/dist/{chunk-AQPDZAWB.mjs → chunk-4LW6443F.mjs}

@@ -9,7 +9,7 @@ import {
   createEmptyContactsDiagnostics,
   normalizeContactsTimeRangePreset,
   resolveContactsTimeRange
-} from "./chunk-IGEHMLHM.mjs";
+} from "./chunk-52P5ZRBD.mjs";
 import {
   PEOPLE_RELATIONSHIPS_ALGORITHM_VERSION,
   buildPeopleRelationshipsNeighborhoodGraph,
@@ -18,7 +18,7 @@ import {
   computePeopleRelationshipsSnapshot,
   normalizePeopleRelationshipsTimeRangePreset,
   resolvePeopleRelationshipsTimeRange
-} from "./chunk-JTOHAMIW.mjs";
+} from "./chunk-652KEAX3.mjs";
 import {
   ANNUAL_SUMMARY_ALGORITHM_VERSION
 } from "./chunk-QZCNVAH6.mjs";
@@ -90,6 +90,7 @@ import {
   needsStreamingThinkParsing,
   normalizeAnnualSummaryRange,
   normalizeBuiltinToolNames,
+  normalizeSessionGapThreshold,
   openBetterSqliteDatabase,
   readAnnualSummarySnapshot,
   readJsonFile,
@@ -110,13 +111,13 @@ import {
   writeAuthProfile,
   writeJsonFileAtomically,
   writeParseResultToDb
-} from "./chunk-OLE2USEN.mjs";
+} from "./chunk-INBJ7SND.mjs";
 import {
   __commonJS,
   __export,
   __require,
   __toESM
-} from "./chunk-GFHSSCCR.mjs";
+} from "./chunk-VSOWNKPA.mjs";
 
 // ../../node_modules/stream-json/utils/Utf8Stream.js
 var require_Utf8Stream = __commonJS({
@@ -726,8 +727,8 @@ var require_FilterBase = __commonJS({
     var FilterBase = class _FilterBase extends Transform {
       static stringFilter(string, separator) {
         return (stack) => {
-          const path30 = stack.join(separator);
-          return path30.length === string.length && path30 === string || path30.length > string.length && path30.substr(0, string.length) === string && path30.substr(string.length, separator.length) === separator;
+          const path31 = stack.join(separator);
+          return path31.length === string.length && path31 === string || path31.length > string.length && path31.substr(0, string.length) === string && path31.substr(string.length, separator.length) === separator;
         };
       }
       static regExpFilter(regExp, separator) {
@@ -1181,12 +1182,12 @@ var require_Assembler = __commonJS({
         return (this.stack.length >> 1) + (this.done ? 0 : 1);
       }
       get path() {
-        const path30 = [];
+        const path31 = [];
         for (let i = 0; i < this.stack.length; i += 2) {
           const key = this.stack[i + 1];
-          path30.push(key === null ? this.stack[i].length : key);
+          path31.push(key === null ? this.stack[i].length : key);
         }
-        return path30;
+        return path31;
       }
       dropToLevel(level) {
         if (level < this.depth) {
@@ -1468,7 +1469,7 @@ var require_pend = __commonJS({
 var require_fd_slicer = __commonJS({
   "../../packages/node-runtime/node_modules/yauzl/fd-slicer.js"(exports) {
     "use strict";
-    var fs36 = __require("fs");
+    var fs37 = __require("fs");
     var util = __require("util");
     var stream = __require("stream");
     var Readable = stream.Readable;
@@ -1488,7 +1489,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs36.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+        fs37.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
           cb();
           callback(err, bytesRead, buffer2);
         });
@@ -1505,7 +1506,7 @@ var require_fd_slicer = __commonJS({
       self.refCount -= 1;
       if (self.refCount < 0) throw new Error("invalid unref");
       if (self.refCount > 0) return;
-      fs36.close(self.fd, onCloseDone);
+      fs37.close(self.fd, onCloseDone);
       function onCloseDone(err) {
         if (err) {
           self.emit("error", err);
@@ -1537,7 +1538,7 @@ var require_fd_slicer = __commonJS({
       }
       self.context.pend.go(function(cb) {
         var buffer = Buffer.allocUnsafe(toRead);
-        fs36.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
+        fs37.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
           if (err) {
             self.destroy(err);
           } else if (bytesRead === 0) {
@@ -1899,7 +1900,7 @@ var require_crc32 = __commonJS({
 var require_yauzl = __commonJS({
   "../../packages/node-runtime/node_modules/yauzl/index.js"(exports) {
     "use strict";
-    var fs36 = __require("fs");
+    var fs37 = __require("fs");
     var zlib = __require("zlib");
     var fd_slicer = require_fd_slicer();
     var util = __require("util");
@@ -1924,9 +1925,9 @@ var require_yauzl = __commonJS({
     exports.Entry = Entry;
     exports.LocalFileHeader = LocalFileHeader;
     exports.RandomAccessReader = RandomAccessReader;
-    function openPromise2(path30, options2) {
+    function openPromise2(path31, options2) {
       return new Promise((resolve4, reject) => {
-        open(path30, { ...options2, lazyEntries: true }, function(err, zipfile) {
+        open(path31, { ...options2, lazyEntries: true }, function(err, zipfile) {
           if (err) return reject(err);
           resolve4(zipfile);
         });
@@ -1956,7 +1957,7 @@ var require_yauzl = __commonJS({
         });
       });
     }
-    function open(path30, options2, callback) {
+    function open(path31, options2, callback) {
       if (typeof options2 === "function") {
         callback = options2;
         options2 = null;
@@ -1968,10 +1969,10 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs36.open(path30, "r", function(err, fd) {
+      fs37.open(path31, "r", function(err, fd) {
         if (err) return callback(err);
         fromFd(fd, options2, function(err2, zipfile) {
-          if (err2) fs36.close(fd, defaultCallback);
+          if (err2) fs37.close(fd, defaultCallback);
           callback(err2, zipfile);
         });
       });
@@ -1988,7 +1989,7 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs36.fstat(fd, function(err, stats) {
+      fs37.fstat(fd, function(err, stats) {
         if (err) return callback(err);
         var reader = new fd_slicer.FdSlicer(fd);
         fromRandomAccessReader(reader, stats.size, options2, callback);
@@ -2767,9 +2768,9 @@ function optionsEnv(options2) {
 function resolveChatLabTempRoot(options2 = {}) {
   const envRoot = optionsEnv(options2)[CHATLAB_TEMP_ROOT_ENV]?.trim();
   if (envRoot) return path.resolve(envRoot);
-  const platform2 = options2.platform ?? process.platform;
+  const platform = options2.platform ?? process.platform;
   const systemTempDir = options2.systemTempDir ?? os.tmpdir();
-  return path.resolve(platform2 === "darwin" ? "/private/tmp/chatlab" : path.join(systemTempDir, "chatlab"));
+  return path.resolve(platform === "darwin" ? "/private/tmp/chatlab" : path.join(systemTempDir, "chatlab"));
 }
 function ensurePrivateOwnedDirectory(dirPath, label) {
   fs.mkdirSync(dirPath, { recursive: true, mode: 448 });
@@ -2847,6 +2848,14 @@ function matchFilenameSignatures(filePath, patterns) {
   const filename = path2.basename(filePath);
   return patterns.some((pattern) => pattern.test(filename));
 }
+function matchFilenameFallbackPatterns(filePath, patterns) {
+  try {
+    const content = fs2.readFileSync(filePath, "utf-8");
+    return patterns.every((pattern) => pattern.test(content));
+  } catch {
+    return false;
+  }
+}
 function matchRequiredFields(headContent, fields) {
   return fields.every((field) => {
     const pattern = new RegExp(`"${field.replace(".", '"\\s*:\\s*.*"')}"\\s*:`);
@@ -2968,6 +2977,11 @@ var FormatSniffer = class {
         return false;
       }
     }
+    if (!headMatch && filenameMatch && signatures.filenameFallbackPatterns) {
+      if (!filePath || !matchFilenameFallbackPatterns(filePath, signatures.filenameFallbackPatterns)) {
+        return false;
+      }
+    }
     if (signatures.requiredFields && signatures.requiredFields.length > 0) {
       if (!matchRequiredFields(headContent, signatures.requiredFields)) {
         return false;
@@ -3069,10 +3083,20 @@ function getNativeParserStatus() {
   const module = loadNativeParser();
   return { available: module !== null, disabled: false, error: module ? void 0 : cachedLoadError };
 }
+function isNativeFormatAvailable(formatId) {
+  const module = loadNativeParser();
+  if (!module) return false;
+  try {
+    new module.NativeParser(formatId, "");
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // ../../packages/parser/src/native/create-native-parser.ts
 var PROGRESS_POLL_INTERVAL_MS = 200;
-async function* pumpNativeParser(adapter, options2, parser11, fallback) {
+async function* pumpNativeParser(adapter, options2, parser11, fallbackAfterNativeFailure2) {
   const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const totalBytes = getFileSize(filePath);
   const initialProgress = createProgress("parsing", 0, totalBytes, 0, "");
@@ -3101,7 +3125,7 @@ async function* pumpNativeParser(adapter, options2, parser11, fallback) {
       "warn",
       `[NativeParser] Rust parse failed, falling back to TS parser: ${error instanceof Error ? error.message : String(error)}`
     );
-    yield* fallback(options2);
+    yield* fallbackAfterNativeFailure2(options2);
     return;
   } finally {
     clearInterval(progressTimer);
@@ -3122,9 +3146,12 @@ async function* pumpNativeParser(adapter, options2, parser11, fallback) {
   yield { type: "progress", data: doneProgress };
   onProgress?.(doneProgress);
   onLog?.("info", `\u89E3\u6790\u5B8C\u6210: ${messagesProcessed} \u6761\u6D88\u606F, ${members.length} \u4E2A\u6210\u5458`);
+  for (const message of adapter.completionLogs?.(metaJson) ?? []) {
+    onLog?.("info", message);
+  }
   yield { type: "done", data: { messageCount: messagesProcessed, memberCount: members.length } };
 }
-function createNativeFirstParser(adapter, fallback) {
+function createNativeFirstParser(adapter, fallback, fallbackAfterNativeFailure2 = fallback) {
   return async function* (options2) {
     const native = loadNativeParser();
     if (!native) {
@@ -3146,7 +3173,7 @@ function createNativeFirstParser(adapter, fallback) {
       yield* fallback(options2);
       return;
     }
-    yield* pumpNativeParser(adapter, options2, parser11, fallback);
+    yield* pumpNativeParser(adapter, options2, parser11, fallbackAfterNativeFailure2);
   };
 }
 
@@ -3662,6 +3689,12 @@ function slimMessage(msg) {
       type: e.type
     }));
   }
+  if (content?.reply && typeof content.reply === "object") {
+    const reply = content.reply;
+    if (reply.referencedMessageId !== void 0) {
+      slimContent.reply = { referencedMessageId: reply.referencedMessageId };
+    }
+  }
   const slimMsg = {
     timestamp: msg.timestamp,
     sender: { name: sender?.name || "" },
@@ -3669,12 +3702,12 @@ function slimMessage(msg) {
   };
   if (msg.id) slimMsg.id = msg.id;
   if (msg.type) slimMsg.type = msg.type;
-  if (msg.recalled) slimMsg.recalled = msg.recalled;
-  if (msg.system) slimMsg.system = msg.system;
-  if (msg.messageId) slimMsg.messageId = msg.messageId;
+  if (msg.recalled !== void 0) slimMsg.recalled = msg.recalled;
+  if (msg.system !== void 0) slimMsg.system = msg.system;
+  if (msg.messageId !== void 0) slimMsg.messageId = msg.messageId;
   if (msg.messageType !== void 0) slimMsg.messageType = msg.messageType;
-  if (msg.isRecalled) slimMsg.isRecalled = msg.isRecalled;
-  if (msg.isSystemMessage) slimMsg.isSystemMessage = msg.isSystemMessage;
+  if (msg.isRecalled !== void 0) slimMsg.isRecalled = msg.isRecalled;
+  if (msg.isSystemMessage !== void 0) slimMsg.isSystemMessage = msg.isSystemMessage;
   if (sender?.uin) slimMsg.sender.uin = sender.uin;
   if (sender?.uid) slimMsg.sender.uid = sender.uid;
   if (rawMessage) {
@@ -3686,7 +3719,7 @@ function slimMessage(msg) {
   }
   return slimMsg;
 }
-async function preprocessQQJson(inputPath, onProgress) {
+async function preprocessShuakamiQqJson(inputPath, onProgress) {
   const totalBytes = getFileSize(inputPath);
   let bytesRead = 0;
   let messagesProcessed = 0;
@@ -3696,101 +3729,82 @@ async function preprocessQQJson(inputPath, onProgress) {
   const outputPath = path5.join(tempDir, outputFilename);
   onProgress?.(createProgress("parsing", 0, totalBytes, 0, ""));
   const avatarsStr = readAvatarsFromFile(inputPath);
+  const headContent = readFileHeadBytes(inputPath, 5e5);
+  let chatInfo = { name: "\u672A\u77E5\u7FA4\u804A", type: "group" };
+  let metadata;
+  let statistics;
+  try {
+    const chatInfoJson = extractJsonObject(headContent, "chatInfo");
+    if (chatInfoJson) chatInfo = JSON.parse(chatInfoJson);
+  } catch {
+  }
+  if (!chatInfo.name) {
+    chatInfo.name = path5.basename(inputPath).replace(/\.json$/i, "") || "\u672A\u77E5\u7FA4\u804A";
+  }
+  try {
+    const metadataMatch = headContent.match(/"metadata"\s*:\s*(\{[^}]+\})/);
+    if (metadataMatch) metadata = JSON.parse(metadataMatch[1]);
+  } catch {
+  }
+  try {
+    const statisticsMatch = headContent.match(/"statistics"\s*:\s*(\{[\s\S]*?\})\s*,\s*"messages"/);
+    if (statisticsMatch) statistics = JSON.parse(statisticsMatch[1]);
+  } catch {
+  }
   return new Promise((resolve4, reject) => {
-    const headChunks = [];
-    let headSize = 0;
-    const maxHeadSize = 1e5;
-    const headStream = fs6.createReadStream(inputPath, { encoding: "utf-8" });
-    let chatInfo = { name: "\u672A\u77E5\u7FA4\u804A", type: "group" };
-    let metadata;
-    let statistics;
-    headStream.on("data", (chunk) => {
-      const str = typeof chunk === "string" ? chunk : chunk.toString("utf-8");
-      if (headSize < maxHeadSize) {
-        headChunks.push(str);
-        headSize += str.length;
-      } else {
-        headStream.destroy();
-      }
+    onProgress?.(createProgress("parsing", 0, totalBytes, 0, ""));
+    const readStream = fs6.createReadStream(inputPath, { encoding: "utf-8" });
+    const writeStream = fs6.createWriteStream(outputPath, { encoding: "utf-8" });
+    readStream.on("data", (chunk) => {
+      bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
-    headStream.on("close", () => {
-      const headContent = headChunks.join("");
-      try {
-        const chatInfoMatch = headContent.match(/"chatInfo"\s*:\s*(\{[^}]+\})/);
-        if (chatInfoMatch) {
-          chatInfo = JSON.parse(chatInfoMatch[1]);
-        }
-      } catch {
-      }
-      try {
-        const metadataMatch = headContent.match(/"metadata"\s*:\s*(\{[^}]+\})/);
-        if (metadataMatch) {
-          metadata = JSON.parse(metadataMatch[1]);
-        }
-      } catch {
+    const header = { metadata, chatInfo, statistics, messages: [] };
+    const headerJson = JSON.stringify(header);
+    writeStream.write(headerJson.slice(0, -2) + "\n");
+    let isFirstMessage = true;
+    const pipeline2 = chain2([readStream, parser3(), pick2({ filter: /^messages\.\d+$/ }), streamValues2()]);
+    pipeline2.on("data", ({ value }) => {
+      const slimMsg = slimMessage(value);
+      const msgJson = JSON.stringify(slimMsg);
+      if (isFirstMessage) {
+        writeStream.write(msgJson);
+        isFirstMessage = false;
+      } else {
+        writeStream.write(",\n" + msgJson);
       }
-      try {
-        const statisticsMatch = headContent.match(/"statistics"\s*:\s*(\{[\s\S]*?\})\s*,\s*"messages"/);
-        if (statisticsMatch) {
-          statistics = JSON.parse(statisticsMatch[1]);
-        }
-      } catch {
+      messagesProcessed++;
+      if (messagesProcessed % 1e4 === 0) {
+        onProgress?.(
+          createProgress(
+            "parsing",
+            bytesRead,
+            totalBytes,
+            messagesProcessed,
+            `\u9884\u5904\u7406\uFF1A\u5DF2\u7CBE\u7B80 ${messagesProcessed} \u6761\u6D88\u606F...`
+          )
+        );
       }
-      onProgress?.(createProgress("parsing", 0, totalBytes, 0, ""));
-      const readStream = fs6.createReadStream(inputPath, { encoding: "utf-8" });
-      const writeStream = fs6.createWriteStream(outputPath, { encoding: "utf-8" });
-      readStream.on("data", (chunk) => {
-        bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
-      });
-      const header = { metadata, chatInfo, statistics, messages: [] };
-      const headerJson = JSON.stringify(header);
-      writeStream.write(headerJson.slice(0, -2) + "\n");
-      let isFirstMessage = true;
-      const pipeline2 = chain2([readStream, parser3(), pick2({ filter: /^messages\.\d+$/ }), streamValues2()]);
-      pipeline2.on("data", ({ value }) => {
-        const slimMsg = slimMessage(value);
-        const msgJson = JSON.stringify(slimMsg);
-        if (isFirstMessage) {
-          writeStream.write(msgJson);
-          isFirstMessage = false;
-        } else {
-          writeStream.write(",\n" + msgJson);
-        }
-        messagesProcessed++;
-        if (messagesProcessed % 1e4 === 0) {
-          onProgress?.(
-            createProgress(
-              "parsing",
-              bytesRead,
-              totalBytes,
-              messagesProcessed,
-              `\u9884\u5904\u7406\uFF1A\u5DF2\u7CBE\u7B80 ${messagesProcessed} \u6761\u6D88\u606F...`
-            )
-          );
-        }
-      });
-      pipeline2.on("end", () => {
-        writeStream.write("\n]");
-        if (avatarsStr) {
-          writeStream.write(',"avatars":' + avatarsStr);
-        }
-        writeStream.write("}");
-        writeStream.end();
-        writeStream.on("finish", () => {
-          onProgress?.(createProgress("done", totalBytes, totalBytes, messagesProcessed, ""));
-          resolve4(outputPath);
-        });
-      });
-      pipeline2.on("error", (err) => {
-        writeStream.destroy();
-        if (fs6.existsSync(outputPath)) {
-          fs6.unlinkSync(outputPath);
-        }
-        onProgress?.(createProgress("error", bytesRead, totalBytes, messagesProcessed, err.message));
-        reject(err);
+    });
+    pipeline2.on("end", () => {
+      writeStream.write("\n]");
+      if (avatarsStr) {
+        writeStream.write(',"avatars":' + avatarsStr);
+      }
+      writeStream.write("}");
+      writeStream.end();
+      writeStream.on("finish", () => {
+        onProgress?.(createProgress("done", totalBytes, totalBytes, messagesProcessed, ""));
+        resolve4(outputPath);
       });
     });
-    headStream.on("error", reject);
+    pipeline2.on("error", (err) => {
+      writeStream.destroy();
+      if (fs6.existsSync(outputPath)) {
+        fs6.unlinkSync(outputPath);
+      }
+      onProgress?.(createProgress("error", bytesRead, totalBytes, messagesProcessed, err.message));
+      reject(err);
+    });
   });
 }
 function cleanupTempFile(filePath) {
@@ -3801,14 +3815,85 @@ function cleanupTempFile(filePath) {
   } catch {
   }
 }
-var qqPreprocessor = {
+var shuakamiQqPreprocessor = {
   needsPreprocess(_filePath, fileSize) {
     return fileSize > PREPROCESS_THRESHOLD;
   },
-  preprocess: preprocessQQJson,
+  preprocess: preprocessShuakamiQqJson,
   cleanup: cleanupTempFile
 };
 
+// ../../packages/parser/src/native/shuakami-qq-native.ts
+var shuakamiQqAdapter = {
+  formatId: "shuakami-qq-exporter",
+  label: "shuakami/qq-chat-exporter",
+  mapMeta(metaJson) {
+    const meta = metaJson;
+    return {
+      name: meta.name,
+      platform: KNOWN_PLATFORMS.QQ,
+      type: meta.chatType === "private" ? "private" /* PRIVATE */ : "group" /* GROUP */,
+      groupAvatar: meta.groupAvatar ?? void 0
+    };
+  },
+  mapMembers(members) {
+    return members.map((member) => ({
+      platformId: member.platformId,
+      accountName: member.accountName,
+      groupNickname: member.groupNickname,
+      avatar: member.avatar
+    }));
+  },
+  mapMessage(message) {
+    return {
+      platformMessageId: message.platformMessageId,
+      senderPlatformId: message.senderPlatformId,
+      senderAccountName: message.senderAccountName,
+      senderGroupNickname: message.senderGroupNickname,
+      timestamp: message.timestamp,
+      type: message.messageType,
+      content: message.content ?? null,
+      replyToMessageId: message.replyToMessageId
+    };
+  },
+  completionLogs(metaJson) {
+    const skipped = metaJson.skippedMessages;
+    return skipped > 0 ? [
+      `[NativeParser] Skipped ${skipped} shuakami/qq-chat-exporter messages with a missing sender ID or invalid timestamp`
+    ] : [];
+  }
+};
+async function* fallbackAfterNativeFailure(fallback, options2) {
+  if (!shuakamiQqPreprocessor.needsPreprocess(options2.filePath, getFileSize(options2.filePath))) {
+    yield* fallback(options2);
+    return;
+  }
+  let slimFilePath = null;
+  try {
+    options2.onLog?.("info", "[NativeParser] Preprocessing large export before TypeScript fallback");
+    slimFilePath = await shuakamiQqPreprocessor.preprocess(options2.filePath, options2.onProgress);
+  } catch (error) {
+    options2.onLog?.(
+      "warn",
+      `[NativeParser] Fallback preprocessing failed; retrying the original export: ${error instanceof Error ? error.message : String(error)}`
+    );
+    yield* fallback(options2);
+    return;
+  }
+  try {
+    yield* fallback({ ...options2, filePath: slimFilePath });
+  } finally {
+    if (slimFilePath) shuakamiQqPreprocessor.cleanup(slimFilePath);
+  }
+}
+function withShuakamiQqNative(fallback) {
+  return createNativeFirstParser(
+    shuakamiQqAdapter,
+    fallback,
+    (options2) => fallbackAfterNativeFailure(fallback, options2)
+  );
+}
+
 // ../../packages/parser/src/formats/shuakami-qq-exporter.ts
 var { parser: parser4 } = import_stream_json3.default;
 var { pick: pick3 } = import_Pick3.default;
@@ -3930,7 +4015,7 @@ function convertMessageType(messageType, content, isRecalled) {
   if (messageType === 9) return 25 /* REPLY */;
   return 0 /* TEXT */;
 }
-async function* parseV4(options2) {
+async function* parseShuakamiQqV4(options2) {
   const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const totalBytes = getFileSize(filePath);
   let bytesRead = 0;
@@ -3939,7 +4024,7 @@ async function* parseV4(options2) {
   const initialProgress = createProgress("parsing", 0, totalBytes, 0, "");
   yield { type: "progress", data: initialProgress };
   onProgress?.(initialProgress);
-  onLog?.("info", `\u5F00\u59CB\u89E3\u6790 QQ Chat Exporter \u6587\u4EF6\uFF0C\u5927\u5C0F: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`);
+  onLog?.("info", `\u5F00\u59CB\u89E3\u6790 shuakami/qq-chat-exporter \u6587\u4EF6\uFF0C\u5927\u5C0F: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`);
   const headContent = readFileHeadBytes(filePath, 5e5);
   let chatInfo = { name: "\u672A\u77E5\u7FA4\u804A", type: "group" };
   try {
@@ -4066,14 +4151,15 @@ async function* parseV4(options2) {
     data: { messageCount: messagesProcessed, memberCount: memberMap.size }
   };
 }
+var parseShuakamiQqV4Accelerated = withShuakamiQqNative(parseShuakamiQqV4);
 var parser_2 = {
   feature: feature3,
-  parse: parseV4
+  parse: parseShuakamiQqV4Accelerated
 };
 var module_3 = {
   feature: feature3,
   parser: parser_2,
-  preprocessor: qqPreprocessor
+  preprocessor: shuakamiQqPreprocessor
 };
 var shuakami_qq_exporter_default = module_3;
 
@@ -4089,8 +4175,10 @@ var feature4 = {
   // 比单文件版本优先级更高
   extensions: [".json"],
   signatures: {
-    // 使用 head 签名 "format": "chunked-jsonl" 来区分。
-    head: [/"format"\s*:\s*"chunked-jsonl"/],
+    // V5 使用 metadata.format，0.1.x 将格式标识移至 chunked.format。
+    head: [/"format"\s*:\s*"chunked-jsonl"/, /"chunked"\s*:\s*\{[^{}]*"format"\s*:\s*"jsonl"/],
+    filename: [/^manifest\.json$/i],
+    filenameFallbackPatterns: [/"chunked"\s*:\s*\{[\s\S]*?"format"\s*:\s*"jsonl"/],
     requiredFields: ["metadata", "chatInfo"]
   }
 };
@@ -4221,9 +4309,10 @@ async function* parseChunkedJsonl(options2) {
     yield { type: "error", data: new Error(`\u65E0\u6CD5\u8BFB\u53D6 manifest.json: ${errorMsg}`) };
     return;
   }
-  if (manifest.metadata.format !== "chunked-jsonl") {
-    onLog?.("error", `\u4E0D\u652F\u6301\u7684\u683C\u5F0F: ${manifest.metadata.format}`);
-    yield { type: "error", data: new Error(`\u4E0D\u652F\u6301\u7684\u683C\u5F0F: ${manifest.metadata.format}`) };
+  if (manifest.metadata.format !== "chunked-jsonl" && manifest.chunked.format !== "jsonl") {
+    const format = manifest.metadata.format ?? manifest.chunked.format ?? "unknown";
+    onLog?.("error", `\u4E0D\u652F\u6301\u7684\u683C\u5F0F: ${format}`);
+    yield { type: "error", data: new Error(`\u4E0D\u652F\u6301\u7684\u683C\u5F0F: ${format}`) };
     return;
   }
   const totalBytes = calculateTotalBytes(manifest, baseDir);
@@ -5579,6 +5668,12 @@ var SYSTEM_MESSAGE_PATTERNS = [
   /This message was deleted/i,
   /disappearing messages/i
 ];
+var SYSTEM_MESSAGE_REGEX = new RegExp(SYSTEM_MESSAGE_PATTERNS.map((pattern) => pattern.source).join("|"), "i");
+var TIMESTAMP_SPACING = String.raw`(?:\s|\u2009|\u202F|\uFEFF|\u200E|\u200F|\u200B|\u200C|\u200D|\u2060)`;
+var COMMON_TIMESTAMP_REGEX = new RegExp(
+  String.raw`^${TIMESTAMP_SPACING}*(\d{1,4})\/(\d{1,2})\/(\d{1,4})(?:,|${TIMESTAMP_SPACING})+(\d{1,2}):(\d{2})(?::(\d{2}))?(?:${TIMESTAMP_SPACING}+(AM|PM|A\.M\.|P\.M\.|上午|下午|午前|午後|오전|오후))?${TIMESTAMP_SPACING}*$`,
+  "i"
+);
 var AMPM_MARKERS = [
   [/\bPM\b/i, true],
   [/\bP\.M\.(?!\w)/i, true],
@@ -5651,7 +5746,7 @@ var WhatsAppTextAccumulator = class {
       senderPlatformId,
       senderAccountName: senderName,
       timestamp: this.currentMessage.timestamp,
-      type: detectMessageType2(content),
+      type: detectMessageType2(content, this.currentMessage.isSystem),
       content: content || null
     });
     if (this.currentMessage.sender) {
@@ -5662,10 +5757,11 @@ var WhatsAppTextAccumulator = class {
 };
 function createPendingMessage(timestamp, restContent) {
   const senderMatch = restContent.match(SENDER_CONTENT_REGEX);
-  if (senderMatch && !isSystemMessage(restContent)) {
-    return { timestamp, sender: senderMatch[1].trim(), contentLines: [senderMatch[2]] };
+  const isSystem = isSystemMessage(restContent);
+  if (senderMatch && !isSystem) {
+    return { timestamp, sender: senderMatch[1].trim(), contentLines: [senderMatch[2]], isSystem };
   }
-  return { timestamp, sender: null, contentLines: [restContent] };
+  return { timestamp, sender: null, contentLines: [restContent], isSystem };
 }
 function extractNameFromFileName(fileName) {
   const basename10 = getBasename(fileName);
@@ -5689,9 +5785,9 @@ function cleanLine(line) {
   return line.replace(/^(?:\uFEFF|\u200E|\u200F|\u200B|\u200C|\u200D|\u2060)+/, "").trim();
 }
 function isSystemMessage(content) {
-  return SYSTEM_MESSAGE_PATTERNS.some((pattern) => pattern.test(content));
+  return SYSTEM_MESSAGE_REGEX.test(content);
 }
-function detectMessageType2(content) {
+function detectMessageType2(content, knownSystem = false) {
   const trimmed = content.trim();
   if (trimmed === "<\u7701\u7565\u5F71\u97F3\u5185\u5BB9>" || trimmed === "<\u5DF2\u7701\u7565\u591A\u5A92\u9AD4\u6A94\u6848>" || trimmed === "\u5716\u7247\u5DF2\u7565\u53BB" || trimmed === "\u5F71\u7247\u5DF2\u7565\u53BB" || trimmed === "\u97F3\u8A0A\u5DF2\u7565\u53BB" || trimmed === "image omitted" || trimmed === "video omitted" || trimmed === "audio omitted") {
     return 1 /* IMAGE */;
@@ -5703,10 +5799,22 @@ function detectMessageType2(content) {
   if (trimmed === "\u8FD9\u6761\u6D88\u606F\u5DF2\u5220\u9664" || trimmed.startsWith("\u6B64\u8A0A\u606F\u5DF2\u522A\u9664") || trimmed.startsWith("\u4F60\u5DF2\u522A\u9664\u6B64\u8A0A\u606F")) {
     return 81 /* RECALL */;
   }
-  if (isSystemMessage(trimmed)) return 80 /* SYSTEM */;
+  if (knownSystem || isSystemMessage(trimmed)) return 80 /* SYSTEM */;
   return 0 /* TEXT */;
 }
 function parseFlexibleTimestamp(raw) {
+  const commonMatch = raw.match(COMMON_TIMESTAMP_REGEX);
+  if (commonMatch) {
+    return buildTimestamp(
+      Number.parseInt(commonMatch[1], 10),
+      Number.parseInt(commonMatch[2], 10),
+      Number.parseInt(commonMatch[3], 10),
+      Number.parseInt(commonMatch[4], 10),
+      Number.parseInt(commonMatch[5], 10),
+      Number.parseInt(commonMatch[6] ?? "0", 10),
+      parseAmPm(commonMatch[7])
+    );
+  }
   let value = raw.replace(/(?:\u2009|\u202F|\uFEFF|\u200E|\u200F|\u200B|\u200C|\u200D|\u2060)/g, " ").trim();
   let isPm = null;
   for (const [pattern, pm] of AMPM_MARKERS) {
@@ -5720,23 +5828,30 @@ function parseFlexibleTimestamp(raw) {
   if (!match) return null;
   const dateParts = match[1].split("/").map((part) => Number.parseInt(part, 10));
   const timeParts = match[2].split(":").map((part) => Number.parseInt(part, 10));
+  return buildTimestamp(dateParts[0], dateParts[1], dateParts[2], timeParts[0], timeParts[1], timeParts[2] ?? 0, isPm);
+}
+function parseAmPm(marker) {
+  if (!marker) return null;
+  return /^(?:PM|P\.M\.|下午|午後|오후)$/i.test(marker);
+}
+function buildTimestamp(firstDatePart, secondDatePart, thirdDatePart, rawHour, minute, second, isPm) {
   let year;
   let month;
   let day;
-  if (dateParts[0] > 31) {
-    ;
-    [year, month, day] = dateParts;
-  } else if (dateParts[2] > 31) {
-    ;
-    [day, month, year] = dateParts;
+  if (firstDatePart > 31) {
+    year = firstDatePart;
+    month = secondDatePart;
+    day = thirdDatePart;
+  } else if (thirdDatePart > 31) {
+    day = firstDatePart;
+    month = secondDatePart;
+    year = thirdDatePart;
   } else {
-    ;
-    [month, day] = dateParts;
-    year = 2e3 + dateParts[2];
+    month = firstDatePart;
+    day = secondDatePart;
+    year = 2e3 + thirdDatePart;
   }
-  let hour = timeParts[0];
-  const minute = timeParts[1];
-  const second = timeParts[2] ?? 0;
+  let hour = rawHour;
   if (isPm === true && hour !== 12) hour += 12;
   if (isPm === false && hour === 12) hour = 0;
   const date = new Date(year, month - 1, day, hour, minute, second);
@@ -6020,13 +6135,14 @@ var feature12 = {
     head: [/"is_geoblocked_for_viewer"\s*:/]
   }
 };
+var UTF8_DECODER = new TextDecoder("utf-8");
 function decodeInstagramText(text) {
   try {
     const bytes = new Uint8Array(text.length);
     for (let i = 0; i < text.length; i++) {
       bytes[i] = text.charCodeAt(i);
     }
-    return new TextDecoder("utf-8").decode(bytes);
+    return UTF8_DECODER.decode(bytes);
   } catch {
     return text;
   }
@@ -6035,23 +6151,23 @@ function extractNameFromFilePath5(filePath) {
   const basename10 = path9.basename(filePath);
   return basename10.replace(/\.json$/i, "") || "\u672A\u77E5\u5BF9\u8BDD";
 }
+var SYSTEM_MESSAGE_PATTERNS2 = [
+  "You created the group",
+  "created the group",
+  "added",
+  "to the group",
+  "left the group",
+  "removed",
+  "named the group",
+  "changed the group photo",
+  "Reacted",
+  "sent an attachment",
+  "liked a message",
+  "changed the theme",
+  "set the nickname"
+];
 function isSystemMessage2(content) {
-  const systemPatterns = [
-    "You created the group",
-    "created the group",
-    "added",
-    "to the group",
-    "left the group",
-    "removed",
-    "named the group",
-    "changed the group photo",
-    "Reacted",
-    "sent an attachment",
-    "liked a message",
-    "changed the theme",
-    "set the nickname"
-  ];
-  return systemPatterns.some((p) => content.includes(p));
+  return SYSTEM_MESSAGE_PATTERNS2.some((pattern) => content.includes(pattern));
 }
 function detectMessageType4(msg) {
   const content = msg.content || "";
@@ -6135,9 +6251,9 @@ async function* parseInstagram(options2) {
   }
   const members = Array.from(memberMap.values());
   yield { type: "members", data: members };
-  const reversedMessages = [...data.messages].reverse();
   const messageBatch = [];
-  for (const msg of reversedMessages) {
+  for (let index = data.messages.length - 1; index >= 0; index -= 1) {
+    const msg = data.messages[index];
     const senderName = decodeInstagramText(msg.sender_name);
     const timestamp = Math.floor(msg.timestamp_ms / 1e3);
     const type = detectMessageType4(msg);
@@ -6161,7 +6277,7 @@ async function* parseInstagram(options2) {
       messageBatch.length = 0;
       const progress = createProgress(
         "parsing",
-        Math.floor(messagesProcessed / reversedMessages.length * totalBytes),
+        Math.floor(messagesProcessed / data.messages.length * totalBytes),
         totalBytes,
         messagesProcessed,
         `\u5DF2\u5904\u7406 ${messagesProcessed} \u6761\u6D88\u606F...`
@@ -6482,20 +6598,22 @@ var SPECIAL_MESSAGE_TYPES = {
   "[\u8A18\u4E8B\u672C]": 0 /* TEXT */,
   "[\u30CE\u30FC\u30C8]": 0 /* TEXT */
 };
+var SPECIAL_MESSAGE_TYPE_ENTRIES = Object.entries(SPECIAL_MESSAGE_TYPES);
 async function parseLineText(content, fileName, options2 = {}) {
-  const lines = content.split("\n").map((line) => line.replace(/\r$/, ""));
+  const lines = content.split("\n");
   const memberMap = /* @__PURE__ */ new Map();
   const messages = [];
-  const header = lines.length > 0 ? extractNameFromHeader(lines[0].trim()) : null;
+  const header = lines.length > 0 ? extractNameFromHeader(lines[0].replace(/\r$/, "").trim()) : null;
   const chatName = header?.name ?? extractNameFromFileName3(fileName);
   let currentDate = null;
   let lastMessage = null;
   let quotedMultiline = false;
   let lineIndex = header ? 3 : 0;
   let useTabSeparator = Boolean(header);
-  const yieldEvery = Math.max(1, options2.yieldEvery ?? 1e3);
+  const yieldEvery = Math.max(1, options2.yieldEvery ?? 5e3);
   if (!header) {
-    for (const line of lines) {
+    for (const rawLine of lines) {
+      const line = rawLine.replace(/\r$/, "");
       if (TAB_MESSAGE_PATTERN.test(line)) {
         useTabSeparator = true;
         break;
@@ -6508,7 +6626,7 @@ async function parseLineText(content, fileName, options2 = {}) {
   }
   for (; lineIndex < lines.length; lineIndex += 1) {
     options2.checkCancelled?.();
-    const line = lines[lineIndex];
+    const line = lines[lineIndex].replace(/\r$/, "");
     const date = parseDateLine(line);
     if (date) {
       currentDate = date;
@@ -6530,7 +6648,7 @@ async function parseLineText(content, fileName, options2 = {}) {
         lastMessage = {
           senderPlatformId: sender,
           senderAccountName: sender,
-          timestamp: buildTimestamp(currentDate, timeText, options2.now),
+          timestamp: buildTimestamp2(currentDate, timeText, options2.now),
           type: detectMessageType6(messageContent),
           content: messageContent || null
         };
@@ -6544,7 +6662,7 @@ async function parseLineText(content, fileName, options2 = {}) {
           lastMessage = {
             senderPlatformId: "system",
             senderAccountName: "\u7CFB\u7D71",
-            timestamp: buildTimestamp(currentDate, timeText, options2.now),
+            timestamp: buildTimestamp2(currentDate, timeText, options2.now),
             type: 80 /* SYSTEM */,
             content: messageContent || null
           };
@@ -6613,7 +6731,7 @@ function parseDateLine(line) {
   }
   return null;
 }
-function buildTimestamp(currentDate, timeText, now) {
+function buildTimestamp2(currentDate, timeText, now) {
   const { hours, minutes } = parseTime(timeText);
   const value = currentDate ? new Date(currentDate) : now?.() ?? /* @__PURE__ */ new Date();
   value.setHours(hours, minutes, 0, 0);
@@ -6637,7 +6755,7 @@ function parseTime(timeText) {
   return { hours, minutes };
 }
 function detectMessageType6(content) {
-  for (const [pattern, type] of Object.entries(SPECIAL_MESSAGE_TYPES)) {
+  for (const [pattern, type] of SPECIAL_MESSAGE_TYPE_ENTRIES) {
     if (content === pattern || content.startsWith(pattern)) return type;
   }
   if (content.startsWith("[null]") && content.includes("maps.google.com")) return 8 /* LOCATION */;
@@ -6743,6 +6861,8 @@ var MAX_UNIX_SECONDS = 1e11;
 var KNOWN_MESSAGE_TYPES = new Set(
   Object.values(MessageType).filter((value) => typeof value === "number")
 );
+var SYSTEM_SENDER_ID = "SYSTEM";
+var SYSTEM_SENDER_MESSAGE_TYPES = /* @__PURE__ */ new Set([80 /* SYSTEM */, 81 /* RECALL */]);
 function createState(format, fileSize) {
   return {
     format,
@@ -6778,21 +6898,21 @@ function isRecord(value) {
 function hasOwn(value, key) {
   return Object.prototype.hasOwnProperty.call(value, key);
 }
-function childLocation(location, path30) {
-  return { ...location, path: path30 };
+function childLocation(location, path31) {
+  return { ...location, path: path31 };
 }
-function validateRequiredString(state, value, path30, location) {
+function validateRequiredString(state, value, path31, location) {
   if (typeof value === "string" && value.trim().length > 0) return true;
-  addIssue(state, "error", "INVALID_REQUIRED_STRING", "Expected a non-empty string.", childLocation(location, path30));
+  addIssue(state, "error", "INVALID_REQUIRED_STRING", "Expected a non-empty string.", childLocation(location, path31));
   return false;
 }
-function validateOptionalString(state, object, key, path30, location) {
+function validateOptionalString(state, object, key, path31, location) {
   if (!hasOwn(object, key)) return;
   if (typeof object[key] !== "string") {
-    addIssue(state, "error", "INVALID_OPTIONAL_STRING", "Expected a string.", childLocation(location, path30));
+    addIssue(state, "error", "INVALID_OPTIONAL_STRING", "Expected a string.", childLocation(location, path31));
   }
 }
-function validateUnixSeconds(state, value, path30, location) {
+function validateUnixSeconds(state, value, path31, location) {
   if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value < MAX_UNIX_SECONDS) {
     return true;
   }
@@ -6801,7 +6921,7 @@ function validateUnixSeconds(state, value, path30, location) {
     "error",
     "INVALID_UNIX_SECONDS",
     "Expected a non-negative integer Unix timestamp in seconds, not milliseconds.",
-    childLocation(location, path30)
+    childLocation(location, path31)
   );
   return false;
 }
@@ -6862,30 +6982,30 @@ function validateHeader(state, chatlab, meta, location, basePath = "") {
   }
   validateOptionalString(state, meta, "sourceSessionId", `${basePath}meta.sourceSessionId`, location);
 }
-function validateMember(state, value, path30, location) {
+function validateMember(state, value, path31, location) {
   state.stats.memberCount++;
   if (!isRecord(value)) {
-    addIssue(state, "error", "INVALID_MEMBER", "Expected a member object.", childLocation(location, path30));
+    addIssue(state, "error", "INVALID_MEMBER", "Expected a member object.", childLocation(location, path31));
     return;
   }
-  if (validateRequiredString(state, value.platformId, `${path30}.platformId`, location)) {
+  if (validateRequiredString(state, value.platformId, `${path31}.platformId`, location)) {
     if (state.memberIds.has(value.platformId)) {
       addIssue(state, "error", "DUPLICATE_MEMBER_ID", "Member platformId must be unique.", {
         ...location,
-        path: `${path30}.platformId`
+        path: `${path31}.platformId`
       });
     } else {
       state.memberIds.add(value.platformId);
     }
   }
-  validateRequiredString(state, value.accountName, `${path30}.accountName`, location);
-  validateOptionalString(state, value, "groupNickname", `${path30}.groupNickname`, location);
-  validateOptionalString(state, value, "avatar", `${path30}.avatar`, location);
+  validateRequiredString(state, value.accountName, `${path31}.accountName`, location);
+  validateOptionalString(state, value, "groupNickname", `${path31}.groupNickname`, location);
+  validateOptionalString(state, value, "avatar", `${path31}.avatar`, location);
   if (hasOwn(value, "aliases")) {
     if (!Array.isArray(value.aliases) || value.aliases.some((alias) => typeof alias !== "string")) {
       addIssue(state, "error", "INVALID_ALIASES", "Expected aliases to be an array of strings.", {
         ...location,
-        path: `${path30}.aliases`
+        path: `${path31}.aliases`
       });
     }
   }
@@ -6893,11 +7013,11 @@ function validateMember(state, value, path30, location) {
     if (!Array.isArray(value.roles)) {
       addIssue(state, "error", "INVALID_ROLES", "Expected roles to be an array.", {
         ...location,
-        path: `${path30}.roles`
+        path: `${path31}.roles`
       });
     } else {
       value.roles.forEach((role, index) => {
-        const rolePath = `${path30}.roles[${index}]`;
+        const rolePath = `${path31}.roles[${index}]`;
         if (!isRecord(role)) {
           addIssue(state, "error", "INVALID_ROLE", "Expected a role object.", {
             ...location,
@@ -6911,47 +7031,57 @@ function validateMember(state, value, path30, location) {
     }
   }
 }
-function validateMessage(state, value, path30, location) {
+function validateMessage(state, value, path31, location) {
   state.stats.messageCount++;
   if (!isRecord(value)) {
-    addIssue(state, "error", "INVALID_MESSAGE", "Expected a message object.", childLocation(location, path30));
+    addIssue(state, "error", "INVALID_MESSAGE", "Expected a message object.", childLocation(location, path31));
     return;
   }
-  if (validateRequiredString(state, value.sender, `${path30}.sender`, location)) {
-    state.senderIds.add(value.sender);
+  const sender = validateRequiredString(state, value.sender, `${path31}.sender`, location) ? value.sender : void 0;
+  if (sender !== void 0) {
+    state.senderIds.add(sender);
   }
-  validateRequiredString(state, value.accountName, `${path30}.accountName`, location);
-  if (validateUnixSeconds(state, value.timestamp, `${path30}.timestamp`, location)) {
+  validateRequiredString(state, value.accountName, `${path31}.accountName`, location);
+  if (validateUnixSeconds(state, value.timestamp, `${path31}.timestamp`, location)) {
     if (state.lastTimestamp !== void 0 && value.timestamp < state.lastTimestamp) {
       addIssue(
         state,
         "warning",
         "OUT_OF_ORDER_TIMESTAMP",
         "Messages should be ordered by timestamp ascending.",
-        childLocation(location, `${path30}.timestamp`)
+        childLocation(location, `${path31}.timestamp`)
       );
     }
     state.lastTimestamp = value.timestamp;
   }
-  if (typeof value.type !== "number" || !Number.isInteger(value.type) || !KNOWN_MESSAGE_TYPES.has(value.type)) {
+  const messageType = typeof value.type === "number" && Number.isInteger(value.type) && KNOWN_MESSAGE_TYPES.has(value.type) ? value.type : void 0;
+  if (messageType === void 0) {
     addIssue(state, "error", "INVALID_MESSAGE_TYPE", "Expected a supported numeric ChatLab message type.", {
       ...location,
-      path: `${path30}.type`
+      path: `${path31}.type`
     });
+  } else if (sender === SYSTEM_SENDER_ID && !SYSTEM_SENDER_MESSAGE_TYPES.has(messageType)) {
+    addIssue(
+      state,
+      "error",
+      "INVALID_SYSTEM_SENDER_TYPE",
+      "The reserved SYSTEM sender is only valid for system and recall messages.",
+      childLocation(location, `${path31}.sender`)
+    );
   }
   if (!hasOwn(value, "content") || typeof value.content !== "string" && value.content !== null) {
     addIssue(state, "error", "INVALID_MESSAGE_CONTENT", "Expected content to be a string or null.", {
       ...location,
-      path: `${path30}.content`
+      path: `${path31}.content`
     });
   }
-  validateOptionalString(state, value, "groupNickname", `${path30}.groupNickname`, location);
+  validateOptionalString(state, value, "groupNickname", `${path31}.groupNickname`, location);
   if (hasOwn(value, "platformMessageId")) {
-    if (validateRequiredString(state, value.platformMessageId, `${path30}.platformMessageId`, location)) {
+    if (validateRequiredString(state, value.platformMessageId, `${path31}.platformMessageId`, location)) {
       if (state.messageIds.has(value.platformMessageId)) {
         addIssue(state, "error", "DUPLICATE_MESSAGE_ID", "platformMessageId must be unique.", {
           ...location,
-          path: `${path30}.platformMessageId`
+          path: `${path31}.platformMessageId`
         });
       } else {
         state.messageIds.add(value.platformMessageId);
@@ -6959,7 +7089,7 @@ function validateMessage(state, value, path30, location) {
     }
   }
   if (hasOwn(value, "replyToMessageId")) {
-    if (validateRequiredString(state, value.replyToMessageId, `${path30}.replyToMessageId`, location)) {
+    if (validateRequiredString(state, value.replyToMessageId, `${path31}.replyToMessageId`, location)) {
       state.replyTargetIds.add(value.replyToMessageId);
     }
   }
@@ -6986,7 +7116,7 @@ function finalizeState(state, requireExplicitMembers, enforceRequiredSections =
   }
   if (state.memberIds.size > 0) {
     for (const senderId of state.senderIds) {
-      if (!state.memberIds.has(senderId)) {
+      if (senderId !== SYSTEM_SENDER_ID && !state.memberIds.has(senderId)) {
         addIssue(
           state,
           "error",
@@ -7125,6 +7255,154 @@ async function validateChatLabFile(filePath) {
   return finalizeState(state, false, false);
 }
 
+// ../../packages/parser/src/chatlab-demo-timeline.ts
+var SECONDS_PER_MINUTE = 60;
+var DEFAULT_DEMO_TIME_ZONE_OFFSET_MINUTES = 8 * 60;
+var MAX_TIME_ZONE_OFFSET_MINUTES = 14 * 60;
+function rebaseChatLabDemoDocuments(jsonDocuments, now = /* @__PURE__ */ new Date(), targetTimeZone) {
+  if (jsonDocuments.length === 0) throw new Error("Demo timeline requires at least one document");
+  if (!Number.isFinite(now.getTime())) throw new Error("Demo timeline requires a valid import time");
+  const documents = jsonDocuments.map((json, index) => parseDemoDocument(json, index));
+  const timeZoneOffsetMinutes = resolveTimeZoneOffsetMinutes(documents);
+  const sourceLatestTimestamp = Math.max(
+    ...documents.flatMap((document) => document.messages.map((message) => message.timestamp))
+  );
+  const sourceLatestWallTime = new Date((sourceLatestTimestamp + timeZoneOffsetMinutes * SECONDS_PER_MINUTE) * 1e3);
+  const latestTimestamp = resolveTargetLatestTimestamp(now, sourceLatestWallTime, targetTimeZone);
+  const offsetSeconds = latestTimestamp - sourceLatestTimestamp;
+  const exportedAt = Math.floor(now.getTime() / 1e3);
+  for (const document of documents) {
+    document.chatlab.exportedAt = exportedAt;
+    for (const message of document.messages) {
+      message.timestamp += offsetSeconds;
+    }
+  }
+  return {
+    documents: documents.map((document) => JSON.stringify(document)),
+    offsetSeconds,
+    latestTimestamp
+  };
+}
+function resolveTargetLatestTimestamp(now, sourceWallTime, targetTimeZone) {
+  if (!targetTimeZone) {
+    const targetLatestTime = new Date(now);
+    targetLatestTime.setDate(targetLatestTime.getDate() - 1);
+    targetLatestTime.setHours(
+      sourceWallTime.getUTCHours(),
+      sourceWallTime.getUTCMinutes(),
+      sourceWallTime.getUTCSeconds(),
+      0
+    );
+    return Math.floor(targetLatestTime.getTime() / 1e3);
+  }
+  let formatter;
+  try {
+    formatter = new Intl.DateTimeFormat("en-US-u-ca-gregory-nu-latn", {
+      timeZone: targetTimeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hourCycle: "h23"
+    });
+  } catch {
+    throw new Error("Demo timeline has an invalid target time zone");
+  }
+  const currentDate = getZonedDateTimeParts(now, formatter);
+  const yesterday = new Date(Date.UTC(currentDate.year, currentDate.month - 1, currentDate.day - 1));
+  const targetParts = {
+    year: yesterday.getUTCFullYear(),
+    month: yesterday.getUTCMonth() + 1,
+    day: yesterday.getUTCDate(),
+    hour: sourceWallTime.getUTCHours(),
+    minute: sourceWallTime.getUTCMinutes(),
+    second: sourceWallTime.getUTCSeconds()
+  };
+  return Math.floor(zonedWallTimeToUnixMillis(targetParts, formatter) / 1e3);
+}
+function getZonedDateTimeParts(date, formatter) {
+  const values = new Map(formatter.formatToParts(date).map((part) => [part.type, part.value]));
+  const read = (type) => Number(values.get(type));
+  const parts = {
+    year: read("year"),
+    month: read("month"),
+    day: read("day"),
+    hour: read("hour"),
+    minute: read("minute"),
+    second: read("second")
+  };
+  if (Object.values(parts).some((value) => !Number.isInteger(value))) {
+    throw new Error("Demo timeline could not resolve the target time zone");
+  }
+  return parts;
+}
+function zonedWallTimeToUnixMillis(target, formatter) {
+  const targetAsUtc = dateTimePartsToUtcMillis(target);
+  let candidate = targetAsUtc;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const actual2 = getZonedDateTimeParts(new Date(candidate), formatter);
+    const correction = targetAsUtc - dateTimePartsToUtcMillis(actual2);
+    candidate += correction;
+    if (correction === 0) return candidate;
+  }
+  const actual = getZonedDateTimeParts(new Date(candidate), formatter);
+  if (dateTimePartsToUtcMillis(actual) !== targetAsUtc) {
+    throw new Error("Demo timeline target wall time does not exist in the selected time zone");
+  }
+  return candidate;
+}
+function dateTimePartsToUtcMillis(parts) {
+  return Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+}
+function parseDemoDocument(json, index) {
+  let value;
+  try {
+    value = JSON.parse(json);
+  } catch {
+    throw new Error(`Demo document ${index + 1} is not valid JSON`);
+  }
+  if (!isRecord2(value) || !isRecord2(value.chatlab) || !Array.isArray(value.messages)) {
+    throw new Error(`Demo document ${index + 1} is not a ChatLab JSON document`);
+  }
+  if (value.messages.length === 0) {
+    throw new Error(`Demo document ${index + 1} has no messages`);
+  }
+  const messages = value.messages.map((message, messageIndex) => {
+    if (!isRecord2(message) || !isUnixSeconds(message.timestamp)) {
+      throw new Error(`Demo document ${index + 1} has an invalid timestamp at message ${messageIndex + 1}`);
+    }
+    return message;
+  });
+  return {
+    ...value,
+    chatlab: value.chatlab,
+    messages
+  };
+}
+function resolveTimeZoneOffsetMinutes(documents) {
+  const offsets = /* @__PURE__ */ new Set();
+  for (const document of documents) {
+    const configured = document.chatlab.demoTimeline?.timeZoneOffsetMinutes;
+    const offset = configured ?? DEFAULT_DEMO_TIME_ZONE_OFFSET_MINUTES;
+    if (typeof offset !== "number" || !Number.isInteger(offset) || Math.abs(offset) > MAX_TIME_ZONE_OFFSET_MINUTES) {
+      throw new Error("Demo timeline has an invalid time zone offset");
+    }
+    offsets.add(offset);
+  }
+  if (offsets.size !== 1) {
+    throw new Error("Demo documents must use the same time zone offset");
+  }
+  return offsets.values().next().value;
+}
+function isUnixSeconds(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // ../../packages/parser/src/index.ts
 var sniffer = createSniffer();
 sniffer.registerAll(formats);
@@ -7262,95 +7540,113 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   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 (!fs19.existsSync(logDir)) {
-      fs19.mkdirSync(logDir, { recursive: true });
+function createImportPerfLogger(logDir) {
+  let lastLogTime = Date.now();
+  let lastMessageCount = 0;
+  let currentLogFile = null;
+  let errorCount = 0;
+  const append = (line) => {
+    if (!currentLogFile) return;
+    try {
+      fs19.appendFileSync(currentLogFile, line, "utf-8");
+    } catch {
     }
-    currentLogFile = path12.join(logDir, `import_${sessionId}_${Date.now()}.log`);
-    fs19.writeFileSync(currentLogFile, `=== Import Log ===
+  };
+  const writeLogLine = (level, message) => {
+    append(`[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${message}
+`);
+  };
+  return {
+    init(sessionId) {
+      try {
+        if (!fs19.existsSync(logDir)) fs19.mkdirSync(logDir, { recursive: true });
+        currentLogFile = path12.join(logDir, `import_${sessionId}_${Date.now()}.log`);
+        fs19.writeFileSync(currentLogFile, `=== Import Log ===
 Start time: ${(/* @__PURE__ */ new Date()).toISOString()}
 
 `, "utf-8");
-  } catch {
-  }
+      } catch {
+        currentLogFile = null;
+      }
+    },
+    perf(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 {
+        memory = Math.round(process.memoryUsage().heapUsed / 1024 / 1024);
+      } catch {
+      }
+      append(
+        `[${(/* @__PURE__ */ new Date()).toISOString()}] ${event} | messages: ${messagesProcessed.toLocaleString()} | elapsed: ${duration}ms | speed: ${speed.toLocaleString()}/s | memory: ${memory}MB` + (batchSize ? ` | batch: ${batchSize}` : "") + "\n"
+      );
+      lastLogTime = now;
+      lastMessageCount = messagesProcessed;
+    },
+    perfDetail(detail) {
+      append(`  ${detail}
+`);
+    },
+    reset() {
+      lastLogTime = Date.now();
+      lastMessageCount = 0;
+      currentLogFile = null;
+      errorCount = 0;
+    },
+    getCurrentLogFile() {
+      return currentLogFile;
+    },
+    error(message, error) {
+      errorCount++;
+      writeLogLine("ERROR" /* ERROR */, `${message}${error ? `: ${error.message}` : ""}`);
+    },
+    info(message) {
+      writeLogLine("INFO" /* INFO */, message);
+    },
+    getErrorCount() {
+      return errorCount;
+    },
+    summary(totalMessages, totalMembers) {
+      append(`
+=== Import Summary ===
+End time: ${(/* @__PURE__ */ new Date()).toISOString()}
+Total messages: ${totalMessages.toLocaleString()}
+Total members: ${totalMembers.toLocaleString()}
+Errors: ${errorCount}
+`);
+    }
+  };
+}
+var defaultLogger = createImportPerfLogger("");
+function initPerfLog(sessionId, logDir) {
+  defaultLogger = createImportPerfLogger(logDir);
+  defaultLogger.init(sessionId);
 }
 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 {
-      fs19.appendFileSync(currentLogFile, logLine, "utf-8");
-    } catch {
-    }
-  }
-  lastLogTime = now;
-  lastMessageCount = messagesProcessed;
+  defaultLogger.perf(event, messagesProcessed, batchSize);
 }
 function logPerfDetail(detail) {
-  if (currentLogFile) {
-    try {
-      fs19.appendFileSync(currentLogFile, `  ${detail}
-`, "utf-8");
-    } catch {
-    }
-  }
+  defaultLogger.perfDetail(detail);
 }
 function resetPerfLog() {
-  lastLogTime = Date.now();
-  lastMessageCount = 0;
-  currentLogFile = null;
-  errorCount = 0;
+  defaultLogger.reset();
 }
 function getCurrentLogFile() {
-  return currentLogFile;
-}
-function writeLogLine(level, message) {
-  if (!currentLogFile) return;
-  const logLine = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${message}
-`;
-  try {
-    fs19.appendFileSync(currentLogFile, logLine, "utf-8");
-  } catch {
-  }
+  return defaultLogger.getCurrentLogFile();
 }
 function logError(message, error) {
-  errorCount++;
-  const errorDetail = error ? `: ${error.message}` : "";
-  writeLogLine("ERROR" /* ERROR */, `${message}${errorDetail}`);
+  defaultLogger.error(message, error);
 }
 function logInfo(message) {
-  writeLogLine("INFO" /* INFO */, message);
+  defaultLogger.info(message);
 }
 function getErrorCount() {
-  return errorCount;
+  return defaultLogger.getErrorCount();
 }
 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 {
-    fs19.appendFileSync(currentLogFile, summary, "utf-8");
-  } catch {
-  }
+  defaultLogger.summary(totalMessages, totalMembers);
 }
 
 // ../../packages/node-runtime/src/nlp/word-frequency.ts
@@ -7593,16 +7889,27 @@ function createFtsTable(db) {
 function buildFtsIndex(db) {
   createFtsTable(db);
   const insertFts = db.prepare("INSERT INTO message_fts(rowid, content) VALUES (?, ?)");
-  const countRow = db.prepare("SELECT COUNT(*) as total FROM message WHERE type = 0 AND content IS NOT NULL AND content != ''").get();
-  const total = countRow?.total ?? 0;
   let indexed = 0;
-  let offset = 0;
-  while (offset < total) {
-    const rows = db.prepare(
-      `SELECT id, content FROM message
-         WHERE type = 0 AND content IS NOT NULL AND content != ''
-         ORDER BY id ASC LIMIT ? OFFSET ?`
-    ).all(BATCH_SIZE, offset);
+  let lastId = null;
+  const selectFirstBatch = db.prepare(
+    `SELECT id, content FROM message
+     WHERE type = 0
+       AND content IS NOT NULL
+       AND content != ''
+     ORDER BY id ASC
+     LIMIT ?`
+  );
+  const selectNextBatch = db.prepare(
+    `SELECT id, content FROM message
+     WHERE type = 0
+       AND content IS NOT NULL
+       AND content != ''
+       AND id > ?
+     ORDER BY id ASC
+     LIMIT ?`
+  );
+  while (true) {
+    const rows = lastId === null ? selectFirstBatch.all(BATCH_SIZE) : selectNextBatch.all(lastId, BATCH_SIZE);
     if (rows.length === 0) break;
     db.transaction(() => {
       for (const row of rows) {
@@ -7613,7 +7920,7 @@ function buildFtsIndex(db) {
       }
     });
     indexed += rows.length;
-    offset += BATCH_SIZE;
+    lastId = rows[rows.length - 1].id;
   }
   return { indexed };
 }
@@ -7655,8 +7962,62 @@ function searchByFts(db, keywords, limit = 1e3, offset = 0) {
   }
 }
 
+// ../../packages/node-runtime/src/import/message-batch-inserter.ts
+var MESSAGE_COLUMN_COUNT = 8;
+var SQLITE_LEGACY_VARIABLE_LIMIT = 999;
+var MESSAGE_INSERT_MAX_ROWS = Math.floor(SQLITE_LEGACY_VARIABLE_LIMIT / MESSAGE_COLUMN_COUNT);
+var MessageBatchInserter = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  statementCache = /* @__PURE__ */ new Map();
+  insert(rows) {
+    let statementCount = 0;
+    for (let offset = 0; offset < rows.length; offset += MESSAGE_INSERT_MAX_ROWS) {
+      const batch = rows.slice(offset, offset + MESSAGE_INSERT_MAX_ROWS);
+      const statement = this.getStatement(batch.length);
+      statement.run(...batch.flatMap(toParams));
+      statementCount++;
+    }
+    return statementCount;
+  }
+  getStatement(rowCount) {
+    const cached = this.statementCache.get(rowCount);
+    if (cached) return cached;
+    const values = Array.from({ length: rowCount }, () => "(?, ?, ?, ?, ?, ?, ?, ?)").join(", ");
+    const statement = this.db.prepare(
+      `INSERT INTO message (
+         sender_id,
+         sender_account_name,
+         sender_group_nickname,
+         ts,
+         type,
+         content,
+         reply_to_message_id,
+         platform_message_id
+       ) VALUES ${values}`
+    );
+    this.statementCache.set(rowCount, statement);
+    return statement;
+  }
+};
+function toParams(row) {
+  return [
+    row.senderId,
+    row.senderAccountName,
+    row.senderGroupNickname,
+    row.timestamp,
+    row.type,
+    row.content,
+    row.replyToMessageId,
+    row.platformMessageId
+  ];
+}
+
 // ../../packages/node-runtime/src/import/streaming-importer.ts
 import * as fs21 from "fs";
+import { performance } from "perf_hooks";
 
 // ../../packages/node-runtime/src/import/message-deduplicator.ts
 function generateFallbackMessageKey(message) {
@@ -7688,15 +8049,25 @@ function registerMessageAndCheckDuplicate(message, state) {
 // ../../packages/node-runtime/src/import/streaming-importer.ts
 var BATCH_COMMIT_SIZE = 5e4;
 var CHECKPOINT_INTERVAL = 2e5;
+var SYSTEM_SENDER_ID2 = "SYSTEM";
+var SYSTEM_MEMBER_NAME = "\u7CFB\u7EDF\u6D88\u606F";
+var RESERVED_SYSTEM_SENDER_FORMATS = /* @__PURE__ */ new Set(["chatlab", "chatlab-jsonl"]);
+var defaultNow = () => performance.now();
+function elapsedMs(startedAt, now) {
+  return now() - startedAt;
+}
 var yieldToEventLoop = () => new Promise((resolve4) => setImmediate(resolve4));
 function defaultGenerateSessionId() {
   const ts = Date.now();
   const rand = Math.random().toString(36).substring(2, 8);
   return `chat_${ts}_${rand}`;
 }
-function prepareMessageForCreate(message) {
+function normalizeSystemMemberName(formatId, platformId, name) {
+  return RESERVED_SYSTEM_SENDER_FORMATS.has(formatId) && platformId === SYSTEM_SENDER_ID2 ? SYSTEM_MEMBER_NAME : name;
+}
+function prepareMessageForCreate(message, senderAccountName = message.senderAccountName) {
   if (!message.senderPlatformId) return { skipCounter: "skippedNoSenderId" };
-  if (!message.senderAccountName) return { skipCounter: "skippedNoAccountName" };
+  if (!senderAccountName) return { skipCounter: "skippedNoAccountName" };
   if (message.timestamp === void 0 || message.timestamp === null || isNaN(message.timestamp)) {
     return { skipCounter: "skippedInvalidTimestamp" };
   }
@@ -7717,28 +8088,38 @@ function prepareMessageForCreate(message) {
   };
 }
 async function streamingImport(filePath, deps, formatOptions, externalSessionId) {
+  const now = deps.now ?? defaultNow;
+  const totalStartedAt = now();
+  const detectionStartedAt = now();
   if (formatOptions?.formatId) {
     const formatId = formatOptions.formatId;
     const feature15 = getFormatFeatureById(formatId);
     if (!feature15) {
       return { success: false, error: "error.unknown_format_id" };
     }
-    return streamImportSingle(filePath, deps, feature15, formatOptions, externalSessionId);
+    return streamImportSingle(filePath, deps, feature15, formatOptions, externalSessionId, {
+      totalStartedAt,
+      detectionMs: elapsedMs(detectionStartedAt, now)
+    });
   }
   const candidates = detectAllFormats(filePath);
   if (candidates.length === 0) {
     return { success: false, error: "error.unrecognized_format" };
   }
+  const timingContext = {
+    totalStartedAt,
+    detectionMs: elapsedMs(detectionStartedAt, now)
+  };
   if (candidates.length > 1) {
-    return streamImportWithFallback(filePath, deps, candidates, formatOptions, externalSessionId);
+    return streamImportWithFallback(filePath, deps, candidates, formatOptions, externalSessionId, timingContext);
   }
-  return streamImportSingle(filePath, deps, candidates[0], formatOptions, externalSessionId);
+  return streamImportSingle(filePath, deps, candidates[0], formatOptions, externalSessionId, timingContext);
 }
-async function streamImportWithFallback(filePath, deps, candidates, formatOptions, externalSessionId) {
+async function streamImportWithFallback(filePath, deps, candidates, formatOptions, externalSessionId, timingContext) {
   for (let i = 0; i < candidates.length; i++) {
     const candidate = candidates[i];
     deps.logger?.info(`[StreamImport] Trying format ${i + 1}/${candidates.length}: ${candidate.name} (${candidate.id})`);
-    const result = await streamImportSingle(filePath, deps, candidate, formatOptions, externalSessionId);
+    const result = await streamImportSingle(filePath, deps, candidate, formatOptions, externalSessionId, timingContext);
     if (result.success) {
       if (i > 0) {
         deps.logger?.info(
@@ -7752,9 +8133,32 @@ async function streamImportWithFallback(filePath, deps, candidates, formatOption
   }
   return { success: false, error: "error.no_messages" };
 }
-async function streamImportSingle(filePath, deps, formatFeature, formatOptions, externalSessionId) {
+async function streamImportSingle(filePath, deps, formatFeature, formatOptions, externalSessionId, timingContext) {
   const { onProgress, logger } = deps;
   const genId = deps.generateSessionId ?? defaultGenerateSessionId;
+  const now = deps.now ?? defaultNow;
+  const totalStartedAt = timingContext?.totalStartedAt ?? now();
+  const timings = {
+    detectionMs: timingContext?.detectionMs ?? 0,
+    preprocessingMs: 0,
+    databaseSetupMs: 0,
+    parserMs: 0,
+    metaWriteMs: 0,
+    memberWriteMs: 0,
+    messageWriteMs: 0,
+    nicknameHistoryMs: 0,
+    indexCreationMs: 0,
+    ftsMs: 0,
+    checkpointMs: 0,
+    sessionIndexMs: 0,
+    postImportHookMs: 0,
+    totalMs: 0
+  };
+  const rssStartBytes = process.memoryUsage().rss;
+  let rssPeakBytes = rssStartBytes;
+  const sampleRss = () => {
+    rssPeakBytes = Math.max(rssPeakBytes, process.memoryUsage().rss);
+  };
   logger?.reset();
   const sessionId = externalSessionId || genId();
   logger?.init(sessionId);
@@ -7764,8 +8168,18 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
   logger?.perf("Import started", 0);
   let actualFilePath = filePath;
   let tempFilePath = null;
-  const preprocessor = getPreprocessor(filePath);
-  if (preprocessor && needsPreprocess(filePath)) {
+  const preprocessing = deps.preprocessing ?? { getPreprocessor, needsPreprocess, isNativeFormatAvailable };
+  const getImportPreprocessor = preprocessing.getPreprocessor;
+  const shouldPreprocess = preprocessing.needsPreprocess;
+  const nativeFormatAvailable = preprocessing.isNativeFormatAvailable;
+  const preprocessor = getImportPreprocessor(filePath);
+  const needsLargeFilePreprocess = preprocessor && shouldPreprocess(filePath);
+  const nativeCanParseOriginal = needsLargeFilePreprocess && nativeFormatAvailable(formatFeature.id);
+  if (nativeCanParseOriginal) {
+    logger?.info(
+      `[NativeParser] Kernel ${formatFeature.id} is available; skipping large-file preprocessing and parsing the original export`
+    );
+  } else if (needsLargeFilePreprocess) {
     logger?.info("File needs preprocessing, simplifying large file...");
     onProgress({
       stage: "parsing",
@@ -7775,6 +8189,7 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
       percentage: 0,
       message: ""
     });
+    const preprocessingStartedAt = now();
     try {
       tempFilePath = await preprocessor.preprocess(filePath, (progress) => {
         onProgress({ ...progress, message: "" });
@@ -7785,45 +8200,100 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
       const errorMsg = `Preprocessing failed: ${err instanceof Error ? err.message : String(err)}`;
       logger?.error(errorMsg, err instanceof Error ? err : void 0);
       return { success: false, error: errorMsg };
+    } finally {
+      timings.preprocessingMs = elapsedMs(preprocessingStartedAt, now);
+      sampleRss();
     }
   }
-  const db = deps.openDatabase(sessionId);
-  const insertMeta = db.prepare(
-    `INSERT INTO meta (name, platform, type, imported_at, group_id, group_avatar, owner_id) VALUES (?, ?, ?, ?, ?, ?, ?)`
-  );
-  const insertMember = db.prepare(
-    `INSERT INTO member (platform_id, account_name, group_nickname, aliases, 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),
-       aliases = CASE WHEN excluded.aliases != '[]' THEN excluded.aliases ELSE aliases END,
-       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(
-    `INSERT INTO message (sender_id, sender_account_name, sender_group_nickname, ts, type, content, reply_to_message_id, platform_message_id)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
-  );
-  const insertNameHistory = db.prepare(
-    `INSERT INTO member_name_history (member_id, name_type, name, start_ts, end_ts) VALUES (?, ?, ?, ?, ?)`
-  );
-  const updateMemberAccountName = db.prepare(`UPDATE member SET account_name = ? WHERE platform_id = ?`);
-  const updateMemberGroupNickname = db.prepare(`UPDATE member SET group_nickname = ? WHERE platform_id = ?`);
+  const databaseSetupStartedAt = now();
+  const databaseSetup = (() => {
+    let db2;
+    try {
+      db2 = deps.openDatabase(sessionId);
+      return {
+        ok: true,
+        db: db2,
+        insertMeta: db2.prepare(
+          `INSERT INTO meta (name, platform, type, imported_at, group_id, group_avatar, owner_id) VALUES (?, ?, ?, ?, ?, ?, ?)`
+        ),
+        insertMember: db2.prepare(
+          `INSERT INTO member (platform_id, account_name, group_nickname, aliases, 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),
+             aliases = CASE WHEN excluded.aliases != '[]' THEN excluded.aliases ELSE aliases END,
+             avatar = COALESCE(NULLIF(excluded.avatar, ''), avatar),
+             roles = CASE WHEN excluded.roles != '[]' THEN excluded.roles ELSE roles END`
+        ),
+        getMemberId: db2.prepare(`SELECT id FROM member WHERE platform_id = ?`),
+        insertNameHistory: db2.prepare(
+          `INSERT INTO member_name_history (member_id, name_type, name, start_ts, end_ts) VALUES (?, ?, ?, ?, ?)`
+        ),
+        updateMemberAccountName: db2.prepare(`UPDATE member SET account_name = ? WHERE platform_id = ?`),
+        updateMemberGroupNickname: db2.prepare(`UPDATE member SET group_nickname = ? WHERE platform_id = ?`)
+      };
+    } catch (error) {
+      try {
+        db2?.close();
+      } catch {
+      }
+      return { ok: false, error, databaseOpened: db2 !== void 0 };
+    }
+  })();
+  timings.databaseSetupMs = elapsedMs(databaseSetupStartedAt, now);
+  sampleRss();
+  if (!databaseSetup.ok) {
+    if (tempFilePath && preprocessor) preprocessor.cleanup(tempFilePath);
+    if (databaseSetup.databaseOpened) deps.deleteDatabase(sessionId);
+    const error = databaseSetup.error;
+    logger?.error("Import failed during database setup", error instanceof Error ? error : void 0);
+    throw error;
+  }
+  const {
+    db,
+    insertMeta,
+    insertMember,
+    getMemberId,
+    insertNameHistory,
+    updateMemberAccountName,
+    updateMemberGroupNickname
+  } = databaseSetup;
   const memberIdMap = /* @__PURE__ */ new Map();
   const accountNameTracker = /* @__PURE__ */ new Map();
   const groupNicknameTracker = /* @__PURE__ */ new Map();
   let metaInserted = false;
+  let importedPlatform = formatFeature.platform;
   let messageCountInBatch = 0;
   let totalMessageCount = 0;
   let duplicateCount = 0;
   let lastCheckpointCount = 0;
   let inTransaction = false;
+  let messageTransactionCount = 0;
+  let messageTransactionMs = 0;
+  let messageInsertStatementCount = 0;
+  const messageBatchInserter = new MessageBatchInserter(db);
   const beginTransaction = () => {
     if (!inTransaction) {
-      db.exec("BEGIN TRANSACTION");
-      inTransaction = true;
+      const startedAt = now();
+      try {
+        db.exec("BEGIN TRANSACTION");
+        inTransaction = true;
+        messageTransactionCount++;
+      } finally {
+        messageTransactionMs += elapsedMs(startedAt, now);
+      }
+    }
+  };
+  const commitTransaction = () => {
+    if (inTransaction) {
+      const startedAt = now();
+      try {
+        db.exec("COMMIT");
+        inTransaction = false;
+      } finally {
+        messageTransactionMs += elapsedMs(startedAt, now);
+      }
     }
   };
   const doCheckpoint = () => {
@@ -7832,13 +8302,20 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
     } catch {
     }
   };
+  const measureCheckpoint = () => {
+    const startedAt = now();
+    try {
+      doCheckpoint();
+    } finally {
+      timings.checkpointMs += elapsedMs(startedAt, now);
+    }
+  };
   const commitAndBeginNew = () => {
     if (inTransaction) {
-      db.exec("COMMIT");
-      inTransaction = false;
+      commitTransaction();
       logger?.perf("Commit transaction", totalMessageCount, BATCH_COMMIT_SIZE);
       if (totalMessageCount - lastCheckpointCount >= CHECKPOINT_INTERVAL) {
-        doCheckpoint();
+        measureCheckpoint();
         logger?.perf("WAL checkpoint", totalMessageCount);
         lastCheckpointCount = totalMessageCount;
       }
@@ -7853,7 +8330,6 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
     }
     beginTransaction();
   };
-  beginTransaction();
   let shouldDeleteDb = false;
   let importError = null;
   const callbackStats = {
@@ -7871,7 +8347,18 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
   };
   const dedupState = createMessageDedupState();
   logger?.info("Starting streamParseFile...");
+  const parsePipelineStartedAt = now();
+  let parserTimingFinished = false;
+  const finishParserTiming = () => {
+    if (parserTimingFinished) return;
+    const parsePipelineMs = elapsedMs(parsePipelineStartedAt, now);
+    const writeCallbackMs = timings.metaWriteMs + timings.memberWriteMs + timings.messageWriteMs + messageTransactionMs + timings.checkpointMs;
+    timings.parserMs = Math.max(0, parsePipelineMs - writeCallbackMs);
+    parserTimingFinished = true;
+    sampleRss();
+  };
   try {
+    beginTransaction();
     await streamParseFile(
       actualFilePath,
       {
@@ -7890,123 +8377,139 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
           }
         },
         onMeta: (meta) => {
-          callbackStats.onMetaCalls++;
-          if (!metaInserted) {
-            logger?.info(`Writing meta: name=${meta.name}, type=${meta.type}, platform=${meta.platform}`);
-            insertMeta.run(
-              meta.name,
-              meta.platform,
-              meta.type,
-              Math.floor(Date.now() / 1e3),
-              meta.groupId || null,
-              meta.groupAvatar || null,
-              meta.ownerId || null
-            );
-            metaInserted = true;
+          const startedAt = now();
+          try {
+            callbackStats.onMetaCalls++;
+            importedPlatform = meta.platform || importedPlatform;
+            if (!metaInserted) {
+              logger?.info(`Writing meta: name=${meta.name}, type=${meta.type}, platform=${meta.platform}`);
+              insertMeta.run(
+                meta.name,
+                meta.platform,
+                meta.type,
+                Math.floor(Date.now() / 1e3),
+                meta.groupId || null,
+                meta.groupAvatar || null,
+                meta.ownerId || null
+              );
+              metaInserted = true;
+            }
+          } finally {
+            timings.metaWriteMs += elapsedMs(startedAt, now);
+            sampleRss();
           }
         },
         onMembers: (members) => {
-          callbackStats.onMembersCalls++;
-          callbackStats.totalMembersReceived += members.length;
-          logger?.info(`Received member batch: ${members.length} members`);
-          for (const member of members) {
-            insertMember.run(
-              member.platformId,
-              member.accountName || null,
-              member.groupNickname || null,
-              member.aliases ? JSON.stringify(member.aliases) : "[]",
-              member.avatar || null,
-              member.roles ? JSON.stringify(member.roles) : "[]"
-            );
-            const row = getMemberId.get(member.platformId);
-            if (row) memberIdMap.set(member.platformId, row.id);
+          const startedAt = now();
+          try {
+            callbackStats.onMembersCalls++;
+            callbackStats.totalMembersReceived += members.length;
+            logger?.info(`Received member batch: ${members.length} members`);
+            for (const member of members) {
+              const accountName = normalizeSystemMemberName(formatFeature.id, member.platformId, member.accountName);
+              const groupNickname = normalizeSystemMemberName(formatFeature.id, member.platformId, member.groupNickname);
+              insertMember.run(
+                member.platformId,
+                accountName || null,
+                groupNickname || null,
+                member.aliases ? JSON.stringify(member.aliases) : "[]",
+                member.avatar || null,
+                member.roles ? JSON.stringify(member.roles) : "[]"
+              );
+              const row = getMemberId.get(member.platformId);
+              if (row) memberIdMap.set(member.platformId, row.id);
+            }
+          } finally {
+            timings.memberWriteMs += elapsedMs(startedAt, now);
+            sampleRss();
           }
         },
         onMessageBatch: (messages) => {
-          callbackStats.onMessageBatchCalls++;
-          callbackStats.totalMessagesReceived += messages.length;
-          if (callbackStats.onMessageBatchCalls <= 3 || callbackStats.onMessageBatchCalls % 10 === 0) {
-            logger?.info(`Received message batch #${callbackStats.onMessageBatchCalls}: ${messages.length} messages`);
-          }
-          let memberLookupTime = 0;
-          let memberInsertTime = 0;
-          let messageInsertTime = 0;
-          let nicknameTrackTime = 0;
-          let memberLookupCount = 0;
-          let memberInsertCount = 0;
-          let nicknameChangeCount = 0;
-          for (const msg of messages) {
-            const prepared = prepareMessageForCreate(msg);
-            if ("skipCounter" in prepared) {
-              callbackStats[prepared.skipCounter]++;
-              continue;
-            }
-            const dedupMessage = prepared.message;
-            if (registerMessageAndCheckDuplicate(dedupMessage, dedupState)) {
-              duplicateCount++;
-              continue;
+          const startedAt = now();
+          const transactionMsBefore = messageTransactionMs;
+          const checkpointMsBefore = timings.checkpointMs;
+          try {
+            const pendingRows = [];
+            const flushPendingRows = () => {
+              if (pendingRows.length === 0) return;
+              messageInsertStatementCount += messageBatchInserter.insert(pendingRows);
+              pendingRows.length = 0;
+            };
+            callbackStats.onMessageBatchCalls++;
+            callbackStats.totalMessagesReceived += messages.length;
+            if (callbackStats.onMessageBatchCalls <= 3 || callbackStats.onMessageBatchCalls % 10 === 0) {
+              logger?.info(`Received message batch #${callbackStats.onMessageBatchCalls}: ${messages.length} messages`);
             }
-            let t0 = Date.now();
-            if (!memberIdMap.has(msg.senderPlatformId)) {
-              insertMember.run(
+            for (const msg of messages) {
+              const senderAccountName = normalizeSystemMemberName(
+                formatFeature.id,
                 msg.senderPlatformId,
-                msg.senderAccountName || null,
-                msg.senderGroupNickname || null,
-                "[]",
-                null,
-                "[]"
+                msg.senderAccountName
               );
-              const row = getMemberId.get(msg.senderPlatformId);
-              if (row) memberIdMap.set(msg.senderPlatformId, row.id);
-              memberInsertCount++;
-              memberInsertTime += Date.now() - t0;
-            } else {
-              memberLookupCount++;
-              memberLookupTime += Date.now() - t0;
-            }
-            const senderId = memberIdMap.get(msg.senderPlatformId);
-            if (senderId === void 0) continue;
-            t0 = Date.now();
-            insertMessage.run(
-              senderId,
-              msg.senderAccountName || null,
-              msg.senderGroupNickname || null,
-              dedupMessage.timestamp,
-              dedupMessage.type,
-              dedupMessage.content,
-              msg.replyToMessageId || null,
-              msg.platformMessageId || null
-            );
-            messageInsertTime += Date.now() - t0;
-            messageCountInBatch++;
-            totalMessageCount++;
-            t0 = Date.now();
-            trackNickname(accountNameTracker, msg.senderPlatformId, msg.senderAccountName, msg.timestamp);
-            trackNickname(groupNicknameTracker, msg.senderPlatformId, msg.senderGroupNickname, msg.timestamp);
-            nicknameTrackTime += Date.now() - t0;
-            nicknameChangeCount += accountNameTracker.get(msg.senderPlatformId)?.history.length === 1 ? 0 : 0;
-            if (messageCountInBatch >= BATCH_COMMIT_SIZE) {
-              const detail = `[Detail] Member lookup: ${memberLookupTime}ms (${memberLookupCount} times) | Member insert: ${memberInsertTime}ms (${memberInsertCount} times) | Message insert: ${messageInsertTime}ms | Nickname tracking: ${nicknameTrackTime}ms (${nicknameChangeCount} changes)`;
-              logger?.perfDetail(detail);
-              commitAndBeginNew();
-              messageCountInBatch = 0;
-              memberLookupTime = 0;
-              memberInsertTime = 0;
-              messageInsertTime = 0;
-              nicknameTrackTime = 0;
-              memberLookupCount = 0;
-              memberInsertCount = 0;
-              nicknameChangeCount = 0;
+              const senderGroupNickname = normalizeSystemMemberName(
+                formatFeature.id,
+                msg.senderPlatformId,
+                msg.senderGroupNickname
+              );
+              const prepared = prepareMessageForCreate(msg, senderAccountName);
+              if ("skipCounter" in prepared) {
+                callbackStats[prepared.skipCounter]++;
+                continue;
+              }
+              const dedupMessage = prepared.message;
+              if (registerMessageAndCheckDuplicate(dedupMessage, dedupState)) {
+                duplicateCount++;
+                continue;
+              }
+              if (!memberIdMap.has(msg.senderPlatformId)) {
+                insertMember.run(
+                  msg.senderPlatformId,
+                  senderAccountName || null,
+                  senderGroupNickname || null,
+                  "[]",
+                  null,
+                  "[]"
+                );
+                const row = getMemberId.get(msg.senderPlatformId);
+                if (row) memberIdMap.set(msg.senderPlatformId, row.id);
+              }
+              const senderId = memberIdMap.get(msg.senderPlatformId);
+              if (senderId === void 0) continue;
+              pendingRows.push({
+                senderId,
+                senderAccountName: senderAccountName || null,
+                senderGroupNickname: senderGroupNickname || null,
+                timestamp: dedupMessage.timestamp,
+                type: dedupMessage.type,
+                content: dedupMessage.content,
+                replyToMessageId: msg.replyToMessageId || null,
+                platformMessageId: msg.platformMessageId || null
+              });
+              messageCountInBatch++;
+              totalMessageCount++;
+              trackNickname(accountNameTracker, msg.senderPlatformId, senderAccountName, msg.timestamp);
+              trackNickname(groupNicknameTracker, msg.senderPlatformId, senderGroupNickname, msg.timestamp);
+              if (messageCountInBatch >= BATCH_COMMIT_SIZE) {
+                flushPendingRows();
+                commitAndBeginNew();
+                messageCountInBatch = 0;
+              }
             }
+            flushPendingRows();
+          } finally {
+            const nestedStageMs = messageTransactionMs - transactionMsBefore + (timings.checkpointMs - checkpointMsBefore);
+            timings.messageWriteMs += Math.max(0, elapsedMs(startedAt, now) - nestedStageMs);
+            sampleRss();
           }
         }
       },
       formatFeature.id
     );
+    finishParserTiming();
     if (inTransaction) {
-      db.exec("COMMIT");
-      inTransaction = false;
+      commitTransaction();
     }
+    timings.messageWriteMs += messageTransactionMs;
     onProgress({
       stage: "saving",
       bytesRead: 0,
@@ -8017,6 +8520,7 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
     });
     await yieldToEventLoop();
     logger?.perf("Writing nickname history", totalMessageCount);
+    const nicknameHistoryStartedAt = now();
     db.exec("BEGIN TRANSACTION");
     let historyCount = 0;
     flushNicknameHistory(accountNameTracker, "account_name", memberIdMap, insertNameHistory, updateMemberAccountName);
@@ -8029,6 +8533,8 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
     );
     historyCount = countHistory(accountNameTracker) + countHistory(groupNicknameTracker);
     db.exec("COMMIT");
+    timings.nicknameHistoryMs = elapsedMs(nicknameHistoryStartedAt, now);
+    sampleRss();
     logger?.perf(`Nickname history written (${historyCount} entries)`, totalMessageCount);
     onProgress({
       stage: "indexing",
@@ -8040,13 +8546,20 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
     });
     await yieldToEventLoop();
     logger?.perf("Creating indexes", totalMessageCount);
+    const indexCreationStartedAt = now();
     db.exec(CHAT_DB_INDEXES);
+    timings.indexCreationMs = elapsedMs(indexCreationStartedAt, now);
+    sampleRss();
     logger?.perf("Indexes created", totalMessageCount);
+    const ftsStartedAt = now();
     try {
       buildFtsIndex(db);
       logger?.perf("FTS index built", totalMessageCount);
     } catch (ftsError) {
       logger?.error("FTS index build failed (non-fatal)", ftsError instanceof Error ? ftsError : void 0);
+    } finally {
+      timings.ftsMs = elapsedMs(ftsStartedAt, now);
+      sampleRss();
     }
     onProgress({
       stage: "indexing",
@@ -8057,18 +8570,36 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
       message: ""
     });
     await yieldToEventLoop();
-    doCheckpoint();
+    measureCheckpoint();
+    sampleRss();
     logger?.perf("WAL checkpoint done", totalMessageCount);
+    const sessionIndexStartedAt = now();
+    const sessionGapThreshold = normalizeSessionGapThreshold(deps.sessionGapThreshold);
     try {
-      generateSessionIndex(db);
+      const generateSessionIndex2 = deps.generateSessionIndex ?? generateSessionIndex;
+      generateSessionIndex2(db, sessionGapThreshold);
+      logger?.perfDetail(`[SessionIndex] Built with gap threshold ${sessionGapThreshold}s`);
       logger?.perf("Session index built", totalMessageCount);
-    } catch {
+    } catch (error) {
+      logger?.error("Session index build failed (non-fatal)", error instanceof Error ? error : void 0);
+    } finally {
+      timings.sessionIndexMs = elapsedMs(sessionIndexStartedAt, now);
+      sampleRss();
     }
-    try {
-      await deps.postImportHook?.(db, sessionId);
-      if (deps.postImportHook) logger?.perf("Post-import hook done", totalMessageCount);
-    } catch {
+    if (deps.postImportHook) {
+      const postImportHookStartedAt = now();
+      try {
+        await deps.postImportHook(db, sessionId);
+        logger?.perf("Post-import hook done", totalMessageCount);
+      } catch {
+      } finally {
+        timings.postImportHookMs = elapsedMs(postImportHookStartedAt, now);
+        sampleRss();
+      }
     }
+    logger?.perfDetail(
+      `[Stages] parser=${timings.parserMs.toFixed(1)}ms | message-write=${timings.messageWriteMs.toFixed(1)}ms | indexes=${timings.indexCreationMs.toFixed(1)}ms | fts=${timings.ftsMs.toFixed(1)}ms | session-index=${timings.sessionIndexMs.toFixed(1)}ms | hook=${timings.postImportHookMs.toFixed(1)}ms`
+    );
     logger?.perf("Import completed", totalMessageCount);
     logger?.info(`=== Parser Callback Stats ===`);
     logger?.info(`onProgress calls: ${callbackStats.onProgressCalls}`);
@@ -8100,6 +8631,7 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
       importError = "error.no_messages";
     }
   } catch (error) {
+    finishParserTiming();
     logger?.error("Import failed", error instanceof Error ? error : void 0);
     if (inTransaction) {
       try {
@@ -8117,7 +8649,10 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
     if (shouldDeleteDb) {
       deps.deleteDatabase(sessionId);
     }
+    sampleRss();
   }
+  timings.totalMs = elapsedMs(totalStartedAt, now);
+  const bytesPerMegabyte = 1024 * 1024;
   const diagnostics = {
     logFile: logger?.getCurrentLogFile() ?? null,
     detectedFormat: formatFeature ? `${formatFeature.name} (${formatFeature.id})` : null,
@@ -8130,12 +8665,21 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
       noAccountName: callbackStats.skippedNoAccountName,
       invalidTimestamp: callbackStats.skippedInvalidTimestamp,
       noType: callbackStats.skippedNoType
+    },
+    performance: {
+      timings,
+      messageBatchCount: callbackStats.onMessageBatchCalls,
+      messageTransactionCount,
+      messageInsertStatementCount,
+      rssStartMb: rssStartBytes / bytesPerMegabyte,
+      rssSampledPeakMb: rssPeakBytes / bytesPerMegabyte,
+      rssSampledDeltaMb: (rssPeakBytes - rssStartBytes) / bytesPerMegabyte
     }
   };
   if (importError) {
-    return { success: false, error: importError, diagnostics };
+    return { success: false, platform: importedPlatform, error: importError, diagnostics };
   }
-  return { success: true, sessionId, diagnostics };
+  return { success: true, sessionId, platform: importedPlatform, diagnostics };
 }
 async function analyzeNewImport(filePath, onProgress, options2) {
   const formatFeature = options2?.formatId ? getFormatFeatureById(options2.formatId) : detectFormat(filePath);
@@ -8396,11 +8940,13 @@ async function analyzeIncrementalImport(sessionId, filePath, deps, options2) {
   let totalInFile = 0;
   let newMessageCount = 0;
   let duplicateCount = 0;
+  let platform = formatFeature.platform;
   await streamParseFile(
     filePath,
     {
       formatOptions: options2?.chatIndex === void 0 ? void 0 : { chatIndex: options2.chatIndex },
-      onMeta: () => {
+      onMeta: (meta) => {
+        platform = meta.platform;
       },
       onMembers: () => {
       },
@@ -8422,7 +8968,7 @@ async function analyzeIncrementalImport(sessionId, filePath, deps, options2) {
     },
     options2?.formatId
   );
-  return { newMessageCount, duplicateCount, totalInFile };
+  return { newMessageCount, duplicateCount, totalInFile, platform };
 }
 async function incrementalImport(sessionId, filePath, deps, options2) {
   const formatFeature = options2?.formatId ? getFormatFeatureById(options2.formatId) : detectFormat(filePath);
@@ -8439,7 +8985,7 @@ async function incrementalImport(sessionId, filePath, deps, options2) {
   const memberUpdateMode = options2?.memberUpdateMode ?? "upsert";
   try {
     let trackError2 = function(index, reason, detail) {
-      errorCount2++;
+      errorCount++;
       errorReasonCounts[reason] = (errorReasonCounts[reason] || 0) + 1;
       if (errorSamples.length < MAX_ERROR_SAMPLES) {
         errorSamples.push({ index, reason, detail });
@@ -8488,7 +9034,7 @@ async function incrementalImport(sessionId, filePath, deps, options2) {
     let metaUpdated = false;
     let membersAdded = 0;
     let membersUpdated = 0;
-    let errorCount2 = 0;
+    let errorCount = 0;
     const errorReasonCounts = {};
     const errorSamples = [];
     const MAX_ERROR_SAMPLES = 5;
@@ -8513,10 +9059,12 @@ async function incrementalImport(sessionId, filePath, deps, options2) {
           if (memberUpdateMode === "none") return;
           for (const m of members) {
             const existed = memberIdMap.has(m.platformId);
+            const accountName = normalizeSystemMemberName(formatFeature.id, m.platformId, m.accountName);
+            const groupNickname = normalizeSystemMemberName(formatFeature.id, m.platformId, m.groupNickname);
             upsertMember.run(
               m.platformId,
-              m.accountName || null,
-              m.groupNickname || null,
+              accountName || null,
+              groupNickname || null,
               m.aliases ? JSON.stringify(m.aliases) : "[]",
               m.avatar || null,
               m.roles ? JSON.stringify(m.roles) : "[]"
@@ -8553,12 +9101,22 @@ async function incrementalImport(sessionId, filePath, deps, options2) {
               duplicateCount++;
               continue;
             }
+            const senderAccountName = normalizeSystemMemberName(
+              formatFeature.id,
+              msg.senderPlatformId,
+              msg.senderAccountName
+            );
+            const senderGroupNickname = normalizeSystemMemberName(
+              formatFeature.id,
+              msg.senderPlatformId,
+              msg.senderGroupNickname
+            );
             let memberId = memberIdMap.get(msg.senderPlatformId);
             if (!memberId) {
               insertMemberMinimal.run(
                 msg.senderPlatformId,
-                msg.senderAccountName || null,
-                msg.senderGroupNickname || null,
+                senderAccountName || null,
+                senderGroupNickname || null,
                 null
               );
               const row = getMemberId.get(msg.senderPlatformId);
@@ -8571,8 +9129,8 @@ async function incrementalImport(sessionId, filePath, deps, options2) {
             if (!memberId) continue;
             const msgResult = insertMessage.run(
               memberId,
-              msg.senderAccountName || null,
-              msg.senderGroupNickname || null,
+              senderAccountName || null,
+              senderGroupNickname || null,
               timestamp,
               msg.type,
               msg.content || null,
@@ -8612,10 +9170,11 @@ async function incrementalImport(sessionId, filePath, deps, options2) {
     }
     if (newMessageCount > 0) {
       try {
+        const sessionGapThreshold = getSessionIndexStats(db).gapThreshold;
         if (minWrittenTs < preWriteMaxTs) {
-          generateSessionIndex(db);
+          generateSessionIndex(db, sessionGapThreshold);
         } else {
-          generateIncrementalSessionIndex(db);
+          generateIncrementalSessionIndex(db, sessionGapThreshold);
         }
       } catch {
       }
@@ -8627,7 +9186,7 @@ async function incrementalImport(sessionId, filePath, deps, options2) {
            MAX(ts) as lastTimestamp
          FROM message`
     ).get();
-    const memberCountRow = db.prepare("SELECT COUNT(*) as count FROM member").get();
+    const memberCountRow = db.prepare(`SELECT COUNT(*) as count FROM member WHERE COALESCE(account_name, '') != ?`).get(SYSTEM_MEMBER_NAME);
     try {
       await deps.postImportHook?.(db, sessionId);
     } catch {
@@ -8648,7 +9207,7 @@ async function incrementalImport(sessionId, filePath, deps, options2) {
         receivedCount: processedCount,
         writtenCount: newMessageCount,
         duplicateCount,
-        errorCount: errorCount2,
+        errorCount,
         errorReasonCounts,
         errorSample: errorSamples
       },
@@ -8682,6 +9241,7 @@ function isValidImportSessionId(sessionId) {
 }
 
 // ../../packages/node-runtime/src/import/auto-import-matcher.ts
+import { createHash as createHash2 } from "crypto";
 var MATCH_WINDOW_SIZE = 5;
 function buildPrivateIdentity(ownerId, memberIds) {
   if (!ownerId) return null;
@@ -8700,6 +9260,9 @@ function addMessageWindow(recentKeys, windows, message) {
   if (recentKeys.length === MATCH_WINDOW_SIZE) windows.add(recentKeys.join(""));
 }
 async function resolveAutoImportTarget(filePath, deps, formatOptions) {
+  return (await resolveAutoImportTargetPlan(filePath, deps, formatOptions)).decision;
+}
+async function resolveAutoImportTargetPlan(filePath, deps, formatOptions) {
   let sourceMeta = null;
   const sourceMemberIds = /* @__PURE__ */ new Set();
   const sourceWindows = /* @__PURE__ */ new Set();
@@ -8730,6 +9293,8 @@ async function resolveAutoImportTarget(filePath, deps, formatOptions) {
   const meta = sourceMeta;
   const privateIdentity = meta.type === "private" ? buildPrivateIdentity(meta.ownerId, sourceMemberIds) : null;
   const hasStableIdentity = Boolean(meta.groupId || privateIdentity);
+  const stableIdentity = meta.groupId ? `group\0${meta.groupId}` : privateIdentity ? `private\0${privateIdentity}` : null;
+  const stableConcurrencyKey = stableIdentity ? `source:${createHash2("sha256").update(`${meta.platform}\0${meta.type}\0${stableIdentity}`).digest("hex")}` : null;
   const stableMatches = [];
   const trailingMatches = [];
   for (const sessionId of deps.listSessionIds()) {
@@ -8774,24 +9339,62 @@ async function resolveAutoImportTarget(filePath, deps, formatOptions) {
   }
   if (hasStableIdentity) {
     if (meta.sourceSessionId && stableMatches.includes(meta.sourceSessionId)) {
-      return { action: "incremental", sessionId: meta.sourceSessionId, matchedBy: "source-session-id" };
+      return {
+        decision: { action: "incremental", sessionId: meta.sourceSessionId, matchedBy: "source-session-id" },
+        concurrencyKey: `session:${meta.sourceSessionId}`,
+        exclusive: false,
+        coalesceCreate: false
+      };
     }
     if (stableMatches.length === 1) {
-      return { action: "incremental", sessionId: stableMatches[0], matchedBy: "stable-id" };
+      return {
+        decision: { action: "incremental", sessionId: stableMatches[0], matchedBy: "stable-id" },
+        concurrencyKey: `session:${stableMatches[0]}`,
+        exclusive: false,
+        coalesceCreate: false
+      };
     }
   }
   if (meta.sourceSessionId && trailingMatches.includes(meta.sourceSessionId)) {
-    return { action: "incremental", sessionId: meta.sourceSessionId, matchedBy: "source-session-id" };
+    return {
+      decision: { action: "incremental", sessionId: meta.sourceSessionId, matchedBy: "source-session-id" },
+      concurrencyKey: `session:${meta.sourceSessionId}`,
+      exclusive: false,
+      coalesceCreate: false
+    };
   }
   if (trailingMatches.length === 1) {
-    return { action: "incremental", sessionId: trailingMatches[0], matchedBy: "trailing-messages" };
+    return {
+      decision: { action: "incremental", sessionId: trailingMatches[0], matchedBy: "trailing-messages" },
+      concurrencyKey: `session:${trailingMatches[0]}`,
+      exclusive: false,
+      coalesceCreate: false
+    };
   }
   const ambiguous = stableMatches.length > 1 || trailingMatches.length > 1;
-  return { action: "create", reason: ambiguous ? "ambiguous" : "no-match" };
+  const decision = { action: "create", reason: ambiguous ? "ambiguous" : "no-match" };
+  if (!ambiguous && stableConcurrencyKey) {
+    return {
+      decision,
+      concurrencyKey: stableConcurrencyKey,
+      exclusive: false,
+      coalesceCreate: true
+    };
+  }
+  return {
+    decision,
+    concurrencyKey: "unresolved",
+    exclusive: true,
+    coalesceCreate: false
+  };
 }
 
 // ../../packages/node-runtime/src/import/auto-importer.ts
 async function planAutoImport(filePath, deps, options2) {
+  if (options2.resolvedDecision) {
+    const decision2 = options2.resolvedDecision;
+    return decision2.action === "incremental" ? { action: "incremental", sessionId: decision2.sessionId, matchedBy: decision2.matchedBy } : { action: "create", reason: decision2.reason };
+  }
   if (options2.explicitSessionId) {
     if (!isValidImportSessionId(options2.explicitSessionId)) {
       throw new Error("sessionId contains invalid characters");
@@ -8807,11 +9410,17 @@ async function planAutoImport(filePath, deps, options2) {
 }
 function mapCreateResult(result, createReason) {
   if (!result.success || !result.sessionId) {
-    return { success: false, error: result.error, diagnostics: result.diagnostics };
+    return {
+      success: false,
+      ...result.platform !== void 0 ? { platform: result.platform } : {},
+      error: result.error,
+      diagnostics: result.diagnostics
+    };
   }
   return {
     success: true,
     sessionId: result.sessionId,
+    platform: result.platform,
     importMode: "created",
     ...createReason ? { createReason } : {},
     newMessageCount: result.diagnostics?.messagesWritten ?? 0,
@@ -8825,12 +9434,15 @@ function mapCreateResult(result, createReason) {
   };
 }
 function mapIncrementalResult(sessionId, result, matchedBy) {
-  if (!result.success) return { success: false, sessionId, error: result.error };
-  return {
-    success: true,
+  const incrementalResult = {
     sessionId,
     importMode: "incremental",
-    ...matchedBy ? { matchedBy } : {},
+    ...matchedBy ? { matchedBy } : {}
+  };
+  if (!result.success) return { success: false, ...incrementalResult, error: result.error };
+  return {
+    success: true,
+    ...incrementalResult,
     newMessageCount: result.newMessageCount,
     duplicateCount: result.batch?.duplicateCount ?? 0,
     batch: result.batch,
@@ -8839,17 +9451,18 @@ function mapIncrementalResult(sessionId, result, matchedBy) {
   };
 }
 async function autoImportFile(filePath, deps, options2 = {}) {
+  let plan;
   try {
     if (!options2.explicitSessionId) {
       appLogger.info("import", "Automatic session matching started", {
         candidateCount: deps.listSessionIds().length
       });
     }
-    const plan = await planAutoImport(filePath, deps, options2);
+    plan = await planAutoImport(filePath, deps, options2);
     if (plan.action === "incremental") {
       const result2 = mapIncrementalResult(
         plan.sessionId,
-        await deps.appendSession(plan.sessionId, filePath, options2.formatOptions),
+        await deps.appendSession(plan.sessionId, filePath, options2.formatOptions, deps.onProgress),
         plan.matchedBy
       );
       appLogger.info("import", "Incremental import completed", {
@@ -8862,7 +9475,7 @@ async function autoImportFile(filePath, deps, options2 = {}) {
       return result2;
     }
     const result = mapCreateResult(
-      await deps.createSession(filePath, options2.formatOptions, plan.sessionId),
+      await deps.createSession(filePath, options2.formatOptions, plan.sessionId, deps.onProgress),
       plan.reason
     );
     appLogger.info("import", "Import created a new session", {
@@ -8873,7 +9486,15 @@ async function autoImportFile(filePath, deps, options2 = {}) {
     return result;
   } catch (error) {
     appLogger.error("import", "Automatic import failed", error);
-    return { success: false, error: error instanceof Error ? error.message : String(error) };
+    return {
+      success: false,
+      ...plan?.action === "incremental" ? {
+        sessionId: plan.sessionId,
+        importMode: "incremental",
+        ...plan.matchedBy ? { matchedBy: plan.matchedBy } : {}
+      } : {},
+      error: error instanceof Error ? error.message : String(error)
+    };
   }
 }
 async function analyzeAutoImportFile(filePath, deps, options2 = {}) {
@@ -8924,6 +9545,221 @@ async function analyzeAutoImportFile(filePath, deps, options2 = {}) {
   }
 }
 
+// ../../packages/node-runtime/src/import/batch-coordinator.ts
+import { cpus, totalmem } from "os";
+function normalizeBatchConcurrency(value, taskCount) {
+  if (taskCount <= 0) return 0;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) return 1;
+  return Math.min(value, taskCount);
+}
+function resolveDefaultBatchConcurrency(taskCount, resources = {}) {
+  if (taskCount <= 0) return 0;
+  const cpuCount = resources.cpuCount ?? cpus().length;
+  const totalMemoryBytes = resources.totalMemoryBytes ?? totalmem();
+  const lowResourceRuntime = cpuCount < 4 || totalMemoryBytes < 4 * 1024 * 1024 * 1024;
+  return Math.min(taskCount, lowResourceRuntime ? 1 : 2);
+}
+async function runKeyedBatch(tasks, options2) {
+  if (tasks.length === 0) return [];
+  const concurrency = normalizeBatchConcurrency(options2.concurrency, tasks.length);
+  const results = Array(tasks.length);
+  const pending = new Set(tasks.map((_, index) => index));
+  const activeKeys = /* @__PURE__ */ new Set();
+  let activeCount = 0;
+  let exclusiveActive = false;
+  return new Promise((resolve4) => {
+    const finishIfDone = () => {
+      if (activeCount !== 0 || pending.size !== 0) return false;
+      options2.signal?.removeEventListener("abort", schedule);
+      resolve4(results);
+      return true;
+    };
+    const cancelPending = () => {
+      if (!options2.signal?.aborted) return;
+      for (const index of pending) {
+        pending.delete(index);
+        const result = { status: "cancelled" };
+        results[index] = result;
+        options2.onTaskComplete?.(tasks[index].value, index, result);
+      }
+    };
+    const findRunnableIndex = () => {
+      if (exclusiveActive) return void 0;
+      for (const index of pending) {
+        const task = tasks[index];
+        if (task.exclusive) return activeCount === 0 ? index : void 0;
+        if (!activeKeys.has(task.key)) return index;
+      }
+      return void 0;
+    };
+    function schedule() {
+      cancelPending();
+      if (finishIfDone()) return;
+      while (activeCount < concurrency && !options2.signal?.aborted) {
+        const index = findRunnableIndex();
+        if (index === void 0) break;
+        const task = tasks[index];
+        pending.delete(index);
+        activeCount++;
+        activeKeys.add(task.key);
+        if (task.exclusive) exclusiveActive = true;
+        options2.onTaskStart?.(task.value, index);
+        void Promise.resolve().then(() => options2.run(task.value, index)).then(
+          (value) => ({ status: "success", value }),
+          (error) => ({
+            status: "failed",
+            error: error instanceof Error ? error.message : String(error)
+          })
+        ).then((result) => {
+          results[index] = result;
+          options2.onTaskComplete?.(task.value, index, result);
+        }).finally(() => {
+          activeCount--;
+          activeKeys.delete(task.key);
+          if (task.exclusive) exclusiveActive = false;
+          schedule();
+        });
+      }
+    }
+    options2.signal?.addEventListener("abort", schedule, { once: true });
+    schedule();
+  });
+}
+
+// ../../packages/node-runtime/src/import/auto-import-batch.ts
+function mapTaskResult(item, result) {
+  if (result.status === "cancelled") return { id: item.id, status: "cancelled" };
+  if (result.status === "failed") return { id: item.id, status: "failed", error: result.error };
+  if (!result.value.success) {
+    return {
+      id: item.id,
+      status: "failed",
+      error: result.value.error ?? "Import failed",
+      result: result.value
+    };
+  }
+  return { id: item.id, status: "success", result: result.value };
+}
+function preserveSerialTargetMatching(planned) {
+  let priorPlannedWrite = false;
+  for (const plannedItem of planned) {
+    let plan = plannedItem.plan;
+    if (priorPlannedWrite && !plannedItem.item.options?.explicitSessionId && !plan.exclusive) {
+      plan = {
+        ...plan,
+        concurrencyKey: `unresolved:${plannedItem.itemIndex}`,
+        exclusive: true,
+        coalesceCreate: false
+      };
+    }
+    plannedItem.plan = plan;
+    priorPlannedWrite = true;
+  }
+}
+async function autoImportBatch(items, deps, options2 = {}) {
+  if (items.length === 0) return [];
+  const resolvePlan = options2.resolveTargetPlan ?? resolveAutoImportTargetPlan;
+  const concurrency = normalizeBatchConcurrency(options2.concurrency, items.length);
+  appLogger.info("import-batch", "Batch import started", {
+    itemCount: items.length,
+    concurrency
+  });
+  const preflight = await runKeyedBatch(
+    items.map((item, index) => ({ value: { item, itemIndex: index }, key: `preflight:${index}` })),
+    {
+      concurrency,
+      signal: options2.signal,
+      onTaskStart: ({ item, itemIndex }) => options2.onItemStart?.(item, itemIndex),
+      run: async ({ item, itemIndex }) => {
+        const itemOptions = item.options ?? {};
+        if (itemOptions.explicitSessionId) {
+          const sessionId = itemOptions.explicitSessionId;
+          const decision = deps.sessionExists(sessionId) ? { action: "incremental", sessionId, matchedBy: "source-session-id" } : { action: "create", reason: "no-match" };
+          return {
+            item,
+            itemIndex,
+            plan: {
+              decision,
+              concurrencyKey: `session:${sessionId}`,
+              exclusive: false,
+              coalesceCreate: decision.action === "create"
+            }
+          };
+        }
+        return {
+          item,
+          itemIndex,
+          plan: await resolvePlan(
+            item.filePath,
+            {
+              ...deps,
+              onProgress: (progress) => options2.onItemProgress?.(item, itemIndex, progress)
+            },
+            itemOptions.formatOptions
+          )
+        };
+      }
+    }
+  );
+  const finalResults = Array(items.length);
+  const planned = [];
+  for (let index = 0; index < preflight.length; index++) {
+    const result = preflight[index];
+    if (result.status === "success") {
+      planned.push(result.value);
+      continue;
+    }
+    const mapped = result.status === "cancelled" ? { id: items[index].id, status: "cancelled" } : { id: items[index].id, status: "failed", error: result.error };
+    finalResults[index] = mapped;
+    options2.onItemComplete?.(items[index], index, mapped);
+  }
+  preserveSerialTargetMatching(planned);
+  const targetSessionByKey = /* @__PURE__ */ new Map();
+  await runKeyedBatch(
+    planned.map((plannedItem) => ({
+      value: plannedItem,
+      key: plannedItem.plan.concurrencyKey,
+      exclusive: plannedItem.plan.exclusive
+    })),
+    {
+      concurrency,
+      signal: options2.signal,
+      onTaskComplete: ({ item, itemIndex }, _plannedIndex, taskResult) => {
+        const mapped = mapTaskResult(item, taskResult);
+        finalResults[itemIndex] = mapped;
+        options2.onItemComplete?.(item, itemIndex, mapped);
+      },
+      run: async ({ item, itemIndex, plan }) => {
+        const targetSessionId = plan.coalesceCreate ? targetSessionByKey.get(plan.concurrencyKey) : void 0;
+        const decision = targetSessionId ? { action: "incremental", sessionId: targetSessionId, matchedBy: "trailing-messages" } : plan.decision;
+        const result = await autoImportFile(
+          item.filePath,
+          {
+            ...deps,
+            onProgress: (progress) => options2.onItemProgress?.(item, itemIndex, progress)
+          },
+          {
+            ...item.options,
+            resolvedDecision: plan.exclusive || item.options?.explicitSessionId && !targetSessionId ? void 0 : decision
+          }
+        );
+        if (!plan.exclusive && result.success && result.sessionId) {
+          targetSessionByKey.set(plan.concurrencyKey, result.sessionId);
+        }
+        return result;
+      }
+    }
+  );
+  const completedResults = finalResults;
+  appLogger.info("import-batch", "Batch import completed", {
+    itemCount: items.length,
+    successCount: completedResults.filter((result) => result.status === "success").length,
+    failedCount: completedResults.filter((result) => result.status === "failed").length,
+    cancelledCount: completedResults.filter((result) => result.status === "cancelled").length
+  });
+  return completedResults;
+}
+
 // ../../packages/node-runtime/src/import/import-lock.ts
 import * as fs22 from "fs";
 import * as path14 from "path";
@@ -9758,8 +10594,8 @@ var AssistantManager = class {
   }
   // ==================== Init ====================
   init() {
-    const { fs: fs36, assistantsDir } = this.deps;
-    fs36.ensureDir(assistantsDir);
+    const { fs: fs37, assistantsDir } = this.deps;
+    fs37.ensureDir(assistantsDir);
     const { generalCreated, generalUpdated } = this.syncGeneralAssistants();
     this.loadAll();
     this.initialized = true;
@@ -9771,25 +10607,25 @@ var AssistantManager = class {
     return { total: this.cache.size, generalCreated, generalUpdated };
   }
   syncGeneralAssistants() {
-    const { fs: fs36, assistantsDir } = this.deps;
+    const { fs: fs37, assistantsDir } = this.deps;
     let generalCreated = false;
     let generalUpdated = false;
     for (const id of this.generalIds) {
       const config = this.getBuiltinConfig(id);
       if (!config) continue;
-      const filePath = fs36.joinPath(assistantsDir, `${id}.md`);
-      if (!fs36.fileExists(filePath)) {
-        fs36.writeFile(filePath, serializeAssistant(this.withBuiltinTracking(config)));
+      const filePath = fs37.joinPath(assistantsDir, `${id}.md`);
+      if (!fs37.fileExists(filePath)) {
+        fs37.writeFile(filePath, serializeAssistant(this.withBuiltinTracking(config)));
         generalCreated = true;
         continue;
       }
       try {
-        const existing = parseAssistantFile(fs36.readFile(filePath), filePath);
+        const existing = parseAssistantFile(fs37.readFile(filePath), filePath);
         if (!existing) continue;
         if (existing.builtinId !== id) {
           try {
             const backupId = this.backupAssistantOccupyingReservedId(existing);
-            fs36.writeFile(filePath, serializeAssistant(this.withBuiltinTracking(config)));
+            fs37.writeFile(filePath, serializeAssistant(this.withBuiltinTracking(config)));
             generalCreated = true;
             this.deps.logger?.info("AssistantManager", "Backed up assistant occupying reserved default ID", {
               reservedId: id,
@@ -9805,7 +10641,7 @@ var AssistantManager = class {
           continue;
         }
         if (!this.shouldUpgradeBuiltin(existing, config)) continue;
-        fs36.writeFile(filePath, serializeAssistant(this.withBuiltinTracking(config, existing.id)));
+        fs37.writeFile(filePath, serializeAssistant(this.withBuiltinTracking(config, existing.id)));
         generalUpdated = true;
         this.deps.logger?.info("AssistantManager", "Updated unmodified default assistant template", {
           id,
@@ -9821,14 +10657,14 @@ var AssistantManager = class {
     return { generalCreated, generalUpdated };
   }
   backupAssistantOccupyingReservedId(config) {
-    const { fs: fs36, assistantsDir } = this.deps;
+    const { fs: fs37, assistantsDir } = this.deps;
     const baseId = this.deps.generateId?.() || `custom_${Date.now().toString(36)}`;
     let backupId = baseId;
     let suffix = 2;
-    while (this.generalIds.includes(backupId) || fs36.fileExists(fs36.joinPath(assistantsDir, `${backupId}.md`))) {
+    while (this.generalIds.includes(backupId) || fs37.fileExists(fs37.joinPath(assistantsDir, `${backupId}.md`))) {
       backupId = `${baseId}_${suffix++}`;
     }
-    fs36.writeFile(fs36.joinPath(assistantsDir, `${backupId}.md`), serializeAssistant({ ...config, id: backupId }));
+    fs37.writeFile(fs37.joinPath(assistantsDir, `${backupId}.md`), serializeAssistant({ ...config, id: backupId }));
     return backupId;
   }
   getConfigDigest(config) {
@@ -9865,13 +10701,13 @@ var AssistantManager = class {
     return { isUnmodified, isOutdated };
   }
   loadAll() {
-    const { fs: fs36, assistantsDir } = this.deps;
+    const { fs: fs37, assistantsDir } = this.deps;
     this.cache.clear();
-    const files = fs36.listFiles(assistantsDir, ".md");
+    const files = fs37.listFiles(assistantsDir, ".md");
     for (const file of files) {
       try {
-        const filePath = fs36.joinPath(assistantsDir, file);
-        const content = fs36.readFile(filePath);
+        const filePath = fs37.joinPath(assistantsDir, file);
+        const content = fs37.readFile(filePath);
         const config = parseAssistantFile(content, filePath);
         if (config) {
           this.cache.set(config.id, config);
@@ -10094,7 +10930,7 @@ import Database from "better-sqlite3";
 import * as fs26 from "fs";
 import * as path20 from "path";
 var DEFAULT_GENERAL_ID = DEFAULT_GENERAL_ASSISTANT_ID;
-var defaultLogger = {
+var defaultLogger2 = {
   warn(_category, message, extra) {
     console.warn(`[AI Chats] ${message}`, extra ?? "");
   }
@@ -10107,7 +10943,7 @@ var AIChatManager = class {
   pendingDebugContextMap = /* @__PURE__ */ new Map();
   constructor(aiDataDir, options2) {
     this.aiDataDir = aiDataDir;
-    this.logger = options2?.logger ?? defaultLogger;
+    this.logger = options2?.logger ?? defaultLogger2;
     this.nativeBinding = options2?.nativeBinding;
   }
   ensureDir(dir) {
@@ -10361,16 +11197,16 @@ var AIChatManager = class {
     if (allRows.length === 0) return [];
     const rowMap = new Map(allRows.map((row) => [row.id, row]));
     let currentId = leafMessageId ?? this.getActiveMessageId(aiChatId);
-    const path30 = [];
+    const path31 = [];
     const seen = /* @__PURE__ */ new Set();
     while (currentId && !seen.has(currentId)) {
       seen.add(currentId);
       const row = rowMap.get(currentId);
       if (!row) break;
-      path30.push(row);
+      path31.push(row);
       currentId = row.parentId;
     }
-    return path30.length > 0 ? path30.reverse() : allRows;
+    return path31.length > 0 ? path31.reverse() : allRows;
   }
   // ==================== 生命周期 ====================
   close() {
@@ -10940,21 +11776,21 @@ var SkillManagerCore = class {
   }
   // ==================== Init ====================
   init() {
-    const { fs: fs36, skillsDir } = this.deps;
-    fs36.ensureDir(skillsDir);
+    const { fs: fs37, skillsDir } = this.deps;
+    fs37.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: fs36, skillsDir } = this.deps;
+    const { fs: fs37, skillsDir } = this.deps;
     this.cache.clear();
-    const files = fs36.listFiles(skillsDir, ".md");
+    const files = fs37.listFiles(skillsDir, ".md");
     for (const file of files) {
       try {
-        const filePath = fs36.joinPath(skillsDir, file);
-        const content = fs36.readFile(filePath);
+        const filePath = fs37.joinPath(skillsDir, file);
+        const content = fs37.readFile(filePath);
         const def = parseSkillFile(content, filePath);
         if (def) {
           this.cache.set(def.id, def);
@@ -11109,7 +11945,7 @@ var SkillManagerCore = class {
 import * as fs27 from "fs";
 import * as path21 from "path";
 var SKILLS_DIR_NAME = "skills";
-var defaultLogger2 = {
+var defaultLogger3 = {
   info: () => {
   },
   warn: () => {
@@ -11143,7 +11979,7 @@ var SkillManager = class {
   core;
   logger;
   constructor(aiDataDir, logger) {
-    this.logger = logger ?? defaultLogger2;
+    this.logger = logger ?? defaultLogger3;
     this.core = new SkillManagerCore({
       fs: nodeFs,
       skillsDir: path21.join(aiDataDir, SKILLS_DIR_NAME),
@@ -11566,7 +12402,7 @@ STRICT RULES:
 - Omit: pleasantries, filler, redundant back-and-forth, detailed tables (summarize their conclusions instead).
 
 {messages}`;
-var defaultLogger3 = {
+var defaultLogger4 = {
   info: () => {
   },
   warn: () => {
@@ -11574,7 +12410,7 @@ var defaultLogger3 = {
   error: () => {
   }
 };
-async function checkAndCompress(aiChatId, config, systemPrompt, llmAdapter, convManager, logger = defaultLogger3) {
+async function checkAndCompress(aiChatId, config, systemPrompt, llmAdapter, convManager, logger = defaultLogger4) {
   if (!config.enabled) {
     return { compressed: false, reason: "skipped_disabled" };
   }
@@ -11768,7 +12604,7 @@ function createCompressionLlmAdapter(options2) {
 
 // ../../packages/node-runtime/src/ai/preprocessor/pipeline.ts
 var MERGE_WINDOW_DEFAULT = 180;
-var defaultLogger4 = {
+var defaultLogger5 = {
   info: () => {
   },
   warn: () => {
@@ -11785,10 +12621,10 @@ function emptyStats(count) {
     desensitizeRulesApplied: 0
   };
 }
-function preprocessMessages(messages, config, logger = defaultLogger4) {
+function preprocessMessages(messages, config, logger = defaultLogger5) {
   return preprocessMessagesWithStats(messages, config, logger).messages;
 }
-function preprocessMessagesWithStats(messages, config, logger = defaultLogger4) {
+function preprocessMessagesWithStats(messages, config, logger = defaultLogger5) {
   if (!config || !hasAnyEnabled(config)) return { messages, stats: emptyStats(messages.length) };
   if (messages.length === 0) return { messages, stats: emptyStats(0) };
   const stats = emptyStats(messages.length);
@@ -11970,7 +12806,7 @@ function applyCompiledRules(text, compiledRules) {
   }
   return result;
 }
-function desensitizeText(text, rules, logger = defaultLogger4) {
+function desensitizeText(text, rules, logger = defaultLogger5) {
   const enabledRules = rules.filter((r) => r.enabled);
   if (enabledRules.length === 0 || !text) return text;
   return applyCompiledRules(text, compileRules(enabledRules, logger));
@@ -13008,7 +13844,7 @@ var PLAN_INTENTS = [
   "mixed"
 ];
 var STREAM_MARKER_HOLDBACK_CHARS = Math.max("</draft>".length, "</plan>".length, "<json>".length) - 1;
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isIntent(value) {
@@ -13030,10 +13866,10 @@ function extractJsonObject4(text) {
 function parsePlanJson(rawText, availableTools) {
   try {
     const parsed = JSON.parse(extractJsonObject4(rawText));
-    if (!isRecord2(parsed)) return null;
+    if (!isRecord3(parsed)) return null;
     const title = normalizeString(parsed.title);
     if (!title || !isIntent(parsed.intent) || !Array.isArray(parsed.steps)) return null;
-    const steps = parsed.steps.filter(isRecord2).map((step) => {
+    const steps = parsed.steps.filter(isRecord3).map((step) => {
       const goal = normalizeString(step.goal);
       const evidenceNeeded = normalizeString(step.evidenceNeeded);
       if (!goal || !evidenceNeeded) return null;
@@ -15012,9 +15848,9 @@ var localeMap = {
   "ja-JP": ja_JP_default,
   "zh-TW": zh_TW_default
 };
-function getNestedValue(obj, path30) {
+function getNestedValue(obj, path31) {
   let current = obj;
-  for (const segment2 of path30.split(".")) {
+  for (const segment2 of path31.split(".")) {
     if (current == null || typeof current !== "object") return void 0;
     current = current[segment2];
   }
@@ -15542,6 +16378,10 @@ var LLMConfigStore = class {
   hasActiveConfig() {
     return this.getDefaultAssistantConfig() !== null;
   }
+  hasConfiguredModel() {
+    const config = this.getDefaultAssistantConfig();
+    return typeof config?.model === "string" && config.model.trim().length > 0;
+  }
 };
 
 // ../../packages/node-runtime/src/ai/file-config-storage.ts
@@ -17116,7 +17956,7 @@ function setOwnerAndApplyProfile(adapter, preferences, sessionId, ownerPlatformI
   });
   return { sessionId, platform: meta.platform, ownerId: ownerPlatformId, updatedSessionIds, updatedSessionOwnerIds };
 }
-function applyProfileToOtherSessions(adapter, platform2, profile, excludeSessionId) {
+function applyProfileToOtherSessions(adapter, platform, profile, excludeSessionId) {
   const updated = [];
   for (const id of adapter.listSessionIds()) {
     if (id === excludeSessionId) continue;
@@ -17124,8 +17964,8 @@ function applyProfileToOtherSessions(adapter, platform2, profile, excludeSession
       const db = adapter.openReadonly(id);
       if (!db || !isChatSessionDb(db)) continue;
       const meta = getSessionMeta(db);
-      if (!meta || meta.platform !== platform2 || meta.ownerId) continue;
-      const result = matchOwnerProfile(platform2, profile, getMembersWithAliases(db));
+      if (!meta || meta.platform !== platform || meta.ownerId) continue;
+      const result = matchOwnerProfile(platform, profile, getMembersWithAliases(db));
       if (result.type === "exact" || result.type === "name") {
         updateSessionOwnerId(adapter.ensureWritable(id), result.platformId);
         updated.push({ id, ownerId: result.platformId });
@@ -17180,11 +18020,11 @@ function writeContactOverrides(snapshotDir, overrides) {
   fs29.renameSync(tmpPath, getContactOverridesPath(snapshotDir));
 }
 function normalizeContactOverrides(value) {
-  const input = isRecord3(value) ? value : {};
-  const manualFriendsInput = isRecord3(input.manualFriends) ? input.manualFriends : {};
+  const input = isRecord4(value) ? value : {};
+  const manualFriendsInput = isRecord4(input.manualFriends) ? input.manualFriends : {};
   const manualFriends = {};
   for (const [key, entry] of Object.entries(manualFriendsInput)) {
-    if (!key || !isRecord3(entry)) continue;
+    if (!key || !isRecord4(entry)) continue;
     const createdAt = Number.isFinite(entry.createdAt) ? Number(entry.createdAt) : Date.now();
     const updatedAt = Number.isFinite(entry.updatedAt) ? Number(entry.updatedAt) : createdAt;
     manualFriends[key] = { key, createdAt, updatedAt };
@@ -17194,7 +18034,7 @@ function normalizeContactOverrides(value) {
     manualFriends
   };
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -18727,11 +19567,130 @@ var SemanticIndexConfigStore = class {
   }
 };
 
+// ../../packages/node-runtime/src/semantic-index/embedding/text.ts
+function applyQueryInstruction(instruction, query) {
+  const trimmed = instruction.trim();
+  if (!trimmed) return query;
+  if (trimmed.endsWith(":") || trimmed.endsWith("\uFF1A")) return `${trimmed}${query}`;
+  return `Instruct: ${trimmed}
+Query: ${query}`;
+}
+function clampTextChars(text, maxChars) {
+  if (maxChars === void 0 || text.length <= maxChars) return text;
+  return text.slice(0, 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)) {
+    throw new Error(
+      `SOCKS proxy is not supported for local embedding model downloads: ${parsed.protocol}//${parsed.host}`
+    );
+  }
+  const { fetch: undiciFetch, ProxyAgent } = await import("./undici-MU5I3L6Q.mjs");
+  const dispatcher = new ProxyAgent(proxyUrl);
+  return ((input, init) => {
+    const nextInit = { ...init, dispatcher };
+    return undiciFetch(input, nextInit);
+  });
+}
+function createTransformersPipelineFactory(loadTransformers) {
+  return async ({ modelId, dtype, cacheDir, modelDownloadProxyUrl, modelDownloadSource }) => {
+    const transformers = await loadTransformers();
+    transformers.env.remoteHost = resolveModelDownloadRemoteHost(modelDownloadSource);
+    if (cacheDir) {
+      transformers.env.cacheDir = cacheDir;
+      transformers.env.allowRemoteModels = true;
+    }
+    if (modelDownloadProxyUrl) {
+      transformers.env.fetch = await createProxyFetch(modelDownloadProxyUrl);
+    }
+    const extractor = await transformers.pipeline("feature-extraction", modelId, {
+      ...dtype ? { dtype } : {},
+      session_options: LOCAL_ONNX_SESSION_OPTIONS
+    });
+    return async (texts, options2) => {
+      const out = await extractor(texts, { pooling: options2.pooling, normalize: options2.normalize });
+      return out.tolist();
+    };
+  };
+}
+var defaultPipelineFactory = createTransformersPipelineFactory(() => import("@huggingface/transformers"));
+var LocalEmbeddingProvider = class {
+  modelId;
+  dim;
+  maxTokens;
+  documentBatchSize;
+  profile;
+  options;
+  extractorPromise = null;
+  constructor(profile, options2 = {}) {
+    this.profile = profile;
+    this.options = options2;
+    this.modelId = profile.modelId;
+    this.dim = profile.dim;
+    this.maxTokens = profile.maxTokens;
+    this.documentBatchSize = profile.maxBatchSize ?? 1;
+  }
+  getExtractor() {
+    if (!this.extractorPromise) {
+      const factory = this.options.pipelineFactory ?? defaultPipelineFactory;
+      this.extractorPromise = factory({
+        modelId: this.profile.modelId,
+        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;
+        throw error;
+      });
+    }
+    return this.extractorPromise;
+  }
+  toFloat32(vector) {
+    if (vector.length !== this.profile.dim) {
+      throw new Error(`model ${this.profile.modelId} returned dim ${vector.length}, expected ${this.profile.dim}`);
+    }
+    return Float32Array.from(vector);
+  }
+  async embedDocuments(texts) {
+    if (texts.length === 0) return [];
+    const extractor = await this.getExtractor();
+    const batchSize = this.profile.maxBatchSize ?? texts.length;
+    const clamped = texts.map((t2) => clampTextChars(t2, this.profile.maxTextChars));
+    const result = [];
+    for (let i = 0; i < clamped.length; i += batchSize) {
+      const batch = clamped.slice(i, i + batchSize);
+      const vectors = await extractor(batch, { pooling: this.profile.pooling, normalize: this.profile.normalize });
+      for (const v of vectors) result.push(this.toFloat32(v));
+    }
+    return result;
+  }
+  async embedQuery(text) {
+    const withInstruction = applyQueryInstruction(this.profile.queryInstruction, text);
+    const [vector] = await this.embedDocuments([withInstruction]);
+    return vector;
+  }
+  async preload() {
+    await this.getExtractor();
+  }
+};
+
 // ../../packages/node-runtime/src/semantic-index/service.ts
 import path28 from "path";
 
 // ../../packages/node-runtime/src/semantic-index/chunker-config.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var CHUNKER_VERSION = "v1.3";
 var STRATEGY_ID = "balanced";
 var DEFAULT_CHUNKER_CONFIG = {
@@ -18746,7 +19705,7 @@ var DEFAULT_CHUNKER_CONFIG = {
   semanticVoidSkipThreshold: 20
 };
 function sha256Hex(input) {
-  return createHash2("sha256").update(input, "utf-8").digest("hex");
+  return createHash3("sha256").update(input, "utf-8").digest("hex");
 }
 function computeChunkerConfigHash(config) {
   const canonical = JSON.stringify({
@@ -18885,128 +19844,6 @@ var OpenAICompatibleEmbeddingProvider = class {
   }
 };
 
-// ../../packages/node-runtime/src/semantic-index/embedding/text.ts
-function applyQueryInstruction(instruction, query) {
-  const trimmed = instruction.trim();
-  if (!trimmed) return query;
-  if (trimmed.endsWith(":") || trimmed.endsWith("\uFF1A")) return `${trimmed}${query}`;
-  return `Instruct: ${trimmed}
-Query: ${query}`;
-}
-function clampTextChars(text, maxChars) {
-  if (maxChars === void 0 || text.length <= maxChars) return text;
-  return text.slice(0, 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)) {
-    throw new Error(
-      `SOCKS proxy is not supported for local embedding model downloads: ${parsed.protocol}//${parsed.host}`
-    );
-  }
-  const { fetch: undiciFetch, ProxyAgent } = await import("./undici-ZSXBT7EA.mjs");
-  const dispatcher = new ProxyAgent(proxyUrl);
-  return ((input, init) => {
-    const nextInit = { ...init, dispatcher };
-    return undiciFetch(input, nextInit);
-  });
-}
-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;
-  }
-  if (modelDownloadProxyUrl) {
-    transformers.env.fetch = await createProxyFetch(modelDownloadProxyUrl);
-  }
-  const extractor = await transformers.pipeline("feature-extraction", modelId, {
-    ...dtype ? { dtype } : {},
-    session_options: LOCAL_ONNX_SESSION_OPTIONS
-  });
-  return async (texts, options2) => {
-    const out = await extractor(texts, { pooling: options2.pooling, normalize: options2.normalize });
-    return out.tolist();
-  };
-};
-var LocalEmbeddingProvider = class {
-  modelId;
-  dim;
-  maxTokens;
-  documentBatchSize;
-  profile;
-  options;
-  extractorPromise = null;
-  constructor(profile, options2 = {}) {
-    this.profile = profile;
-    this.options = options2;
-    this.modelId = profile.modelId;
-    this.dim = profile.dim;
-    this.maxTokens = profile.maxTokens;
-    this.documentBatchSize = profile.maxBatchSize ?? 1;
-  }
-  getExtractor() {
-    if (!this.extractorPromise) {
-      const factory = this.options.pipelineFactory ?? defaultPipelineFactory;
-      this.extractorPromise = factory({
-        modelId: this.profile.modelId,
-        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;
-        throw error;
-      });
-    }
-    return this.extractorPromise;
-  }
-  toFloat32(vector) {
-    if (vector.length !== this.profile.dim) {
-      throw new Error(`model ${this.profile.modelId} returned dim ${vector.length}, expected ${this.profile.dim}`);
-    }
-    return Float32Array.from(vector);
-  }
-  async embedDocuments(texts) {
-    if (texts.length === 0) return [];
-    const extractor = await this.getExtractor();
-    const batchSize = this.profile.maxBatchSize ?? texts.length;
-    const clamped = texts.map((t2) => clampTextChars(t2, this.profile.maxTextChars));
-    const result = [];
-    for (let i = 0; i < clamped.length; i += batchSize) {
-      const batch = clamped.slice(i, i + batchSize);
-      const vectors = await extractor(batch, { pooling: this.profile.pooling, normalize: this.profile.normalize });
-      for (const v of vectors) result.push(this.toFloat32(v));
-    }
-    return result;
-  }
-  async embedQuery(text) {
-    const withInstruction = applyQueryInstruction(this.profile.queryInstruction, text);
-    const [vector] = await this.embedDocuments([withInstruction]);
-    return vector;
-  }
-  async preload() {
-    await this.getExtractor();
-  }
-};
-
 // ../../packages/node-runtime/src/semantic-index/embedding/profiles.ts
 var QWEN3_PROFILE = {
   displayName: "Qwen3 Embedding 0.6B",
@@ -19070,39 +19907,7 @@ function createEmbedder(config, deps = {}) {
 
 // ../../packages/node-runtime/src/semantic-index/store.ts
 import Database2 from "better-sqlite3";
-
-// ../../node_modules/sqlite-vec/index.mjs
-import { fileURLToPath } from "url";
-import { arch, platform } from "process";
-var BASE_PACKAGE_NAME = "sqlite-vec";
-var ENTRYPOINT_BASE_NAME = "vec0";
-var supportedPlatforms = [["darwin", "x64"], ["linux", "x64"], ["darwin", "arm64"], ["win32", "x64"], ["linux", "arm64"]];
-var invalidPlatformErrorMessage = `Unsupported platform for ${BASE_PACKAGE_NAME}, on a ${platform}-${arch} machine. Supported platforms are (${supportedPlatforms.map(([p, a]) => `${p}-${a}`).join(",")}). Consult the ${BASE_PACKAGE_NAME} NPM package README for details.`;
-function validPlatform(platform2, arch2) {
-  return supportedPlatforms.find(([p, a]) => platform2 === p && arch2 === a) !== void 0;
-}
-function extensionSuffix(platform2) {
-  if (platform2 === "win32") return "dll";
-  if (platform2 === "darwin") return "dylib";
-  return "so";
-}
-function platformPackageName(platform2, arch2) {
-  const os3 = platform2 === "win32" ? "windows" : platform2;
-  return `${BASE_PACKAGE_NAME}-${os3}-${arch2}`;
-}
-function getLoadablePath() {
-  if (!validPlatform(platform, arch)) {
-    throw new Error(
-      invalidPlatformErrorMessage
-    );
-  }
-  const packageName = platformPackageName(platform, arch);
-  const loadablePath = fileURLToPath(import.meta.resolve(packageName + "/" + ENTRYPOINT_BASE_NAME + "." + extensionSuffix(platform)));
-  return loadablePath;
-}
-function load(db) {
-  db.loadExtension(getLoadablePath());
-}
+import * as sqliteVec from "sqlite-vec";
 
 // ../../packages/node-runtime/src/semantic-index/schema.ts
 var CHUNK_VECTOR_INDEX_TABLE = `
@@ -19168,7 +19973,7 @@ function vecTableSchema(dim) {
 }
 
 // ../../packages/node-runtime/src/semantic-index/store.ts
-var defaultLoadSqliteVec = (db) => load(db);
+var defaultLoadSqliteVec = (db) => sqliteVec.load(db);
 function rowToRecord(row) {
   return {
     chunkId: row.chunk_id,
@@ -19614,7 +20419,7 @@ var SemanticIndexJobQueue = class {
 };
 
 // ../../packages/node-runtime/src/semantic-index/chunker.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 var VOID_MESSAGE_TYPES = /* @__PURE__ */ new Set([
   1 /* IMAGE */,
   2 /* VOICE */,
@@ -19697,7 +20502,7 @@ function sumEffectiveChars(messages) {
   return total;
 }
 function sha256Hex2(input) {
-  return createHash3("sha256").update(input, "utf-8").digest("hex");
+  return createHash4("sha256").update(input, "utf-8").digest("hex");
 }
 var EMBEDDING_HEADER_BUDGET_RATIO = 0.25;
 var SOURCE_TITLE_HEADER_SHARE = 1 / 3;
@@ -20273,7 +21078,8 @@ function createSemanticIndexService(params) {
     sessionAdapter: params.sessionAdapter,
     nativeBinding: params.nativeBinding,
     loadSqliteVec: params.loadSqliteVec,
-    embedderFactoryDeps: params.embedderFactoryDeps
+    embedderFactoryDeps: params.embedderFactoryDeps,
+    getLocalEmbeddingRuntimeStatus: params.getLocalEmbeddingRuntimeStatus
   });
 }
 var SemanticIndexService = class {
@@ -20328,7 +21134,8 @@ var SemanticIndexService = class {
    * 传入 apiKey 时写入固定 auth profile，config 内只保存引用，绝不持久化明文。
    */
   getModelStatus() {
-    return this.modelPreloadStatus;
+    if (this.modelPreloadStatus !== "downloading") return this.modelPreloadStatus;
+    return this.options.getLocalEmbeddingRuntimeStatus?.() === "installing" ? "installing-runtime" : "downloading-model";
   }
   setConfig(config, options2) {
     const saved = persistSemanticIndexConfig(this.configStore, config, {
@@ -20342,11 +21149,17 @@ var SemanticIndexService = class {
     if (!saved.enabled) {
       for (const state of this.stateStore.listEnabled()) this.queue.pause(state.dbPathHash);
     }
-    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";
+    this.startLocalModelPreload(saved, preloadGeneration);
+    return saved;
+  }
+  startLocalModelPreload(config, preloadGeneration, options2 = {}) {
+    if (!config.enabled || !isSemanticIndexConfigured(config) || config.mode !== "local") return;
+    const modelId = config.local.modelId;
+    const downloadSource = config.local.downloadSource ?? DEFAULT_SEMANTIC_INDEX_MODEL_DOWNLOAD_SOURCE;
+    const cacheDir = this.options.modelsCacheDir;
+    this.modelPreloadStatus = "downloading";
+    const run = () => {
+      if (preloadGeneration !== this.modelPreloadGeneration) return;
       appLogger.info("semantic-index", "local embedding model preload started", { modelId, downloadSource, cacheDir });
       void this.getEmbedder().preload?.().then(() => {
         if (preloadGeneration !== this.modelPreloadGeneration) return;
@@ -20365,8 +21178,9 @@ var SemanticIndexService = class {
           error
         );
       });
-    }
-    return saved;
+    };
+    if (options2.defer) queueMicrotask(run);
+    else run();
   }
   currentModelId() {
     return this.configStore.resolveModelId();
@@ -20742,6 +21556,8 @@ ${text}`;
         this.stateStore.setIndexStatus(state.dbPathHash, "paused");
       }
     }
+    const config = this.configStore.get();
+    this.startLocalModelPreload(config, ++this.modelPreloadGeneration, { defer: true });
   }
   // ---------- 队列执行 ----------
   resolveSource(db) {
@@ -20817,9 +21633,269 @@ ${text}`;
   }
 };
 
+// ../../packages/node-runtime/src/semantic-index/embedding/local-runtime.ts
+import { execFile } from "child_process";
+import fs34 from "fs";
+import { createRequire as createRequire2 } from "module";
+import path29 from "path";
+import { pathToFileURL } from "url";
+var LOCAL_EMBEDDING_RUNTIME_PACKAGE = "@huggingface/transformers";
+var LOCAL_EMBEDDING_RUNTIME_VERSION = "4.2.0";
+var RUNTIME_MANIFEST_FILE = "runtime.json";
+var VERIFY_RUNTIME_SCRIPT = `
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+const [, runtimeDir, transformersPackage] = process.argv
+const runtimeRequire = createRequire(path.join(runtimeDir, 'package.json'))
+const importFromRuntime = async (packageName) => {
+  const resolved = runtimeRequire.resolve(packageName)
+  return await import(pathToFileURL(resolved).href)
+}
+
+const transformers = await importFromRuntime(transformersPackage)
+if (typeof transformers.pipeline !== 'function' || typeof transformers.env !== 'object') {
+  throw new Error('Installed Transformers runtime does not expose the expected Node API.')
+}
+
+const onnxRuntime = await importFromRuntime('onnxruntime-node')
+if (typeof onnxRuntime.listSupportedBackends !== 'function') {
+  throw new Error('Installed ONNX runtime does not expose listSupportedBackends().')
+}
+`;
+function executeInstall(input) {
+  return new Promise((resolve4, reject) => {
+    execFile(
+      input.command,
+      input.args,
+      {
+        cwd: input.cwd,
+        env: { ...process.env, npm_config_update_notifier: "false" },
+        maxBuffer: 10 * 1024 * 1024,
+        shell: process.platform === "win32"
+      },
+      (error, _stdout, stderr) => {
+        if (!error) {
+          resolve4();
+          return;
+        }
+        reject(new Error(stderr.trim() || error.message, { cause: error }));
+      }
+    );
+  });
+}
+function verifyRuntimeInSubprocess(runtimeDir) {
+  return new Promise((resolve4, reject) => {
+    execFile(
+      process.execPath,
+      ["--input-type=module", "--eval", VERIFY_RUNTIME_SCRIPT, runtimeDir, LOCAL_EMBEDDING_RUNTIME_PACKAGE],
+      {
+        env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" },
+        maxBuffer: 10 * 1024 * 1024
+      },
+      (error, _stdout, stderr) => {
+        if (!error) {
+          resolve4();
+          return;
+        }
+        reject(new Error(stderr.trim() || error.message, { cause: error }));
+      }
+    );
+  });
+}
+function createRuntimeRequire(runtimeDir) {
+  return createRequire2(path29.join(runtimeDir, "package.json"));
+}
+async function importFromRuntime(runtimeDir, packageName) {
+  const resolved = createRuntimeRequire(runtimeDir).resolve(packageName);
+  return await import(pathToFileURL(resolved).href);
+}
+async function verifyInstalledRuntime(runtimeDir) {
+  const transformers = await importFromRuntime(runtimeDir, LOCAL_EMBEDDING_RUNTIME_PACKAGE);
+  if (typeof transformers.pipeline !== "function" || typeof transformers.env !== "object") {
+    throw new Error("Installed Transformers runtime does not expose the expected Node API.");
+  }
+  const onnxRuntime = await importFromRuntime(runtimeDir, "onnxruntime-node");
+  if (typeof onnxRuntime.listSupportedBackends !== "function") {
+    throw new Error("Installed ONNX runtime does not expose listSupportedBackends().");
+  }
+}
+async function loadInstalledTransformers(runtimeDir) {
+  return await importFromRuntime(
+    runtimeDir,
+    LOCAL_EMBEDDING_RUNTIME_PACKAGE
+  );
+}
+var LocalEmbeddingRuntimeManager = class {
+  baseDir;
+  installMode;
+  platform;
+  arch;
+  npmCommand;
+  runInstall;
+  verifyStagedRuntime;
+  verifyRuntime;
+  importTransformers;
+  status;
+  installPromise = null;
+  transformersPromise = null;
+  verifiedRuntimeDir = null;
+  constructor(options2) {
+    this.baseDir = options2.baseDir;
+    this.installMode = options2.installMode;
+    this.platform = options2.platform ?? process.platform;
+    this.arch = options2.arch ?? process.arch;
+    this.npmCommand = options2.npmCommand ?? (this.platform === "win32" ? "npm.cmd" : "npm");
+    this.runInstall = options2.runInstall ?? executeInstall;
+    this.verifyStagedRuntime = options2.verifyStagedRuntime ?? verifyRuntimeInSubprocess;
+    this.verifyRuntime = options2.verifyRuntime ?? verifyInstalledRuntime;
+    this.importTransformers = options2.importTransformers ?? loadInstalledTransformers;
+    this.status = "idle";
+  }
+  getStatus() {
+    return this.status;
+  }
+  getRuntimeDir() {
+    return path29.join(this.baseDir, `transformers-${LOCAL_EMBEDDING_RUNTIME_VERSION}`, `${this.platform}-${this.arch}`);
+  }
+  async ensureInstalled() {
+    if (!this.installPromise) {
+      this.installPromise = this.ensureInstalledOnce().finally(() => {
+        this.installPromise = null;
+      });
+    }
+    return await this.installPromise;
+  }
+  async loadTransformers() {
+    if (!this.transformersPromise) {
+      this.transformersPromise = this.ensureInstalled().then((runtimeDir) => this.importTransformers(runtimeDir)).catch((error) => {
+        this.transformersPromise = null;
+        throw error;
+      });
+    }
+    return await this.transformersPromise;
+  }
+  async ensureInstalledOnce() {
+    const runtimeDir = this.getRuntimeDir();
+    try {
+      if (this.hasCompleteLayout(runtimeDir)) {
+        try {
+          await this.verifyOnce(runtimeDir);
+          this.status = "ready";
+          return runtimeDir;
+        } catch (error) {
+          if (this.installMode === "preinstalled") throw error;
+          appLogger.warn("semantic-index", "Existing local embedding runtime is invalid; reinstalling", {
+            packageVersion: LOCAL_EMBEDDING_RUNTIME_VERSION,
+            platform: this.platform,
+            arch: this.arch,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          fs34.rmSync(runtimeDir, { recursive: true, force: true });
+          this.verifiedRuntimeDir = null;
+        }
+      }
+      if (this.installMode === "preinstalled") {
+        throw new Error(`Preinstalled local embedding runtime is missing or incomplete: ${runtimeDir}`);
+      }
+      this.status = "installing";
+      appLogger.info("semantic-index", "Local embedding runtime installation started", {
+        packageVersion: LOCAL_EMBEDDING_RUNTIME_VERSION,
+        platform: this.platform,
+        arch: this.arch
+      });
+      await this.installAtomically(runtimeDir);
+      await this.verifyOnce(runtimeDir);
+      this.status = "ready";
+      appLogger.info("semantic-index", "Local embedding runtime installation completed", {
+        packageVersion: LOCAL_EMBEDDING_RUNTIME_VERSION,
+        platform: this.platform,
+        arch: this.arch
+      });
+      return runtimeDir;
+    } catch (error) {
+      this.status = "error";
+      appLogger.error("semantic-index", "Local embedding runtime installation failed", error);
+      throw error;
+    }
+  }
+  async installAtomically(runtimeDir) {
+    const parentDir = path29.dirname(runtimeDir);
+    fs34.mkdirSync(parentDir, { recursive: true });
+    const stagingDir = fs34.mkdtempSync(path29.join(parentDir, ".installing-"));
+    try {
+      fs34.writeFileSync(
+        path29.join(stagingDir, "package.json"),
+        `${JSON.stringify({ private: true, type: "module" }, null, 2)}
+`,
+        "utf8"
+      );
+      await this.runInstall({
+        command: this.npmCommand,
+        args: [
+          "install",
+          "--omit=dev",
+          "--no-audit",
+          "--no-fund",
+          "--save-exact",
+          "--loglevel=error",
+          "--prefix",
+          stagingDir,
+          `${LOCAL_EMBEDDING_RUNTIME_PACKAGE}@${LOCAL_EMBEDDING_RUNTIME_VERSION}`
+        ],
+        cwd: stagingDir
+      });
+      await this.verifyStagedRuntime(stagingDir);
+      fs34.writeFileSync(path29.join(stagingDir, RUNTIME_MANIFEST_FILE), `${JSON.stringify(this.manifest(), null, 2)}
+`);
+      if (fs34.existsSync(runtimeDir)) {
+        if (this.hasCompleteLayout(runtimeDir)) return;
+        fs34.rmSync(runtimeDir, { recursive: true, force: true });
+      }
+      try {
+        fs34.renameSync(stagingDir, runtimeDir);
+      } catch (error) {
+        if (!this.hasCompleteLayout(runtimeDir)) throw error;
+      }
+    } finally {
+      fs34.rmSync(stagingDir, { recursive: true, force: true });
+    }
+  }
+  async verifyOnce(runtimeDir) {
+    if (this.verifiedRuntimeDir === runtimeDir) return;
+    await this.verifyRuntime(runtimeDir);
+    this.verifiedRuntimeDir = runtimeDir;
+  }
+  hasCompleteLayout(runtimeDir) {
+    const manifestPath = path29.join(runtimeDir, RUNTIME_MANIFEST_FILE);
+    const packagePath = path29.join(runtimeDir, "node_modules", "@huggingface", "transformers", "package.json");
+    if (!fs34.existsSync(manifestPath) || !fs34.existsSync(packagePath)) return false;
+    try {
+      const manifest = JSON.parse(fs34.readFileSync(manifestPath, "utf8"));
+      const expected = this.manifest();
+      return manifest.formatVersion === expected.formatVersion && manifest.packageName === expected.packageName && manifest.packageVersion === expected.packageVersion && manifest.platform === expected.platform && manifest.arch === expected.arch;
+    } catch {
+      return false;
+    }
+  }
+  manifest() {
+    return {
+      formatVersion: 1,
+      packageName: LOCAL_EMBEDDING_RUNTIME_PACKAGE,
+      packageVersion: LOCAL_EMBEDDING_RUNTIME_VERSION,
+      platform: this.platform,
+      arch: this.arch
+    };
+  }
+};
+function createLocalEmbeddingRuntimeManager(options2) {
+  return new LocalEmbeddingRuntimeManager(options2);
+}
+
 // ../../packages/node-runtime/src/services/merge-cache.ts
-import * as fs34 from "fs";
-import * as path29 from "path";
+import * as fs35 from "fs";
+import * as path30 from "path";
 import * as crypto from "crypto";
 var MergeSessionCache = class {
   cache = /* @__PURE__ */ new Map();
@@ -20828,15 +21904,15 @@ var MergeSessionCache = class {
   constructor(pathProvider, options2) {
     this.tempDir = pathProvider.getTempDir();
     this.nativeBinding = options2?.nativeBinding;
-    if (!fs34.existsSync(this.tempDir)) {
-      fs34.mkdirSync(this.tempDir, { recursive: true });
+    if (!fs35.existsSync(this.tempDir)) {
+      fs35.mkdirSync(this.tempDir, { recursive: true });
     }
   }
   generateTempDbPath(filename) {
     const ts = Date.now();
     const rand = Math.random().toString(36).slice(2, 8);
     const safeName = filename.replace(/[/\\?%*:|"<>]/g, "_").slice(0, 40);
-    return path29.join(this.tempDir, `merge_${safeName}_${ts}_${rand}.db`);
+    return path30.join(this.tempDir, `merge_${safeName}_${ts}_${rand}.db`);
   }
   /** Store a parsed file's temp DB and return a handle for subsequent requests. */
   store(filename, tempDbPath) {
@@ -20847,7 +21923,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 || !fs34.existsSync(entry.tempDbPath)) return null;
+    if (!entry || !fs35.existsSync(entry.tempDbPath)) return null;
     const adapter = openBetterSqliteDatabase(entry.tempDbPath, {
       readonly: true,
       nativeBinding: this.nativeBinding
@@ -20892,21 +21968,21 @@ var MergeSessionCache = class {
 };
 
 // ../../packages/node-runtime/src/services/push-importer.ts
-import * as fs35 from "fs";
-var SYSTEM_SENDER_ID = "SYSTEM";
-var SYSTEM_MEMBER_NAME = "\u7CFB\u7EDF\u6D88\u606F";
-function isRecord4(value) {
+import * as fs36 from "fs";
+var SYSTEM_SENDER_ID3 = "SYSTEM";
+var SYSTEM_MEMBER_NAME2 = "\u7CFB\u7EDF\u6D88\u606F";
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validateOptionalString2(value, field) {
   return value !== void 0 && typeof value !== "string" ? `${field} must be a string` : null;
 }
 function validatePayload(payload, isNew) {
-  if (!isRecord4(payload)) return "payload must be an object";
+  if (!isRecord5(payload)) return "payload must be an object";
   const messages = payload.messages;
   if (!Array.isArray(messages) || messages.length === 0) return "messages is required and must be a non-empty array";
   if (payload.chatlab !== void 0) {
-    if (!isRecord4(payload.chatlab)) return "chatlab must be an object";
+    if (!isRecord5(payload.chatlab)) return "chatlab must be an object";
     if (typeof payload.chatlab.version !== "string" || payload.chatlab.version.length === 0)
       return "chatlab.version must be a string";
     if (typeof payload.chatlab.exportedAt !== "number" || !Number.isFinite(payload.chatlab.exportedAt))
@@ -20919,7 +21995,7 @@ function validatePayload(payload, isNew) {
     if (!payload.meta) return "meta is required for new sessions";
   }
   if (payload.meta !== void 0) {
-    if (!isRecord4(payload.meta)) return "meta must be an object";
+    if (!isRecord5(payload.meta)) return "meta must be an object";
     const metaFields = ["name", "platform", "type", "groupId", "groupAvatar", "ownerId"];
     for (const field of metaFields) {
       const error = validateOptionalString2(payload.meta[field], `meta.${field}`);
@@ -20929,7 +22005,7 @@ function validatePayload(payload, isNew) {
     if (isNew && !payload.meta.platform) return "meta.platform is required";
     if (isNew && !payload.meta.type) return "meta.type is required";
   }
-  if (payload.options !== void 0 && !isRecord4(payload.options)) return "options must be an object";
+  if (payload.options !== void 0 && !isRecord5(payload.options)) return "options must be an object";
   const { metaUpdateMode, memberUpdateMode } = payload.options ?? {};
   if (metaUpdateMode !== void 0 && metaUpdateMode !== "patch" && metaUpdateMode !== "none") {
     return `options.metaUpdateMode must be 'patch' or 'none'`;
@@ -20941,7 +22017,7 @@ function validatePayload(payload, isNew) {
   if (payload.members) {
     for (let i = 0; i < payload.members.length; i++) {
       const member = payload.members[i];
-      if (!isRecord4(member)) return `members[${i}] must be an object`;
+      if (!isRecord5(member)) return `members[${i}] must be an object`;
       if (typeof member.platformId !== "string" || member.platformId.length === 0)
         return `members[${i}].platformId must be a string`;
       for (const field of ["accountName", "groupNickname", "avatar"]) {
@@ -20952,7 +22028,7 @@ function validatePayload(payload, isNew) {
         if (!Array.isArray(member.roles)) return `members[${i}].roles must be an array`;
         for (let j = 0; j < member.roles.length; j++) {
           const role = member.roles[j];
-          if (!isRecord4(role) || typeof role.id !== "string" || role.id.length === 0)
+          if (!isRecord5(role) || typeof role.id !== "string" || role.id.length === 0)
             return `members[${i}].roles[${j}].id must be a string`;
         }
       }
@@ -20960,7 +22036,7 @@ function validatePayload(payload, isNew) {
   }
   for (let i = 0; i < messages.length; i++) {
     const msg = messages[i];
-    if (!isRecord4(msg)) return `messages[${i}] must be an object`;
+    if (!isRecord5(msg)) return `messages[${i}] must be an object`;
     if (typeof msg.sender !== "string" || msg.sender.length === 0) return `messages[${i}].sender must be a string`;
     if (typeof msg.timestamp !== "number" || !Number.isFinite(msg.timestamp) || msg.timestamp <= 0)
       return `messages[${i}].timestamp must be a positive number`;
@@ -20980,17 +22056,17 @@ function validatePayload(payload, isNew) {
 }
 function queryStats(db) {
   const row = db.prepare("SELECT COUNT(*) as total, MIN(ts) as first, MAX(ts) as last FROM message").get();
-  const memberRow = db.prepare(`SELECT COUNT(*) as cnt FROM member WHERE COALESCE(account_name, '') != ?`).get(SYSTEM_MEMBER_NAME);
+  const memberRow = db.prepare(`SELECT COUNT(*) as cnt FROM member WHERE COALESCE(account_name, '') != ?`).get(SYSTEM_MEMBER_NAME2);
   return { totalCount: row.total, memberCount: memberRow.cnt, firstTimestamp: row.first, lastTimestamp: row.last };
 }
 function normalizeSenderAccountName(sender, accountName) {
-  return sender === SYSTEM_SENDER_ID ? SYSTEM_MEMBER_NAME : accountName;
+  return sender === SYSTEM_SENDER_ID3 ? SYSTEM_MEMBER_NAME2 : accountName;
 }
 function normalizeSenderGroupNickname(sender, groupNickname) {
-  return sender === SYSTEM_SENDER_ID ? SYSTEM_MEMBER_NAME : groupNickname;
+  return sender === SYSTEM_SENDER_ID3 ? SYSTEM_MEMBER_NAME2 : groupNickname;
 }
 function isCountedMember(platformId) {
-  return platformId !== SYSTEM_SENDER_ID;
+  return platformId !== SYSTEM_SENDER_ID3;
 }
 function registerPushMessageAndCheckDuplicate(message, dedupState) {
   return registerMessageAndCheckDuplicate(
@@ -21198,10 +22274,11 @@ function writeIncrementalImport(db, payload) {
   }
   if (writtenCount > 0) {
     try {
+      const sessionGapThreshold = getSessionIndexStats(db).gapThreshold;
       if (minWrittenTs < preWriteMaxTs) {
-        generateSessionIndex(db);
+        generateSessionIndex(db, sessionGapThreshold);
       } else {
-        generateIncrementalSessionIndex(db);
+        generateIncrementalSessionIndex(db, sessionGapThreshold);
       }
     } catch {
     }
@@ -21259,7 +22336,7 @@ async function executePushImportUnlocked(deps, sessionId, payload) {
     return { ok: false, reason: "invalid_payload", message: "sessionId contains invalid characters" };
   }
   const dbPath = deps.getDbPath(sessionId);
-  const isNew = !fs35.existsSync(dbPath);
+  const isNew = !fs36.existsSync(dbPath);
   const validationError = validatePayload(payload, isNew);
   if (validationError) {
     return { ok: false, reason: "invalid_payload", message: validationError };
@@ -21320,10 +22397,10 @@ async function executePushImportUnlocked(deps, sessionId, payload) {
 }
 
 // ../../packages/node-runtime/src/services/import-idempotency.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 var DEFAULT_IMPORT_IDEMPOTENCY_TTL_MS = 60 * 60 * 1e3;
 function hashImportBody(body) {
-  return createHash4("sha256").update(JSON.stringify(body ?? "")).digest("hex");
+  return createHash5("sha256").update(JSON.stringify(body ?? "")).digest("hex");
 }
 var ImportIdempotencyCache = class {
   constructor(ttlMs = DEFAULT_IMPORT_IDEMPOTENCY_TTL_MS) {
@@ -21366,6 +22443,7 @@ export {
   createChatLabTempDir,
   removeChatLabTempDir,
   validateChatLabFile,
+  rebaseChatLabDemoDocuments,
   detectFormat,
   detectAllFormats,
   getSupportedFormats,
@@ -21374,6 +22452,7 @@ export {
   findEntryFileInDirectory,
   logNativeParserStatus,
   LogLevel,
+  createImportPerfLogger,
   initPerfLog,
   logPerf,
   logPerfDetail,
@@ -21397,6 +22476,8 @@ export {
   rebuildFtsIndex,
   insertFtsEntries,
   searchByFts,
+  MESSAGE_INSERT_MAX_ROWS,
+  MessageBatchInserter,
   streamingImport,
   analyzeNewImport,
   streamParseFileInfo,
@@ -21404,8 +22485,13 @@ export {
   incrementalImport,
   isValidImportSessionId,
   resolveAutoImportTarget,
+  resolveAutoImportTargetPlan,
   autoImportFile,
   analyzeAutoImportFile,
+  normalizeBatchConcurrency,
+  resolveDefaultBatchConcurrency,
+  runKeyedBatch,
+  autoImportBatch,
   IMPORT_LOCK_FILENAME,
   IMPORT_IN_PROGRESS_ERROR_KEY,
   ImportInProgressError,
@@ -21554,6 +22640,7 @@ export {
   OpenAICompatibleEmbeddingProvider,
   applyQueryInstruction,
   clampTextChars,
+  createTransformersPipelineFactory,
   LocalEmbeddingProvider,
   QWEN3_PROFILE,
   BGE_BASE_PROFILE,
@@ -21579,6 +22666,9 @@ export {
   SEMANTIC_INDEX_CONFIG_FILE,
   createSemanticIndexService,
   SemanticIndexService,
+  LOCAL_EMBEDDING_RUNTIME_PACKAGE,
+  LOCAL_EMBEDDING_RUNTIME_VERSION,
+  createLocalEmbeddingRuntimeManager,
   MergeSessionCache,
   pushImport,
   executePushImportUnlocked,
@@ -21586,4 +22676,4 @@ export {
   hashImportBody,
   ImportIdempotencyCache
 };
-//# sourceMappingURL=chunk-AQPDZAWB.mjs.map
+//# sourceMappingURL=chunk-4LW6443F.mjs.map