chatlab-cli 0.31.0 → 0.31.2-beta.1

package/dist/{chunk-T64GA5HP.mjs → chunk-5G2INROS.mjs}

@@ -9,7 +9,7 @@ import {
   createEmptyContactsDiagnostics,
   normalizeContactsTimeRangePreset,
   resolveContactsTimeRange
-} from "./chunk-SNCXU2QL.mjs";
+} from "./chunk-ZF67S6RY.mjs";
 import {
   PEOPLE_RELATIONSHIPS_ALGORITHM_VERSION,
   buildPeopleRelationshipsNeighborhoodGraph,
@@ -18,7 +18,7 @@ import {
   computePeopleRelationshipsSnapshot,
   normalizePeopleRelationshipsTimeRangePreset,
   resolvePeopleRelationshipsTimeRange
-} from "./chunk-RDCUGC24.mjs";
+} from "./chunk-HUKZ2PBC.mjs";
 import {
   ANNUAL_SUMMARY_ALGORITHM_VERSION
 } from "./chunk-YAQLYL52.mjs";
@@ -42,7 +42,9 @@ import {
   clearSessionIndex,
   collectPosTagStats,
   deleteAnnualSummarySnapshots,
+  deleteAuthProfile,
   deleteMember,
+  deleteMembers,
   generateIncrementalSessionIndex,
   generateMessageKey,
   generateSessionIndex,
@@ -93,7 +95,7 @@ import {
   updateSessionOwnerId,
   writeAnnualSummarySnapshot,
   writeAuthProfile
-} from "./chunk-UWWFOEGF.mjs";
+} from "./chunk-XZ5FFDLX.mjs";
 import {
   __commonJS,
   __export,
@@ -709,8 +711,8 @@ var require_FilterBase = __commonJS({
     var FilterBase = class _FilterBase extends Transform {
       static stringFilter(string, separator) {
         return (stack) => {
-          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;
+          const path33 = stack.join(separator);
+          return path33.length === string.length && path33 === string || path33.length > string.length && path33.substr(0, string.length) === string && path33.substr(string.length, separator.length) === separator;
         };
       }
       static regExpFilter(regExp, separator) {
@@ -1164,12 +1166,12 @@ var require_Assembler = __commonJS({
         return (this.stack.length >> 1) + (this.done ? 0 : 1);
       }
       get path() {
-        const path31 = [];
+        const path33 = [];
         for (let i = 0; i < this.stack.length; i += 2) {
           const key = this.stack[i + 1];
-          path31.push(key === null ? this.stack[i].length : key);
+          path33.push(key === null ? this.stack[i].length : key);
         }
-        return path31;
+        return path33;
       }
       dropToLevel(level) {
         if (level < this.depth) {
@@ -1451,7 +1453,7 @@ var require_pend = __commonJS({
 var require_fd_slicer = __commonJS({
   "../../packages/node-runtime/node_modules/yauzl/fd-slicer.js"(exports) {
     "use strict";
-    var fs35 = __require("fs");
+    var fs37 = __require("fs");
     var util = __require("util");
     var stream = __require("stream");
     var Readable = stream.Readable;
@@ -1471,7 +1473,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs35.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);
         });
@@ -1488,7 +1490,7 @@ var require_fd_slicer = __commonJS({
       self.refCount -= 1;
       if (self.refCount < 0) throw new Error("invalid unref");
       if (self.refCount > 0) return;
-      fs35.close(self.fd, onCloseDone);
+      fs37.close(self.fd, onCloseDone);
       function onCloseDone(err) {
         if (err) {
           self.emit("error", err);
@@ -1520,7 +1522,7 @@ var require_fd_slicer = __commonJS({
       }
       self.context.pend.go(function(cb) {
         var buffer = Buffer.allocUnsafe(toRead);
-        fs35.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) {
@@ -1882,7 +1884,7 @@ var require_crc32 = __commonJS({
 var require_yauzl = __commonJS({
   "../../packages/node-runtime/node_modules/yauzl/index.js"(exports) {
     "use strict";
-    var fs35 = __require("fs");
+    var fs37 = __require("fs");
     var zlib = __require("zlib");
     var fd_slicer = require_fd_slicer();
     var util = __require("util");
@@ -1907,39 +1909,39 @@ var require_yauzl = __commonJS({
     exports.Entry = Entry;
     exports.LocalFileHeader = LocalFileHeader;
     exports.RandomAccessReader = RandomAccessReader;
-    function openPromise2(path31, options2) {
-      return new Promise((resolve2, reject) => {
-        open(path31, { ...options2, lazyEntries: true }, function(err, zipfile) {
+    function openPromise2(path33, options2) {
+      return new Promise((resolve4, reject) => {
+        open(path33, { ...options2, lazyEntries: true }, function(err, zipfile) {
           if (err) return reject(err);
-          resolve2(zipfile);
+          resolve4(zipfile);
         });
       });
     }
     function fromFdPromise(fd, options2) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve4, reject) => {
         fromFd(fd, { ...options2, lazyEntries: true }, function(err, zipfile) {
           if (err) return reject(err);
-          resolve2(zipfile);
+          resolve4(zipfile);
         });
       });
     }
     function fromBufferPromise(buffer, options2) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve4, reject) => {
         fromBuffer(buffer, { ...options2, lazyEntries: true }, function(err, zipfile) {
           if (err) return reject(err);
-          resolve2(zipfile);
+          resolve4(zipfile);
         });
       });
     }
     function fromRandomAccessReaderPromise(reader, totalSize, options2) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve4, reject) => {
         fromRandomAccessReader(reader, totalSize, { ...options2, lazyEntries: true }, function(err, zipfile) {
           if (err) return reject(err);
-          resolve2(zipfile);
+          resolve4(zipfile);
         });
       });
     }
-    function open(path31, options2, callback) {
+    function open(path33, options2, callback) {
       if (typeof options2 === "function") {
         callback = options2;
         options2 = null;
@@ -1951,10 +1953,10 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs35.open(path31, "r", function(err, fd) {
+      fs37.open(path33, "r", function(err, fd) {
         if (err) return callback(err);
         fromFd(fd, options2, function(err2, zipfile) {
-          if (err2) fs35.close(fd, defaultCallback);
+          if (err2) fs37.close(fd, defaultCallback);
           callback(err2, zipfile);
         });
       });
@@ -1971,7 +1973,7 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs35.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);
@@ -2219,15 +2221,15 @@ var require_yauzl = __commonJS({
         if (self.autoClose) self.close();
       }
       function onEntry(entry) {
-        let { resolve: resolve2 } = pendingResolveReject;
+        let { resolve: resolve4 } = pendingResolveReject;
         pendingResolveReject = null;
-        resolve2({ value: entry });
+        resolve4({ value: entry });
       }
       function onEnd() {
-        let { resolve: resolve2 } = pendingResolveReject;
+        let { resolve: resolve4 } = pendingResolveReject;
         pendingResolveReject = null;
         cleanup();
-        resolve2({ done: true });
+        resolve4({ done: true });
       }
       function onError(err) {
         let { reject } = pendingResolveReject;
@@ -2240,9 +2242,9 @@ var require_yauzl = __commonJS({
           return this;
         },
         next() {
-          const promise = new Promise((resolve2, reject) => {
+          const promise = new Promise((resolve4, reject) => {
             if (pendingResolveReject != null) throw new Error("next() called before previous Promise was resolved.");
-            pendingResolveReject = { resolve: resolve2, reject };
+            pendingResolveReject = { resolve: resolve4, reject };
           });
           self.readEntry();
           return promise;
@@ -2431,26 +2433,26 @@ var require_yauzl = __commonJS({
       });
     };
     ZipFile.prototype.openReadStreamPromise = function(entry, options2) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve4, reject) => {
         this.openReadStream(entry, options2, function(err, readStream) {
           if (err) return reject(err);
-          resolve2(readStream);
+          resolve4(readStream);
         });
       });
     };
     ZipFile.prototype.openReadStreamLowLevelPromise = function(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve4, reject) => {
         this.openReadStream(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize, function(err, readStream) {
           if (err) return reject(err);
-          resolve2(readStream);
+          resolve4(readStream);
         });
       });
     };
     ZipFile.prototype.readLocalFileHeaderPromise = function(entry, options2) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve4, reject) => {
         this.readLocalFileHeader(entry, options2, function(err, localFileHeader) {
           if (err) return reject(err);
-          resolve2(localFileHeader);
+          resolve4(localFileHeader);
         });
       });
     };
@@ -2738,6 +2740,73 @@ var require_yauzl = __commonJS({
   }
 });
 
+// ../../packages/node-runtime/src/temp-workspace.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var CHATLAB_TEMP_ROOT_ENV = "CHATLAB_TEMP_ROOT";
+var CHATLAB_TEMP_SCOPES = /* @__PURE__ */ new Set(["tests", "runtime", "imports", "merge", "sync", "parser", "build", "bench"]);
+function optionsEnv(options2) {
+  return options2.env ?? process.env;
+}
+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 systemTempDir = options2.systemTempDir ?? os.tmpdir();
+  return path.resolve(platform2 === "darwin" ? "/private/tmp/chatlab" : path.join(systemTempDir, "chatlab"));
+}
+function ensurePrivateOwnedDirectory(dirPath, label) {
+  fs.mkdirSync(dirPath, { recursive: true, mode: 448 });
+  const stats = fs.lstatSync(dirPath);
+  if (stats.isSymbolicLink()) {
+    throw new Error(`${label} must not be a symbolic link: ${dirPath}`);
+  }
+  if (!stats.isDirectory()) {
+    throw new Error(`${label} must be a directory: ${dirPath}`);
+  }
+  if (typeof process.getuid === "function" && stats.uid !== process.getuid()) {
+    throw new Error(`${label} is owned by another user: ${dirPath}`);
+  }
+  if (process.platform !== "win32") {
+    fs.chmodSync(dirPath, 448);
+  }
+}
+function ensureChatLabTempRoot(options2 = {}) {
+  const root = resolveChatLabTempRoot(options2);
+  ensurePrivateOwnedDirectory(root, "ChatLab temp root");
+  optionsEnv(options2)[CHATLAB_TEMP_ROOT_ENV] = root;
+  return root;
+}
+function assertValidScope(scope) {
+  if (!CHATLAB_TEMP_SCOPES.has(scope)) {
+    throw new Error(`Invalid ChatLab temp scope: ${scope}`);
+  }
+}
+function assertValidPrefix(prefix) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(prefix)) {
+    throw new Error(`Invalid ChatLab temp prefix: ${prefix}`);
+  }
+}
+function getChatLabTempScopeDir(scope, options2 = {}) {
+  assertValidScope(scope);
+  const scopeDir = path.join(ensureChatLabTempRoot(options2), scope);
+  ensurePrivateOwnedDirectory(scopeDir, "ChatLab temp scope");
+  return scopeDir;
+}
+function createChatLabTempDir(scope, prefix, options2 = {}) {
+  assertValidPrefix(prefix);
+  return fs.mkdtempSync(path.join(getChatLabTempScopeDir(scope, options2), prefix));
+}
+function removeChatLabTempDir(dirPath, scope, options2 = {}) {
+  const scopeDir = path.resolve(getChatLabTempScopeDir(scope, options2));
+  const resolvedDir = path.resolve(dirPath);
+  if (path.dirname(resolvedDir) !== scopeDir) {
+    throw new Error(`Refusing to remove non-owned ChatLab temp directory: ${resolvedDir}`);
+  }
+  fs.rmSync(resolvedDir, { recursive: true, force: true });
+}
+
 // ../../packages/node-runtime/src/import/write-parse-result.ts
 function writeParseResultToDb(db, meta, members, messages) {
   let messageCount = 0;
@@ -2852,28 +2921,28 @@ function writeParseResultToDb(db, meta, members, messages) {
 }
 
 // ../../packages/parser/src/index.ts
-import * as fs17 from "fs";
-import * as path13 from "path";
+import * as fs18 from "fs";
+import * as path14 from "path";
 
 // ../../packages/parser/src/sniffer.ts
-import * as fs from "fs";
-import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 var HEAD_SIZE = 64 * 1024;
 function readFileHead(filePath, size = HEAD_SIZE) {
-  const fd = fs.openSync(filePath, "r");
+  const fd = fs2.openSync(filePath, "r");
   const buffer = Buffer.alloc(size);
-  const bytesRead = fs.readSync(fd, buffer, 0, size, 0);
-  fs.closeSync(fd);
+  const bytesRead = fs2.readSync(fd, buffer, 0, size, 0);
+  fs2.closeSync(fd);
   return buffer.slice(0, bytesRead).toString("utf-8");
 }
 function getExtension(filePath) {
-  return path.extname(filePath).toLowerCase();
+  return path2.extname(filePath).toLowerCase();
 }
 function matchHeadSignatures(headContent, patterns) {
   return patterns.some((pattern) => pattern.test(headContent));
 }
 function matchFilenameSignatures(filePath, patterns) {
-  const filename = path.basename(filePath);
+  const filename = path2.basename(filePath);
   return patterns.some((pattern) => pattern.test(filename));
 }
 function matchRequiredFields(headContent, fields) {
@@ -3021,18 +3090,18 @@ var import_stream_json = __toESM(require_stream_json(), 1);
 var import_Pick = __toESM(require_Pick(), 1);
 var import_StreamValues = __toESM(require_StreamValues(), 1);
 var import_stream_chain = __toESM(require_stream_chain(), 1);
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 
 // ../../packages/parser/src/utils.ts
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 function getFileSize(filePath) {
-  return fs2.statSync(filePath).size;
+  return fs3.statSync(filePath).size;
 }
 function readFileHeadBytes(filePath, size) {
-  const fd = fs2.openSync(filePath, "r");
+  const fd = fs3.openSync(filePath, "r");
   const buffer = Buffer.alloc(size);
-  const bytesRead = fs2.readSync(fd, buffer, 0, size, 0);
-  fs2.closeSync(fd);
+  const bytesRead = fs3.readSync(fd, buffer, 0, size, 0);
+  fs3.closeSync(fd);
   return buffer.slice(0, bytesRead).toString("utf-8");
 }
 var createProgress = (stage, bytesRead, totalBytes, messagesProcessed, message) => {
@@ -3062,7 +3131,7 @@ function isValidYear(timestampSeconds) {
 }
 
 // ../../packages/parser/src/formats/chatlab.ts
-import * as path2 from "path";
+import * as path3 from "path";
 
 // ../../packages/parser/src/native/loader.ts
 import { createRequire } from "module";
@@ -3145,7 +3214,7 @@ async function* pumpNativeParser(adapter, options2, parser11, fallback) {
     if (!batch) break;
     messagesProcessed += batch.length;
     yield { type: "messages", data: batch.map((message) => adapter.mapMessage(message, metaJson)) };
-    await new Promise((resolve2) => setImmediate(resolve2));
+    await new Promise((resolve4) => setImmediate(resolve4));
   }
   const doneProgress = createProgress("done", totalBytes, totalBytes, messagesProcessed, "");
   yield { type: "progress", data: doneProgress };
@@ -3243,7 +3312,7 @@ var { pick } = import_Pick.default;
 var { streamValues } = import_StreamValues.default;
 var { chain } = import_stream_chain.default;
 function extractNameFromFilePath(filePath) {
-  const basename13 = path2.basename(filePath);
+  const basename13 = path3.basename(filePath);
   const name = basename13.replace(/\.json$/i, "");
   return name || "\u672A\u77E5\u7FA4\u804A";
 }
@@ -3317,8 +3386,8 @@ async function* parseChatLab(options2) {
   const members = [];
   const memberMapFromMessages = /* @__PURE__ */ new Map();
   const messageBatch = [];
-  await new Promise((resolve2, reject) => {
-    const readStream = fs3.createReadStream(filePath, { encoding: "utf-8" });
+  await new Promise((resolve4, reject) => {
+    const readStream = fs4.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
@@ -3372,7 +3441,7 @@ async function* parseChatLab(options2) {
       if (batchCollector.length > 0) {
         messageBatch.push(...batchCollector);
       }
-      resolve2();
+      resolve4();
     });
     pipeline2.on("error", reject);
   });
@@ -3410,11 +3479,11 @@ var module_ = {
 var chatlab_default = module_;
 
 // ../../packages/parser/src/formats/chatlab-jsonl.ts
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 import * as readline from "readline";
-import * as path3 from "path";
+import * as path4 from "path";
 function extractNameFromFilePath2(filePath) {
-  const basename13 = path3.basename(filePath);
+  const basename13 = path4.basename(filePath);
   const name = basename13.replace(/\.jsonl$/i, "");
   return name || "\u672A\u77E5\u7FA4\u804A";
 }
@@ -3455,7 +3524,7 @@ async function* parseChatLabJsonl(options2) {
   const messageBatch = [];
   let meta = null;
   let headerParsed = false;
-  const fileStream = fs4.createReadStream(filePath, { encoding: "utf-8" });
+  const fileStream = fs5.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline.createInterface({
     input: fileStream,
     crlfDelay: Infinity
@@ -3580,28 +3649,30 @@ var import_stream_json3 = __toESM(require_stream_json(), 1);
 var import_Pick3 = __toESM(require_Pick(), 1);
 var import_StreamValues3 = __toESM(require_StreamValues(), 1);
 var import_stream_chain3 = __toESM(require_stream_chain(), 1);
-import * as fs6 from "fs";
-import * as path5 from "path";
+import * as fs7 from "fs";
+import * as path6 from "path";
 
 // ../../packages/parser/src/formats/shuakami-qq-preprocessor.ts
 var import_stream_json2 = __toESM(require_stream_json(), 1);
 var import_Pick2 = __toESM(require_Pick(), 1);
 var import_StreamValues2 = __toESM(require_StreamValues(), 1);
 var import_stream_chain2 = __toESM(require_stream_chain(), 1);
-import * as fs5 from "fs";
-import * as path4 from "path";
-import * as os from "os";
+import * as fs6 from "fs";
+import * as path5 from "path";
+import * as os2 from "os";
 var { parser: parser3 } = import_stream_json2.default;
 var { pick: pick2 } = import_Pick2.default;
 var { streamValues: streamValues2 } = import_StreamValues2.default;
 var { chain: chain2 } = import_stream_chain2.default;
 var PREPROCESS_THRESHOLD = 50 * 1024 * 1024;
 function getTempDir() {
-  return path4.join(os.tmpdir(), "chatlab");
+  const configuredRoot = process.env.CHATLAB_TEMP_ROOT?.trim();
+  const root = configuredRoot ? path5.resolve(configuredRoot) : path5.resolve(process.platform === "darwin" ? "/private/tmp/chatlab" : path5.join(os2.tmpdir(), "chatlab"));
+  return path5.join(root, "parser");
 }
 function ensureDir(dir) {
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true, mode: 448 });
   }
 }
 function extractJsonObject(content, key) {
@@ -3643,12 +3714,12 @@ function extractJsonObject(content, key) {
 }
 function readAvatarsFromFile(filePath) {
   try {
-    const stats = fs5.statSync(filePath);
+    const stats = fs6.statSync(filePath);
     const tailSize = Math.min(stats.size, 5e6);
-    const fd = fs5.openSync(filePath, "r");
+    const fd = fs6.openSync(filePath, "r");
     const buffer = Buffer.alloc(tailSize);
-    fs5.readSync(fd, buffer, 0, tailSize, stats.size - tailSize);
-    fs5.closeSync(fd);
+    fs6.readSync(fd, buffer, 0, tailSize, stats.size - tailSize);
+    fs6.closeSync(fd);
     const tailContent = buffer.toString("utf-8");
     return extractJsonObject(tailContent, "avatars");
   } catch {
@@ -3707,15 +3778,15 @@ async function preprocessQQJson(inputPath, onProgress) {
   let messagesProcessed = 0;
   const tempDir = getTempDir();
   ensureDir(tempDir);
-  const outputFilename = `slim_${Date.now()}_${path4.basename(inputPath)}`;
-  const outputPath = path4.join(tempDir, outputFilename);
+  const outputFilename = `slim_${Date.now()}_${path5.basename(inputPath)}`;
+  const outputPath = path5.join(tempDir, outputFilename);
   onProgress?.(createProgress("parsing", 0, totalBytes, 0, ""));
   const avatarsStr = readAvatarsFromFile(inputPath);
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const headChunks = [];
     let headSize = 0;
     const maxHeadSize = 1e5;
-    const headStream = fs5.createReadStream(inputPath, { encoding: "utf-8" });
+    const headStream = fs6.createReadStream(inputPath, { encoding: "utf-8" });
     let chatInfo = { name: "\u672A\u77E5\u7FA4\u804A", type: "group" };
     let metadata;
     let statistics;
@@ -3752,8 +3823,8 @@ async function preprocessQQJson(inputPath, onProgress) {
       } catch {
       }
       onProgress?.(createProgress("parsing", 0, totalBytes, 0, ""));
-      const readStream = fs5.createReadStream(inputPath, { encoding: "utf-8" });
-      const writeStream = fs5.createWriteStream(outputPath, { encoding: "utf-8" });
+      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;
       });
@@ -3793,13 +3864,13 @@ async function preprocessQQJson(inputPath, onProgress) {
         writeStream.end();
         writeStream.on("finish", () => {
           onProgress?.(createProgress("done", totalBytes, totalBytes, messagesProcessed, ""));
-          resolve2(outputPath);
+          resolve4(outputPath);
         });
       });
       pipeline2.on("error", (err) => {
         writeStream.destroy();
-        if (fs5.existsSync(outputPath)) {
-          fs5.unlinkSync(outputPath);
+        if (fs6.existsSync(outputPath)) {
+          fs6.unlinkSync(outputPath);
         }
         onProgress?.(createProgress("error", bytesRead, totalBytes, messagesProcessed, err.message));
         reject(err);
@@ -3810,8 +3881,8 @@ async function preprocessQQJson(inputPath, onProgress) {
 }
 function cleanupTempFile(filePath) {
   try {
-    if (fs5.existsSync(filePath) && filePath.includes(getTempDir())) {
-      fs5.unlinkSync(filePath);
+    if (fs6.existsSync(filePath) && path5.dirname(path5.resolve(filePath)) === path5.resolve(getTempDir())) {
+      fs6.unlinkSync(filePath);
     }
   } catch {
   }
@@ -3878,9 +3949,12 @@ function extractJsonObject2(content, key) {
   return null;
 }
 function extractNameFromFilePath3(filePath) {
-  const basename13 = path5.basename(filePath);
+  const basename13 = path6.basename(filePath);
   return basename13.replace(/\.json$/i, "") || "\u672A\u77E5\u7FA4\u804A";
 }
+function isPlaceholderSenderId(id) {
+  return id === "0" || id === "\u672A\u77E5";
+}
 function countSenders(content) {
   const sendersStart = content.indexOf('"senders"');
   if (sendersStart === -1) return 0;
@@ -3895,8 +3969,19 @@ function countSenders(content) {
   }
   if (depth !== 0) return 0;
   const sendersContent = content.slice(arrayStart + 1, i - 1);
-  const uidMatches = sendersContent.match(/"uid"\s*:/g);
-  return uidMatches ? uidMatches.length : 0;
+  const uidMatches = sendersContent.matchAll(/"uid"\s*:\s*"([^"]*)"/g);
+  let count = 0;
+  for (const match of uidMatches) {
+    const uid = match[1];
+    if (uid && !isPlaceholderSenderId(uid)) count++;
+  }
+  return count;
+}
+function resolveChatType(chatInfoType, headContent) {
+  if (chatInfoType === "group") return "group" /* GROUP */;
+  const sendersCount = countSenders(headContent);
+  if (chatInfoType === "private") return sendersCount > 2 ? "group" /* GROUP */ : "private" /* PRIVATE */;
+  return sendersCount > 2 ? "group" /* GROUP */ : sendersCount > 0 ? "private" /* PRIVATE */ : "group" /* GROUP */;
 }
 function convertMessageType(messageType, content, isRecalled) {
   if (isRecalled) return 81 /* RECALL */;
@@ -3950,8 +4035,7 @@ async function* parseV4(options2) {
     }
   } catch {
   }
-  const sendersCount = countSenders(headContent);
-  const chatType = sendersCount > 2 ? "group" /* GROUP */ : sendersCount > 0 ? "private" /* PRIVATE */ : "group" /* GROUP */;
+  const chatType = resolveChatType(chatInfo.type, headContent);
   const meta = {
     name: chatInfo.name || extractNameFromFilePath3(filePath),
     platform: KNOWN_PLATFORMS.QQ,
@@ -3962,15 +4046,15 @@ async function* parseV4(options2) {
   yield { type: "meta", data: meta };
   const memberMap = /* @__PURE__ */ new Map();
   const messageBatch = [];
-  await new Promise((resolve2, reject) => {
-    const readStream = fs6.createReadStream(filePath, { encoding: "utf-8" });
+  await new Promise((resolve4, reject) => {
+    const readStream = fs7.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
     const pipeline2 = chain3([readStream, parser4(), pick3({ filter: /^messages\.\d+$/ }), streamValues3()]);
     pipeline2.on("data", ({ value }) => {
       const platformId = value.sender.uin || value.sender.uid || value.rawMessage?.senderUin || value.rawMessage?.senderUid;
-      if (!platformId) {
+      if (!platformId || isPlaceholderSenderId(platformId)) {
         skippedMessages++;
         return;
       }
@@ -3989,9 +4073,11 @@ async function* parseV4(options2) {
         skippedMessages++;
         return;
       }
-      const type = value.isSystemMessage ? 80 /* SYSTEM */ : convertMessageType(value.messageType, value.content, value.isRecalled);
+      const isSystem = value.system ?? value.isSystemMessage;
+      const isRecalled = value.recalled ?? value.isRecalled;
+      const type = isSystem ? 80 /* SYSTEM */ : convertMessageType(value.messageType, value.content, isRecalled);
       let textContent = value.content?.text || "";
-      if (value.isRecalled) textContent = "[\u5DF2\u64A4\u56DE] " + textContent;
+      if (isRecalled) textContent = "[\u5DF2\u64A4\u56DE] " + textContent;
       messageBatch.push({
         platformMessageId: value.messageId,
         // 消息的平台原始 ID
@@ -4016,17 +4102,17 @@ async function* parseV4(options2) {
         onProgress?.(progress);
       }
     });
-    pipeline2.on("end", resolve2);
+    pipeline2.on("end", resolve4);
     pipeline2.on("error", reject);
   });
   const avatarsMap = /* @__PURE__ */ new Map();
   try {
-    const stats = fs6.statSync(filePath);
+    const stats = fs7.statSync(filePath);
     const tailSize = Math.min(stats.size, 5e6);
-    const fd = fs6.openSync(filePath, "r");
+    const fd = fs7.openSync(filePath, "r");
     const buffer = Buffer.alloc(tailSize);
-    fs6.readSync(fd, buffer, 0, tailSize, stats.size - tailSize);
-    fs6.closeSync(fd);
+    fs7.readSync(fd, buffer, 0, tailSize, stats.size - tailSize);
+    fs7.closeSync(fd);
     const tailContent = buffer.toString("utf-8");
     const avatarsStr = extractJsonObject2(tailContent, "avatars");
     if (avatarsStr) {
@@ -4078,8 +4164,8 @@ var module_3 = {
 var shuakami_qq_exporter_default = module_3;
 
 // ../../packages/parser/src/formats/shuakami-qq-exporter-chunked.ts
-import * as fs7 from "fs";
-import * as path6 from "path";
+import * as fs8 from "fs";
+import * as path7 from "path";
 import * as readline2 from "readline";
 var feature4 = {
   id: "shuakami-qq-exporter-chunked",
@@ -4128,7 +4214,7 @@ function convertMessageType2(msgType, content, isRecalled) {
   return 0 /* TEXT */;
 }
 function readManifest(manifestPath) {
-  const content = fs7.readFileSync(manifestPath, "utf-8");
+  const content = fs8.readFileSync(manifestPath, "utf-8");
   return JSON.parse(content);
 }
 function getChunkRelativePath(chunk) {
@@ -4146,9 +4232,9 @@ function calculateTotalBytes(manifest, baseDir) {
   let total = 0;
   for (const chunk of manifest.chunked.chunks) {
     const relativePath = getChunkRelativePath(chunk);
-    const chunkPath = path6.join(baseDir, relativePath);
-    if (fs7.existsSync(chunkPath)) {
-      total += fs7.statSync(chunkPath).size;
+    const chunkPath = path7.join(baseDir, relativePath);
+    if (fs8.existsSync(chunkPath)) {
+      total += fs8.statSync(chunkPath).size;
     }
   }
   return total;
@@ -4156,10 +4242,10 @@ function calculateTotalBytes(manifest, baseDir) {
 function readAvatars(baseDir, avatarsInfo) {
   const avatarsMap = /* @__PURE__ */ new Map();
   if (!avatarsInfo?.file) return avatarsMap;
-  const avatarsPath = path6.join(baseDir, avatarsInfo.file);
-  if (!fs7.existsSync(avatarsPath)) return avatarsMap;
+  const avatarsPath = path7.join(baseDir, avatarsInfo.file);
+  if (!fs8.existsSync(avatarsPath)) return avatarsMap;
   try {
-    const content = fs7.readFileSync(avatarsPath, "utf-8");
+    const content = fs8.readFileSync(avatarsPath, "utf-8");
     const avatars = JSON.parse(content);
     for (const [uin, avatar] of Object.entries(avatars)) {
       if (avatar && typeof avatar === "string" && avatar.startsWith("data:image/")) {
@@ -4177,7 +4263,7 @@ async function* readJsonlFile(filePath, onParseError) {
   let parseErrorCount = 0;
   const MAX_PARSE_ERRORS_TO_LOG = 10;
   try {
-    fileStream = fs7.createReadStream(filePath, { encoding: "utf-8" });
+    fileStream = fs8.createReadStream(filePath, { encoding: "utf-8" });
     rl = readline2.createInterface({
       input: fileStream,
       crlfDelay: Infinity
@@ -4208,7 +4294,7 @@ async function* readJsonlFile(filePath, onParseError) {
 async function* parseChunkedJsonl(options2) {
   const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const manifestPath = filePath;
-  const baseDir = path6.dirname(manifestPath);
+  const baseDir = path7.dirname(manifestPath);
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 manifest: ${manifestPath}`);
   onLog?.("info", `\u57FA\u7840\u76EE\u5F55: ${baseDir}`);
   let manifest;
@@ -4262,13 +4348,13 @@ async function* parseChunkedJsonl(options2) {
   for (let chunkIndex = 0; chunkIndex < manifest.chunked.chunks.length; chunkIndex++) {
     const chunkInfo = manifest.chunked.chunks[chunkIndex];
     const relativePath = getChunkRelativePath(chunkInfo);
-    const chunkPath = path6.join(baseDir, relativePath);
+    const chunkPath = path7.join(baseDir, relativePath);
     const chunkMessageCount = getChunkMessageCount(chunkInfo);
-    if (!fs7.existsSync(chunkPath)) {
+    if (!fs8.existsSync(chunkPath)) {
       onLog?.("error", `\u5206\u5757\u6587\u4EF6\u4E0D\u5B58\u5728: ${chunkPath}`);
       continue;
     }
-    const chunkSize = fs7.statSync(chunkPath).size;
+    const chunkSize = fs8.statSync(chunkPath).size;
     let chunkMessagesRead = 0;
     let chunkParseErrors = 0;
     onLog?.(
@@ -4390,8 +4476,8 @@ var import_stream_json4 = __toESM(require_stream_json(), 1);
 var import_Pick4 = __toESM(require_Pick(), 1);
 var import_StreamValues4 = __toESM(require_StreamValues(), 1);
 var import_stream_chain4 = __toESM(require_stream_chain(), 1);
-import * as fs8 from "fs";
-import * as path7 from "path";
+import * as fs9 from "fs";
+import * as path8 from "path";
 
 // ../../packages/parser/src/native/weflow-native.ts
 var weflowAdapter = {
@@ -4464,7 +4550,7 @@ var { pick: pick4 } = import_Pick4.default;
 var { streamValues: streamValues4 } = import_StreamValues4.default;
 var { chain: chain4 } = import_stream_chain4.default;
 function extractNameFromFilePath4(filePath) {
-  const basename13 = path7.basename(filePath);
+  const basename13 = path8.basename(filePath);
   const name = basename13.replace(/\.json$/i, "");
   return name || "\u672A\u77E5\u804A\u5929";
 }
@@ -4532,8 +4618,8 @@ async function* parseWeFlow(options2) {
   const headContent = readFileHeadBytes(filePath, 5e3);
   let session = null;
   try {
-    await new Promise((resolve2) => {
-      const sessionStream = fs8.createReadStream(filePath, { encoding: "utf-8" });
+    await new Promise((resolve4) => {
+      const sessionStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
       let sessionContent = "";
       let inSession = false;
       let braceDepth = 0;
@@ -4584,9 +4670,9 @@ async function* parseWeFlow(options2) {
           } catch {
           }
         }
-        resolve2();
+        resolve4();
       });
-      sessionStream.on("error", () => resolve2());
+      sessionStream.on("error", () => resolve4());
     });
   } catch {
   }
@@ -4655,8 +4741,8 @@ async function* parseWeFlow(options2) {
   }
   if (avatarsMap.size === 0) {
     try {
-      await new Promise((resolve2) => {
-        const avatarStream = fs8.createReadStream(filePath, { encoding: "utf-8" });
+      await new Promise((resolve4) => {
+        const avatarStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
         let avatarsContent = "";
         let inAvatars = false;
         let braceDepth = 0;
@@ -4712,9 +4798,9 @@ async function* parseWeFlow(options2) {
             } catch {
             }
           }
-          resolve2();
+          resolve4();
         });
-        avatarStream.on("error", () => resolve2());
+        avatarStream.on("error", () => resolve4());
       });
     } catch {
     }
@@ -4722,8 +4808,8 @@ async function* parseWeFlow(options2) {
   const groupAvatar = sessionData?.avatar || (groupId ? avatarsMap.get(groupId) : void 0);
   let ownerId;
   try {
-    await new Promise((resolve2) => {
-      const scanStream = fs8.createReadStream(filePath, { encoding: "utf-8" });
+    await new Promise((resolve4) => {
+      const scanStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
       const scanPipeline = chain4([scanStream, parser5(), pick4({ filter: /^messages\.\d+$/ }), streamValues4()]);
       scanPipeline.on("data", ({ value }) => {
         if (value.isSend === 1 && value.senderUsername && !value.senderUsername.endsWith("@chatroom")) {
@@ -4731,9 +4817,9 @@ async function* parseWeFlow(options2) {
           scanStream.destroy();
         }
       });
-      scanStream.on("close", () => resolve2());
-      scanPipeline.on("end", () => resolve2());
-      scanPipeline.on("error", () => resolve2());
+      scanStream.on("close", () => resolve4());
+      scanPipeline.on("end", () => resolve4());
+      scanPipeline.on("error", () => resolve4());
     });
   } catch {
   }
@@ -4748,8 +4834,8 @@ async function* parseWeFlow(options2) {
   yield { type: "meta", data: meta };
   const memberMap = /* @__PURE__ */ new Map();
   const messageBatch = [];
-  await new Promise((resolve2, reject) => {
-    const readStream = fs8.createReadStream(filePath, { encoding: "utf-8" });
+  await new Promise((resolve4, reject) => {
+    const readStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
@@ -4821,7 +4907,7 @@ async function* parseWeFlow(options2) {
       if (batchCollector.length > 0) {
         messageBatch.push(...batchCollector);
       }
-      resolve2();
+      resolve4();
     });
     pipeline2.on("error", reject);
   });
@@ -4886,7 +4972,7 @@ var import_stream_json5 = __toESM(require_stream_json(), 1);
 var import_Pick5 = __toESM(require_Pick(), 1);
 var import_StreamValues5 = __toESM(require_StreamValues(), 1);
 var import_stream_chain5 = __toESM(require_stream_chain(), 1);
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 var { parser: parser6 } = import_stream_json5.default;
 var { pick: pick5 } = import_Pick5.default;
 var { streamValues: streamValues5 } = import_StreamValues5.default;
@@ -5035,8 +5121,8 @@ async function* parseDiscordExporter(options2) {
   onLog?.("info", `\u7FA4\u804A\u540D\u79F0: ${chatName}`);
   const memberMap = /* @__PURE__ */ new Map();
   const messageBatch = [];
-  await new Promise((resolve2, reject) => {
-    const readStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
+  await new Promise((resolve4, reject) => {
+    const readStream = fs10.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
@@ -5114,7 +5200,7 @@ ${stickerTexts.join("\n")}` : stickerTexts.join("\n");
       if (batchCollector.length > 0) {
         messageBatch.push(...batchCollector);
       }
-      resolve2();
+      resolve4();
     });
     pipeline2.on("error", reject);
   });
@@ -5152,7 +5238,7 @@ var import_stream_chain6 = __toESM(require_stream_chain(), 1);
 var import_stream_json6 = __toESM(require_stream_json(), 1);
 var import_Pick6 = __toESM(require_Pick(), 1);
 var import_StreamValues6 = __toESM(require_StreamValues(), 1);
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 
 // ../../packages/parser/src/formats/utils/telegram-utils.ts
 function mapChatType(telegramType) {
@@ -5237,8 +5323,8 @@ var feature8 = {
 };
 async function scanChats(filePath) {
   const chats = [];
-  return new Promise((resolve2, reject) => {
-    const readStream = fs10.createReadStream(filePath, { encoding: "utf-8" });
+  return new Promise((resolve4, reject) => {
+    const readStream = fs11.createReadStream(filePath, { encoding: "utf-8" });
     const pipeline2 = chain6([readStream, parser7(), pick6({ filter: /^chats\.list\.\d+$/ }), streamValues6()]);
     pipeline2.on("data", ({ value }) => {
       const chat = value;
@@ -5251,7 +5337,7 @@ async function scanChats(filePath) {
       });
     });
     pipeline2.on("end", () => {
-      resolve2(chats);
+      resolve4(chats);
     });
     pipeline2.on("error", (err) => {
       reject(new Error(`\u626B\u63CF Telegram \u6587\u4EF6\u5931\u8D25: ${err.message}`));
@@ -5270,8 +5356,8 @@ async function* parseTelegram(options2) {
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 Telegram JSON \u6587\u4EF6\uFF0C\u5927\u5C0F: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`);
   onLog?.("info", `\u76EE\u6807\u804A\u5929\u7D22\u5F15: ${chatIndex}`);
   const chatPathFilter = `chats.list.${chatIndex}`;
-  const chatData = await new Promise((resolve2, reject) => {
-    const readStream = fs10.createReadStream(filePath, { encoding: "utf-8" });
+  const chatData = await new Promise((resolve4, reject) => {
+    const readStream = fs11.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
@@ -5284,10 +5370,10 @@ async function* parseTelegram(options2) {
     let found = false;
     pipeline2.on("data", ({ value }) => {
       found = true;
-      resolve2(value);
+      resolve4(value);
     });
     pipeline2.on("end", () => {
-      if (!found) resolve2(null);
+      if (!found) resolve4(null);
     });
     pipeline2.on("error", reject);
   });
@@ -5379,7 +5465,7 @@ var telegram_native_default = module_8;
 var import_stream_chain7 = __toESM(require_stream_chain(), 1);
 var import_stream_json7 = __toESM(require_stream_json(), 1);
 var import_StreamValues7 = __toESM(require_StreamValues(), 1);
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 var { chain: chain7 } = import_stream_chain7.default;
 var { parser: parser8 } = import_stream_json7.default;
 var { streamValues: streamValues7 } = import_StreamValues7.default;
@@ -5408,18 +5494,18 @@ async function* parseTelegramSingle(options2) {
   yield { type: "progress", data: initialProgress };
   onProgress?.(initialProgress);
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 Telegram \u5355\u804A\u5929 JSON \u6587\u4EF6\uFF0C\u5927\u5C0F: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`);
-  const chatData = await new Promise((resolve2, reject) => {
-    const readStream = fs11.createReadStream(filePath, { encoding: "utf-8" });
+  const chatData = await new Promise((resolve4, reject) => {
+    const readStream = fs12.createReadStream(filePath, { encoding: "utf-8" });
     const pipeline2 = chain7([readStream, parser8(), streamValues7()]);
     let found = false;
     pipeline2.on("data", ({ value }) => {
       if (!found) {
         found = true;
-        resolve2(value);
+        resolve4(value);
       }
     });
     pipeline2.on("end", () => {
-      if (!found) resolve2(null);
+      if (!found) resolve4(null);
     });
     pipeline2.on("error", reject);
   });
@@ -5507,11 +5593,11 @@ var module_9 = {
 var telegram_native_single_default = module_9;
 
 // ../../packages/parser/src/formats/whatsapp-native-txt.ts
-import * as fs12 from "fs";
-import * as path8 from "path";
+import * as fs13 from "fs";
+import * as path9 from "path";
 import * as readline3 from "readline";
 function extractNameFromFilePath5(filePath) {
-  const basename13 = path8.basename(filePath);
+  const basename13 = path9.basename(filePath);
   const matchZhCn = basename13.match(/^与(.+?)的\s*WhatsApp\s*聊天\.txt$/i);
   if (matchZhCn) return matchZhCn[1].trim();
   const matchZhTw = basename13.match(/^與(.+?)的\s*WhatsApp\s*對話\.txt$/i);
@@ -5519,7 +5605,7 @@ function extractNameFromFilePath5(filePath) {
   return basename13.replace(/\.txt$/i, "") || "\u672A\u77E5\u804A\u5929";
 }
 function shouldInferPrivateChatName(filePath, fallbackName) {
-  const basename13 = path8.basename(filePath);
+  const basename13 = path9.basename(filePath);
   return /^_chat\.txt$/i.test(basename13) || /^whatsapp(?:[-_\s].*)?$/i.test(fallbackName);
 }
 function inferPrivateChatName(memberMap, fallbackName) {
@@ -5698,7 +5784,7 @@ async function* parseWhatsApp(options2) {
       messagesProcessed++;
     }
   };
-  const fileStream = fs12.createReadStream(filePath, { encoding: "utf-8" });
+  const fileStream = fs13.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline3.createInterface({
     input: fileStream,
     crlfDelay: Infinity
@@ -5819,11 +5905,11 @@ var module_10 = {
 var whatsapp_native_txt_default = module_10;
 
 // ../../packages/parser/src/formats/qq-native-txt.ts
-import * as fs13 from "fs";
-import * as path9 from "path";
+import * as fs14 from "fs";
+import * as path10 from "path";
 import * as readline4 from "readline";
 function extractNameFromFilePath6(filePath) {
-  const basename13 = path9.basename(filePath);
+  const basename13 = path10.basename(filePath);
   const name = basename13.replace(/\.txt$/i, "");
   return name || "\u672A\u77E5\u7FA4\u804A";
 }
@@ -5905,7 +5991,7 @@ async function* parseTxt(options2) {
       messagesProcessed++;
     }
   };
-  const fileStream = fs13.createReadStream(filePath, { encoding: "utf-8" });
+  const fileStream = fs14.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline4.createInterface({
     input: fileStream,
     crlfDelay: Infinity
@@ -6005,8 +6091,8 @@ var module_11 = {
 var qq_native_txt_default = module_11;
 
 // ../../packages/parser/src/formats/instagram-native.ts
-import * as fs14 from "fs";
-import * as path10 from "path";
+import * as fs15 from "fs";
+import * as path11 from "path";
 var feature12 = {
   id: "instagram-native",
   name: "Instagram \u5B98\u65B9\u5BFC\u51FA",
@@ -6032,7 +6118,7 @@ function decodeInstagramText(text) {
   }
 }
 function extractNameFromFilePath7(filePath) {
-  const basename13 = path10.basename(filePath);
+  const basename13 = path11.basename(filePath);
   return basename13.replace(/\.json$/i, "") || "\u672A\u77E5\u5BF9\u8BDD";
 }
 function isSystemMessage2(content) {
@@ -6101,7 +6187,7 @@ async function* parseInstagram(options2) {
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 Instagram \u804A\u5929\u8BB0\u5F55\uFF0C\u5927\u5C0F: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`);
   let data;
   try {
-    const content = fs14.readFileSync(filePath, "utf-8");
+    const content = fs15.readFileSync(filePath, "utf-8");
     data = JSON.parse(content);
   } catch (error) {
     const err = new Error(`\u65E0\u6CD5\u89E3\u6790 Instagram JSON \u6587\u4EF6: ${error}`);
@@ -6196,8 +6282,8 @@ var import_stream_chain8 = __toESM(require_stream_chain(), 1);
 var import_stream_json8 = __toESM(require_stream_json(), 1);
 var import_Pick7 = __toESM(require_Pick(), 1);
 var import_StreamValues8 = __toESM(require_StreamValues(), 1);
-import * as fs15 from "fs";
-import * as path11 from "path";
+import * as fs16 from "fs";
+import * as path12 from "path";
 var { chain: chain8 } = import_stream_chain8.default;
 var { parser: parser9 } = import_stream_json8.default;
 var { pick: pick7 } = import_Pick7.default;
@@ -6280,12 +6366,12 @@ function normalizeIdentity(user) {
   };
 }
 function readJson(filePath) {
-  return JSON.parse(fs15.readFileSync(filePath, "utf8"));
+  return JSON.parse(fs16.readFileSync(filePath, "utf8"));
 }
 function resolveManifestFile(manifestDir, relativePath) {
-  const resolved = path11.resolve(manifestDir, relativePath);
-  const relative2 = path11.relative(manifestDir, resolved);
-  if (relative2.startsWith("..") || path11.isAbsolute(relative2)) {
+  const resolved = path12.resolve(manifestDir, relativePath);
+  const relative2 = path12.relative(manifestDir, resolved);
+  if (relative2.startsWith("..") || path12.isAbsolute(relative2)) {
     throw new Error(`Google Chat manifest path escapes its directory: ${relativePath}`);
   }
   return resolved;
@@ -6298,7 +6384,7 @@ function readManifest2(filePath) {
   if (manifest.chatType !== "private" && manifest.chatType !== "group") {
     throw new Error("Invalid Google Chat chat type");
   }
-  const manifestDir = path11.dirname(filePath);
+  const manifestDir = path12.dirname(filePath);
   return {
     manifest,
     userInfoPath: resolveManifestFile(manifestDir, manifest.userInfoFile),
@@ -6376,7 +6462,7 @@ async function* parseGoogleChat(options2) {
     });
   }
   yield { type: "members", data: Array.from(memberMap.values()) };
-  const readStream = fs15.createReadStream(messagesPath, { encoding: "utf8" });
+  const readStream = fs16.createReadStream(messagesPath, { encoding: "utf8" });
   let bytesRead = 0;
   let messagesProcessed = 0;
   readStream.on("data", (chunk) => {
@@ -6429,8 +6515,8 @@ var module_13 = {
 var google_chat_takeout_default = module_13;
 
 // ../../packages/parser/src/formats/line-native-txt.ts
-import * as fs16 from "fs";
-import * as path12 from "path";
+import * as fs17 from "fs";
+import * as path13 from "path";
 var feature14 = {
   id: "line-native-txt",
   name: "LINE \u5B98\u65B9\u5BFC\u51FA TXT",
@@ -6458,7 +6544,7 @@ var feature14 = {
   }
 };
 function extractNameFromFilePath8(filePath) {
-  const basename13 = path12.basename(filePath, ".txt");
+  const basename13 = path13.basename(filePath, ".txt");
   const name = basename13.replace(/^\[LINE\]\s*/i, "").trim();
   return name || "\u672A\u77E5\u804A\u5929";
 }
@@ -6638,7 +6724,7 @@ async function* parseLINE(options2) {
   yield { type: "progress", data: initialProgress };
   onProgress?.(initialProgress);
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 LINE \u5BFC\u51FA\u6587\u4EF6\uFF0C\u5927\u5C0F: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`);
-  const content = fs16.readFileSync(filePath, "utf-8");
+  const content = fs17.readFileSync(filePath, "utf-8");
   const lines = content.split("\n").map((line) => line.replace(/\r$/, ""));
   let currentDate = null;
   let chatName = extractNameFromFilePath8(filePath);
@@ -6946,12 +7032,12 @@ function findEntryFileInDirectory(dirPath, maxDepth = 1) {
     if (depth > maxDepth) return null;
     let entries;
     try {
-      entries = fs17.readdirSync(current, { withFileTypes: true });
+      entries = fs18.readdirSync(current, { withFileTypes: true });
     } catch {
       return null;
     }
     for (const entry of entries) {
-      const full = path13.join(current, entry.name);
+      const full = path14.join(current, entry.name);
       if (entry.isFile() && entry.name.endsWith(".json")) {
         const format = detectFormat(full);
         if (format) return full;
@@ -6959,7 +7045,7 @@ function findEntryFileInDirectory(dirPath, maxDepth = 1) {
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const found = walk(path13.join(current, entry.name), depth + 1);
+        const found = walk(path14.join(current, entry.name), depth + 1);
         if (found) return found;
       }
     }
@@ -7008,8 +7094,8 @@ function logNativeParserStatus() {
 }
 
 // ../../packages/node-runtime/src/import/perf-logger.ts
-import * as fs18 from "fs";
-import * as path14 from "path";
+import * as fs19 from "fs";
+import * as path15 from "path";
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2["ERROR"] = "ERROR";
   LogLevel2["INFO"] = "INFO";
@@ -7021,11 +7107,11 @@ var currentLogFile = null;
 var errorCount = 0;
 function initPerfLog(sessionId, logDir) {
   try {
-    if (!fs18.existsSync(logDir)) {
-      fs18.mkdirSync(logDir, { recursive: true });
+    if (!fs19.existsSync(logDir)) {
+      fs19.mkdirSync(logDir, { recursive: true });
     }
-    currentLogFile = path14.join(logDir, `import_${sessionId}_${Date.now()}.log`);
-    fs18.writeFileSync(currentLogFile, `=== Import Log ===
+    currentLogFile = path15.join(logDir, `import_${sessionId}_${Date.now()}.log`);
+    fs19.writeFileSync(currentLogFile, `=== Import Log ===
 Start time: ${(/* @__PURE__ */ new Date()).toISOString()}
 
 `, "utf-8");
@@ -7046,7 +7132,7 @@ function logPerf(event, messagesProcessed, batchSize) {
   const logLine = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${event} | messages: ${messagesProcessed.toLocaleString()} | elapsed: ${duration}ms | speed: ${speed.toLocaleString()}/s | memory: ${memory}MB` + (batchSize ? ` | batch: ${batchSize}` : "") + "\n";
   if (currentLogFile) {
     try {
-      fs18.appendFileSync(currentLogFile, logLine, "utf-8");
+      fs19.appendFileSync(currentLogFile, logLine, "utf-8");
     } catch {
     }
   }
@@ -7056,7 +7142,7 @@ function logPerf(event, messagesProcessed, batchSize) {
 function logPerfDetail(detail) {
   if (currentLogFile) {
     try {
-      fs18.appendFileSync(currentLogFile, `  ${detail}
+      fs19.appendFileSync(currentLogFile, `  ${detail}
 `, "utf-8");
     } catch {
     }
@@ -7076,7 +7162,7 @@ function writeLogLine(level, message) {
   const logLine = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${message}
 `;
   try {
-    fs18.appendFileSync(currentLogFile, logLine, "utf-8");
+    fs19.appendFileSync(currentLogFile, logLine, "utf-8");
   } catch {
   }
 }
@@ -7101,7 +7187,7 @@ Total members: ${totalMembers.toLocaleString()}
 Errors: ${errorCount}
 `;
   try {
-    fs18.appendFileSync(currentLogFile, summary, "utf-8");
+    fs19.appendFileSync(currentLogFile, summary, "utf-8");
   } catch {
   }
 }
@@ -7200,8 +7286,8 @@ function segmentText(text, locale, minLength) {
 }
 
 // ../../packages/node-runtime/src/nlp/dict-manager.ts
-import * as fs19 from "fs";
-import * as path15 from "path";
+import * as fs20 from "fs";
+import * as path16 from "path";
 import { createHash } from "crypto";
 var DICT_DOWNLOAD_URL_BASE = "https://chatlab.fun/assets/nlp";
 var DICT_SHA256 = {
@@ -7213,19 +7299,19 @@ var AVAILABLE_DICTS = [
   { id: "zh-TW", label: "\u7E41\u9AD4\u4E2D\u6587", locale: "zh-TW" }
 ];
 function getDictFilePath(nlpDir, dictId) {
-  return path15.join(nlpDir, `${dictId}.dict`);
+  return path16.join(nlpDir, `${dictId}.dict`);
 }
 function isDictDownloaded(nlpDir, dictId) {
-  return fs19.existsSync(getDictFilePath(nlpDir, dictId));
+  return fs20.existsSync(getDictFilePath(nlpDir, dictId));
 }
 function getDictList(nlpDir) {
   return AVAILABLE_DICTS.map((d) => {
     const filePath = getDictFilePath(nlpDir, d.id);
-    const downloaded = fs19.existsSync(filePath);
+    const downloaded = fs20.existsSync(filePath);
     let fileSize;
     if (downloaded) {
       try {
-        fileSize = fs19.statSync(filePath).size;
+        fileSize = fs20.statSync(filePath).size;
       } catch {
       }
     }
@@ -7234,9 +7320,9 @@ function getDictList(nlpDir) {
 }
 function loadDictBuffer(nlpDir, dictId) {
   const filePath = getDictFilePath(nlpDir, dictId);
-  if (!fs19.existsSync(filePath)) return null;
+  if (!fs20.existsSync(filePath)) return null;
   try {
-    return fs19.readFileSync(filePath);
+    return fs20.readFileSync(filePath);
   } catch (error) {
     console.error(`[NLP DictManager] Failed to read dict file: ${filePath}`, error);
     return null;
@@ -7246,7 +7332,7 @@ async function downloadDict(nlpDir, dictId, onProgress) {
   if (!AVAILABLE_DICTS.find((d) => d.id === dictId)) {
     return { success: false, error: `Unknown dict: ${dictId}` };
   }
-  fs19.mkdirSync(nlpDir, { recursive: true });
+  fs20.mkdirSync(nlpDir, { recursive: true });
   const url = `${DICT_DOWNLOAD_URL_BASE}/${dictId}.dict`;
   const filePath = getDictFilePath(nlpDir, dictId);
   const tmpPath = filePath + ".tmp";
@@ -7287,16 +7373,16 @@ async function downloadDict(nlpDir, dictId, onProgress) {
     if (actualSha256 !== expectedSha256) {
       return { success: false, error: "Dictionary integrity check failed (SHA256 mismatch)" };
     }
-    fs19.writeFileSync(tmpPath, buffer);
-    if (fs19.existsSync(filePath)) fs19.unlinkSync(filePath);
-    fs19.renameSync(tmpPath, filePath);
+    fs20.writeFileSync(tmpPath, buffer);
+    if (fs20.existsSync(filePath)) fs20.unlinkSync(filePath);
+    fs20.renameSync(tmpPath, filePath);
     clearJiebaInstance(dictId);
-    console.log(`[NLP DictManager] Dict downloaded: ${dictId} (${fs19.statSync(filePath).size} bytes)`);
+    console.log(`[NLP DictManager] Dict downloaded: ${dictId} (${fs20.statSync(filePath).size} bytes)`);
     return { success: true };
   } catch (error) {
-    if (fs19.existsSync(tmpPath)) {
+    if (fs20.existsSync(tmpPath)) {
       try {
-        fs19.unlinkSync(tmpPath);
+        fs20.unlinkSync(tmpPath);
       } catch {
       }
     }
@@ -7307,9 +7393,9 @@ async function downloadDict(nlpDir, dictId, onProgress) {
 }
 function deleteDict(nlpDir, dictId) {
   const filePath = getDictFilePath(nlpDir, dictId);
-  if (!fs19.existsSync(filePath)) return { success: true };
+  if (!fs20.existsSync(filePath)) return { success: true };
   try {
-    fs19.unlinkSync(filePath);
+    fs20.unlinkSync(filePath);
     clearJiebaInstance(dictId);
     console.log(`[NLP DictManager] Dict deleted: ${dictId}`);
     return { success: true };
@@ -7409,7 +7495,7 @@ function searchByFts(db, keywords, limit = 1e3, offset = 0) {
 }
 
 // ../../packages/node-runtime/src/import/streaming-importer.ts
-import * as fs20 from "fs";
+import * as fs21 from "fs";
 
 // ../../packages/node-runtime/src/import/message-deduplicator.ts
 function generateFallbackMessageKey(message) {
@@ -7441,7 +7527,7 @@ function registerMessageAndCheckDuplicate(message, state) {
 // ../../packages/node-runtime/src/import/streaming-importer.ts
 var BATCH_COMMIT_SIZE = 5e4;
 var CHECKPOINT_INTERVAL = 2e5;
-var yieldToEventLoop = () => new Promise((resolve2) => setImmediate(resolve2));
+var yieldToEventLoop = () => new Promise((resolve4) => setImmediate(resolve4));
 function defaultGenerateSessionId() {
   const ts = Date.now();
   const rand = Math.random().toString(36).substring(2, 8);
@@ -7890,8 +7976,8 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
   }
   return { success: true, sessionId, diagnostics };
 }
-async function analyzeNewImport(filePath, onProgress) {
-  const formatFeature = detectFormat(filePath);
+async function analyzeNewImport(filePath, onProgress, options2) {
+  const formatFeature = options2?.formatId ? getFormatFeatureById(options2.formatId) : detectFormat(filePath);
   if (!formatFeature) {
     return {
       totalMessages: 0,
@@ -7908,30 +7994,35 @@ async function analyzeNewImport(filePath, onProgress) {
   let totalMessages = 0;
   let newMessageCount = 0;
   let duplicateCount = 0;
-  await streamParseFile(filePath, {
-    onMeta: (parsedMeta) => {
-      meta = { name: parsedMeta.name, platform: parsedMeta.platform, type: parsedMeta.type };
-    },
-    onMembers: (members) => {
-      for (const m of members) memberSet.add(m.platformId);
-    },
-    onProgress: (progress) => {
-      onProgress(progress);
-    },
-    onMessageBatch: (batch) => {
-      for (const msg of batch) {
-        totalMessages++;
-        if (!memberSet.has(msg.senderPlatformId)) memberSet.add(msg.senderPlatformId);
-        const prepared = prepareMessageForCreate(msg);
-        if ("skipCounter" in prepared) continue;
-        if (registerMessageAndCheckDuplicate(prepared.message, dedupState)) {
-          duplicateCount++;
-        } else {
-          newMessageCount++;
+  await streamParseFile(
+    filePath,
+    {
+      formatOptions: options2?.chatIndex === void 0 ? void 0 : { chatIndex: options2.chatIndex },
+      onMeta: (parsedMeta) => {
+        meta = { name: parsedMeta.name, platform: parsedMeta.platform, type: parsedMeta.type };
+      },
+      onMembers: (members) => {
+        for (const m of members) memberSet.add(m.platformId);
+      },
+      onProgress: (progress) => {
+        onProgress(progress);
+      },
+      onMessageBatch: (batch) => {
+        for (const msg of batch) {
+          totalMessages++;
+          if (!memberSet.has(msg.senderPlatformId)) memberSet.add(msg.senderPlatformId);
+          const prepared = prepareMessageForCreate(msg);
+          if ("skipCounter" in prepared) continue;
+          if (registerMessageAndCheckDuplicate(prepared.message, dedupState)) {
+            duplicateCount++;
+          } else {
+            newMessageCount++;
+          }
         }
       }
-    }
-  });
+    },
+    options2?.formatId
+  );
   return { totalMessages, newMessageCount, duplicateCount, totalMembers: memberSet.size, meta };
 }
 async function streamParseFileInfo(filePath, deps) {
@@ -7939,7 +8030,7 @@ async function streamParseFileInfo(filePath, deps) {
   if (!formatFeature) {
     throw new Error("Unrecognized file format");
   }
-  const fileSize = fs20.statSync(filePath).size;
+  const fileSize = fs21.statSync(filePath).size;
   deps.onProgress({
     stage: "parsing",
     bytesRead: 0,
@@ -8028,7 +8119,7 @@ async function streamParseFileInfo(filePath, deps) {
     }
     db.close();
     try {
-      if (fs20.existsSync(tempDbPath)) fs20.unlinkSync(tempDbPath);
+      if (fs21.existsSync(tempDbPath)) fs21.unlinkSync(tempDbPath);
     } catch {
     }
     throw error;
@@ -8128,8 +8219,8 @@ function normalizeImportTimestamp(timestamp) {
   const value = typeof timestamp === "string" && timestamp.trim() !== "" ? Number(timestamp) : timestamp;
   return typeof value === "number" && value > 0 && Number.isFinite(value) ? value : null;
 }
-async function analyzeIncrementalImport(sessionId, filePath, deps) {
-  const formatFeature = detectFormat(filePath);
+async function analyzeIncrementalImport(sessionId, filePath, deps, options2) {
+  const formatFeature = options2?.formatId ? getFormatFeatureById(options2.formatId) : detectFormat(filePath);
   if (!formatFeature) {
     return { error: "error.unrecognized_format", newMessageCount: 0, duplicateCount: 0, totalInFile: 0 };
   }
@@ -8144,27 +8235,32 @@ async function analyzeIncrementalImport(sessionId, filePath, deps) {
   let totalInFile = 0;
   let newMessageCount = 0;
   let duplicateCount = 0;
-  await streamParseFile(filePath, {
-    onMeta: () => {
-    },
-    onMembers: () => {
-    },
-    onProgress: (progress) => {
-      deps.onProgress(progress);
-    },
-    onMessageBatch: (batch) => {
-      for (const msg of batch) {
-        totalInFile++;
-        const timestamp = normalizeImportTimestamp(msg.timestamp);
-        if (timestamp === null) continue;
-        if (isDuplicate({ ...msg, timestamp }, existingPlatformMsgIds, existingKeys, existingFallbackOnlyKeys)) {
-          duplicateCount++;
-        } else {
-          newMessageCount++;
+  await streamParseFile(
+    filePath,
+    {
+      formatOptions: options2?.chatIndex === void 0 ? void 0 : { chatIndex: options2.chatIndex },
+      onMeta: () => {
+      },
+      onMembers: () => {
+      },
+      onProgress: (progress) => {
+        deps.onProgress(progress);
+      },
+      onMessageBatch: (batch) => {
+        for (const msg of batch) {
+          totalInFile++;
+          const timestamp = normalizeImportTimestamp(msg.timestamp);
+          if (timestamp === null) continue;
+          if (isDuplicate({ ...msg, timestamp }, existingPlatformMsgIds, existingKeys, existingFallbackOnlyKeys)) {
+            duplicateCount++;
+          } else {
+            newMessageCount++;
+          }
         }
       }
-    }
-  });
+    },
+    options2?.formatId
+  );
   return { newMessageCount, duplicateCount, totalInFile };
 }
 async function incrementalImport(sessionId, filePath, deps, options2) {
@@ -8418,6 +8514,12 @@ async function incrementalImport(sessionId, filePath, deps, options2) {
   }
 }
 
+// ../../packages/node-runtime/src/import/session-id.ts
+var SAFE_IMPORT_SESSION_ID_RE = /^[A-Za-z0-9_@-][A-Za-z0-9._@-]{0,127}$/;
+function isValidImportSessionId(sessionId) {
+  return SAFE_IMPORT_SESSION_ID_RE.test(sessionId) && !sessionId.includes("..");
+}
+
 // ../../packages/node-runtime/src/import/auto-import-matcher.ts
 var MATCH_WINDOW_SIZE = 5;
 function buildPrivateIdentity(ownerId, memberIds) {
@@ -8528,6 +8630,20 @@ async function resolveAutoImportTarget(filePath, deps, formatOptions) {
 }
 
 // ../../packages/node-runtime/src/import/auto-importer.ts
+async function planAutoImport(filePath, deps, options2) {
+  if (options2.explicitSessionId) {
+    if (!isValidImportSessionId(options2.explicitSessionId)) {
+      throw new Error("sessionId contains invalid characters");
+    }
+    return deps.sessionExists(options2.explicitSessionId) ? { action: "incremental", sessionId: options2.explicitSessionId } : { action: "create", sessionId: options2.explicitSessionId };
+  }
+  const decision = await (deps.resolveTarget ?? resolveAutoImportTarget)(
+    filePath,
+    deps,
+    options2.formatOptions
+  );
+  return decision.action === "incremental" ? { action: "incremental", sessionId: decision.sessionId, matchedBy: decision.matchedBy } : { action: "create", reason: decision.reason };
+}
 function mapCreateResult(result, createReason) {
   if (!result.success || !result.sessionId) {
     return { success: false, error: result.error, diagnostics: result.diagnostics };
@@ -8539,6 +8655,11 @@ function mapCreateResult(result, createReason) {
     ...createReason ? { createReason } : {},
     newMessageCount: result.diagnostics?.messagesWritten ?? 0,
     duplicateCount: result.diagnostics?.duplicateCount ?? 0,
+    batch: result.diagnostics ? {
+      receivedCount: result.diagnostics.messagesReceived,
+      writtenCount: result.diagnostics.messagesWritten,
+      duplicateCount: result.diagnostics.duplicateCount
+    } : void 0,
     diagnostics: result.diagnostics
   };
 }
@@ -8550,61 +8671,41 @@ function mapIncrementalResult(sessionId, result, matchedBy) {
     importMode: "incremental",
     ...matchedBy ? { matchedBy } : {},
     newMessageCount: result.newMessageCount,
-    duplicateCount: result.batch?.duplicateCount ?? 0
+    duplicateCount: result.batch?.duplicateCount ?? 0,
+    batch: result.batch,
+    session: result.session,
+    updates: result.updates
   };
 }
 async function autoImportFile(filePath, deps, options2 = {}) {
   try {
-    if (options2.explicitSessionId) {
-      if (deps.sessionExists(options2.explicitSessionId)) {
-        const result3 = mapIncrementalResult(
-          options2.explicitSessionId,
-          await deps.appendSession(options2.explicitSessionId, filePath, options2.formatOptions)
-        );
-        appLogger.info("import", "Explicit incremental import completed", {
-          sessionId: options2.explicitSessionId,
-          success: result3.success,
-          newMessageCount: result3.newMessageCount,
-          duplicateCount: result3.duplicateCount
-        });
-        return result3;
-      }
-      const result2 = mapCreateResult(
-        await deps.createSession(filePath, options2.formatOptions, options2.explicitSessionId)
-      );
-      appLogger.info("import", "Explicit session import completed", {
-        sessionId: result2.sessionId,
-        success: result2.success,
-        importMode: result2.importMode
+    if (!options2.explicitSessionId) {
+      appLogger.info("import", "Automatic session matching started", {
+        candidateCount: deps.listSessionIds().length
       });
-      return result2;
     }
-    appLogger.info("import", "Automatic session matching started", {
-      candidateCount: deps.listSessionIds().length
-    });
-    const decision = await (deps.resolveTarget ?? resolveAutoImportTarget)(
-      filePath,
-      deps,
-      options2.formatOptions
-    );
-    if (decision.action === "incremental") {
+    const plan = await planAutoImport(filePath, deps, options2);
+    if (plan.action === "incremental") {
       const result2 = mapIncrementalResult(
-        decision.sessionId,
-        await deps.appendSession(decision.sessionId, filePath, options2.formatOptions),
-        decision.matchedBy
+        plan.sessionId,
+        await deps.appendSession(plan.sessionId, filePath, options2.formatOptions),
+        plan.matchedBy
       );
-      appLogger.info("import", "Automatic incremental import completed", {
-        sessionId: decision.sessionId,
-        matchedBy: decision.matchedBy,
+      appLogger.info("import", "Incremental import completed", {
+        sessionId: plan.sessionId,
+        matchedBy: plan.matchedBy,
         success: result2.success,
         newMessageCount: result2.newMessageCount,
         duplicateCount: result2.duplicateCount
       });
       return result2;
     }
-    const result = mapCreateResult(await deps.createSession(filePath, options2.formatOptions), decision.reason);
-    appLogger.info("import", "Automatic import created a new session", {
-      reason: decision.reason,
+    const result = mapCreateResult(
+      await deps.createSession(filePath, options2.formatOptions, plan.sessionId),
+      plan.reason
+    );
+    appLogger.info("import", "Import created a new session", {
+      reason: plan.reason,
       sessionId: result.sessionId,
       success: result.success
     });
@@ -8614,10 +8715,57 @@ async function autoImportFile(filePath, deps, options2 = {}) {
     return { success: false, error: error instanceof Error ? error.message : String(error) };
   }
 }
+async function analyzeAutoImportFile(filePath, deps, options2 = {}) {
+  try {
+    const plan = await planAutoImport(filePath, deps, options2);
+    if (plan.action === "incremental") {
+      const analysis2 = await deps.analyzeAppendSession(plan.sessionId, filePath, options2.formatOptions);
+      if (analysis2.error) return { success: false, error: analysis2.error };
+      const result2 = {
+        success: true,
+        importMode: "incremental",
+        sessionId: plan.sessionId,
+        ...plan.matchedBy ? { matchedBy: plan.matchedBy } : {},
+        totalMessageCount: analysis2.totalInFile,
+        newMessageCount: analysis2.newMessageCount,
+        duplicateCount: analysis2.duplicateCount
+      };
+      appLogger.info("import", "Incremental import analysis completed", {
+        sessionId: plan.sessionId,
+        matchedBy: plan.matchedBy,
+        newMessageCount: analysis2.newMessageCount,
+        duplicateCount: analysis2.duplicateCount
+      });
+      return result2;
+    }
+    const analysis = await deps.analyzeCreateSession(filePath, options2.formatOptions);
+    if (analysis.error) return { success: false, error: analysis.error };
+    const result = {
+      success: true,
+      importMode: "created",
+      ...plan.sessionId ? { sessionId: plan.sessionId } : {},
+      ...plan.reason ? { createReason: plan.reason } : {},
+      totalMessageCount: analysis.totalMessages,
+      newMessageCount: analysis.newMessageCount,
+      duplicateCount: analysis.duplicateCount,
+      totalMemberCount: analysis.totalMembers,
+      meta: analysis.meta
+    };
+    appLogger.info("import", "New session import analysis completed", {
+      reason: plan.reason,
+      messageCount: analysis.totalMessages,
+      memberCount: analysis.totalMembers
+    });
+    return result;
+  } catch (error) {
+    appLogger.error("import", "Automatic import analysis failed", error);
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
 
 // ../../packages/node-runtime/src/import/import-lock.ts
-import * as fs21 from "fs";
-import * as path16 from "path";
+import * as fs22 from "fs";
+import * as path17 from "path";
 import { randomUUID } from "crypto";
 var IMPORT_LOCK_FILENAME = ".chatlab-import.lock";
 var IMPORT_IN_PROGRESS_ERROR_KEY = "error.import_in_progress";
@@ -8631,7 +8779,7 @@ var ImportInProgressError = class extends Error {
 };
 function parseOwner(lockPath) {
   try {
-    const parsed = JSON.parse(fs21.readFileSync(lockPath, "utf-8"));
+    const parsed = JSON.parse(fs22.readFileSync(lockPath, "utf-8"));
     if (typeof parsed.pid !== "number" || !Number.isInteger(parsed.pid) || parsed.pid <= 0 || typeof parsed.token !== "string" || parsed.token.length === 0 || typeof parsed.startedAt !== "number") {
       return null;
     }
@@ -8654,13 +8802,13 @@ function removeStaleLock(lockPath) {
     if (isProcessRunning(owner.pid)) return false;
   } else {
     try {
-      if (Date.now() - fs21.statSync(lockPath).mtimeMs < 5e3) return false;
+      if (Date.now() - fs22.statSync(lockPath).mtimeMs < 5e3) return false;
     } catch {
       return true;
     }
   }
   try {
-    fs21.unlinkSync(lockPath);
+    fs22.unlinkSync(lockPath);
     appLogger.warn("import-lock", "Removed stale import lock", { ownerPid: owner?.pid });
     return true;
   } catch {
@@ -8669,7 +8817,7 @@ function removeStaleLock(lockPath) {
 }
 function releaseLock(lockPath, fd, owner) {
   try {
-    fs21.closeSync(fd);
+    fs22.closeSync(fd);
   } catch (error) {
     appLogger.error("import-lock", "Failed to close import lock", error);
   }
@@ -8678,19 +8826,19 @@ function releaseLock(lockPath, fd, owner) {
       appLogger.warn("import-lock", "Import lock ownership changed before release");
       return;
     }
-    fs21.unlinkSync(lockPath);
+    fs22.unlinkSync(lockPath);
     appLogger.info("import-lock", "Import lock released");
   } catch (error) {
     appLogger.error("import-lock", "Failed to release import lock", error);
   }
 }
 async function withDataDirImportLock(userDataDir, task) {
-  fs21.mkdirSync(userDataDir, { recursive: true });
-  const lockPath = path16.join(userDataDir, IMPORT_LOCK_FILENAME);
+  fs22.mkdirSync(userDataDir, { recursive: true });
+  const lockPath = path17.join(userDataDir, IMPORT_LOCK_FILENAME);
   let fd = null;
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      fd = fs21.openSync(lockPath, "wx");
+      fd = fs22.openSync(lockPath, "wx");
       break;
     } catch (error) {
       const code = error.code;
@@ -8709,8 +8857,8 @@ async function withDataDirImportLock(userDataDir, task) {
     startedAt: Date.now()
   };
   try {
-    fs21.writeFileSync(fd, JSON.stringify(owner), "utf-8");
-    fs21.fsyncSync(fd);
+    fs22.writeFileSync(fd, JSON.stringify(owner), "utf-8");
+    fs22.fsyncSync(fd);
     appLogger.info("import-lock", "Import lock acquired");
     return await task();
   } finally {
@@ -8730,8 +8878,8 @@ var ArchiveImportError = class extends Error {
 
 // ../../packages/node-runtime/src/import/archive/archive-reader.ts
 var import_yauzl = __toESM(require_yauzl(), 1);
-import * as fs22 from "fs";
-import * as path17 from "path";
+import * as fs23 from "fs";
+import * as path18 from "path";
 import { pipeline } from "stream/promises";
 var DEFAULT_MAX_ENTRIES = 1e5;
 var DEFAULT_MAX_ENTRY_BYTES = 20 * 1024 * 1024 * 1024;
@@ -8850,8 +8998,8 @@ var ZipArchiveReader = class {
     await this.visitEntries(async (entry, openStream) => {
       const destination = targets.get(entry.name);
       if (!destination || entry.isDirectory) return;
-      fs22.mkdirSync(path17.dirname(destination), { recursive: true });
-      await pipeline(await openStream(), fs22.createWriteStream(destination, { flags: "wx" }));
+      fs23.mkdirSync(path18.dirname(destination), { recursive: true });
+      await pipeline(await openStream(), fs23.createWriteStream(destination, { flags: "wx" }));
       remaining.delete(entry.name);
     });
     if (remaining.size > 0) {
@@ -8868,8 +9016,8 @@ var import_stream_chain9 = __toESM(require_stream_chain(), 1);
 var import_stream_json9 = __toESM(require_stream_json(), 1);
 var import_Pick8 = __toESM(require_Pick(), 1);
 var import_StreamValues9 = __toESM(require_StreamValues(), 1);
-import * as fs23 from "fs";
-import * as path18 from "path";
+import * as fs24 from "fs";
+import * as path19 from "path";
 var { chain: chain9 } = import_stream_chain9.default;
 var { parser: parser10 } = import_stream_json9.default;
 var { pick: pick8 } = import_Pick8.default;
@@ -8998,16 +9146,16 @@ var GoogleChatTakeoutResolver = class {
         `Google Chat conversation is missing required files: ${chat.chatId}`
       );
     }
-    fs23.mkdirSync(targetDir, { recursive: true });
+    fs24.mkdirSync(targetDir, { recursive: true });
     await reader.pipeEntries(
       /* @__PURE__ */ new Map([
-        [userInfoEntry, path18.join(targetDir, "user_info.json")],
-        [groupInfoEntry, path18.join(targetDir, "group_info.json")],
-        [messagesEntry, path18.join(targetDir, "messages.json")]
+        [userInfoEntry, path19.join(targetDir, "user_info.json")],
+        [groupInfoEntry, path19.join(targetDir, "group_info.json")],
+        [messagesEntry, path19.join(targetDir, "messages.json")]
       ])
     );
-    const manifestPath = path18.join(targetDir, "google-chat-import.json");
-    fs23.writeFileSync(
+    const manifestPath = path19.join(targetDir, "google-chat-import.json");
+    fs24.writeFileSync(
       manifestPath,
       JSON.stringify(
         {
@@ -9030,8 +9178,8 @@ var GoogleChatTakeoutResolver = class {
 };
 
 // ../../packages/node-runtime/src/import/archive/source-manager.ts
-import * as fs24 from "fs";
-import * as path19 from "path";
+import * as fs25 from "fs";
+import * as path20 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 var DEFAULT_TTL_MS = 30 * 60 * 1e3;
 var ArchiveImportSourceManager = class {
@@ -9042,11 +9190,11 @@ var ArchiveImportSourceManager = class {
   now;
   resolvers;
   constructor(options2 = {}) {
-    this.tempRoot = options2.tempRoot ?? path19.join(process.cwd(), ".chatlab-import-sources");
+    this.tempRoot = options2.tempRoot ?? createChatLabTempDir("imports", "sources-");
     this.ttlMs = options2.ttlMs ?? DEFAULT_TTL_MS;
     this.now = options2.now ?? Date.now;
     this.resolvers = options2.resolvers ?? [new GoogleChatTakeoutResolver()];
-    fs24.mkdirSync(this.tempRoot, { recursive: true });
+    fs25.mkdirSync(this.tempRoot, { recursive: true });
   }
   prepareLocalArchive(archivePath) {
     return this.prepareArchive(archivePath, false);
@@ -9103,7 +9251,7 @@ var ArchiveImportSourceManager = class {
         `Archive conversation was not found: ${chatId}`
       );
     }
-    const materializedDir = fs24.mkdtempSync(path19.join(this.tempRoot, `materialized-${sourceId}-`));
+    const materializedDir = fs25.mkdtempSync(path20.join(this.tempRoot, `materialized-${sourceId}-`));
     try {
       const reader = new ZipArchiveReader(record.archivePath);
       const materialized = await record.resolver.materialize(reader, chat, materializedDir);
@@ -9154,7 +9302,7 @@ var ArchiveImportSourceManager = class {
   }
   removePath(targetPath) {
     try {
-      fs24.rmSync(targetPath, { recursive: true, force: true });
+      fs25.rmSync(targetPath, { recursive: true, force: true });
     } catch {
     }
   }
@@ -9224,12 +9372,12 @@ ${rawErrorLabel}: ${details}`;
 }
 
 // ../../packages/node-runtime/src/ai/assistant-parser.ts
-import * as path20 from "path";
+import * as path21 from "path";
 import matter from "gray-matter";
 function parseAssistantFile(content, filePath) {
   try {
     const { data: fm, content: body } = matter(content);
-    const id = fm.id ?? path20.basename(filePath, ".md");
+    const id = fm.id ?? path21.basename(filePath, ".md");
     const name = fm.name;
     if (!name) return null;
     return {
@@ -9308,8 +9456,8 @@ var AssistantManager = class {
   }
   // ==================== Init ====================
   init() {
-    const { fs: fs35, assistantsDir } = this.deps;
-    fs35.ensureDir(assistantsDir);
+    const { fs: fs37, assistantsDir } = this.deps;
+    fs37.ensureDir(assistantsDir);
     const generalCreated = this.ensureGeneralAssistants();
     this.loadAll();
     this.initialized = true;
@@ -9320,26 +9468,26 @@ var AssistantManager = class {
     return { total: this.cache.size, generalCreated };
   }
   ensureGeneralAssistants() {
-    const { fs: fs35, assistantsDir } = this.deps;
+    const { fs: fs37, assistantsDir } = this.deps;
     let anyCreated = false;
     for (const id of this.generalIds) {
       const config = this.getBuiltinConfig(id);
       if (!config) continue;
-      const filePath = fs35.joinPath(assistantsDir, `${id}.md`);
-      if (fs35.fileExists(filePath)) continue;
-      fs35.writeFile(filePath, serializeAssistant({ ...config, builtinId: config.id }));
+      const filePath = fs37.joinPath(assistantsDir, `${id}.md`);
+      if (fs37.fileExists(filePath)) continue;
+      fs37.writeFile(filePath, serializeAssistant({ ...config, builtinId: config.id }));
       anyCreated = true;
     }
     return anyCreated;
   }
   loadAll() {
-    const { fs: fs35, assistantsDir } = this.deps;
+    const { fs: fs37, assistantsDir } = this.deps;
     this.cache.clear();
-    const files = fs35.listFiles(assistantsDir, ".md");
+    const files = fs37.listFiles(assistantsDir, ".md");
     for (const file of files) {
       try {
-        const filePath = fs35.joinPath(assistantsDir, file);
-        const content = fs35.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);
@@ -9451,12 +9599,12 @@ var AssistantManager = class {
 };
 
 // ../../packages/node-runtime/src/ai/skill-parser.ts
-import * as path21 from "path";
+import * as path22 from "path";
 import matter2 from "gray-matter";
 function parseSkillFile(content, filePath) {
   try {
     const { data: fm, content: prompt } = matter2(content);
-    const id = fm.id ?? path21.basename(filePath, ".md");
+    const id = fm.id ?? path22.basename(filePath, ".md");
     const name = fm.name;
     if (!name) return null;
     return {
@@ -9475,7 +9623,7 @@ function parseSkillFile(content, filePath) {
 function extractSkillId(content, filePath) {
   try {
     const { data: fm } = matter2(content);
-    return fm.id ?? path21.basename(filePath, ".md");
+    return fm.id ?? path22.basename(filePath, ".md");
   } catch {
     return null;
   }
@@ -9494,8 +9642,8 @@ function validateChatScope(raw) {
 
 // ../../packages/node-runtime/src/ai/chats.ts
 import Database from "better-sqlite3";
-import * as fs25 from "fs";
-import * as path22 from "path";
+import * as fs26 from "fs";
+import * as path23 from "path";
 var DEFAULT_GENERAL_ID = "general_cn";
 var defaultLogger = {
   warn(_category, message, extra) {
@@ -9514,14 +9662,14 @@ var AIChatManager = class {
     this.nativeBinding = options2?.nativeBinding;
   }
   ensureDir(dir) {
-    if (!fs25.existsSync(dir)) {
-      fs25.mkdirSync(dir, { recursive: true });
+    if (!fs26.existsSync(dir)) {
+      fs26.mkdirSync(dir, { recursive: true });
     }
   }
   getDb() {
     if (this.db) return this.db;
     this.ensureDir(this.aiDataDir);
-    const dbPath = path22.join(this.aiDataDir, "conversations.db");
+    const dbPath = path23.join(this.aiDataDir, "conversations.db");
     this.db = this.nativeBinding ? new Database(dbPath, { nativeBinding: this.nativeBinding }) : new Database(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.exec(`
@@ -9764,16 +9912,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 path31 = [];
+    const path33 = [];
     const seen = /* @__PURE__ */ new Set();
     while (currentId && !seen.has(currentId)) {
       seen.add(currentId);
       const row = rowMap.get(currentId);
       if (!row) break;
-      path31.push(row);
+      path33.push(row);
       currentId = row.parentId;
     }
-    return path31.length > 0 ? path31.reverse() : allRows;
+    return path33.length > 0 ? path33.reverse() : allRows;
   }
   // ==================== 生命周期 ====================
   close() {
@@ -10343,21 +10491,21 @@ var SkillManagerCore = class {
   }
   // ==================== Init ====================
   init() {
-    const { fs: fs35, skillsDir } = this.deps;
-    fs35.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: fs35, skillsDir } = this.deps;
+    const { fs: fs37, skillsDir } = this.deps;
     this.cache.clear();
-    const files = fs35.listFiles(skillsDir, ".md");
+    const files = fs37.listFiles(skillsDir, ".md");
     for (const file of files) {
       try {
-        const filePath = fs35.joinPath(skillsDir, file);
-        const content = fs35.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);
@@ -10509,8 +10657,8 @@ var SkillManagerCore = class {
 };
 
 // ../../packages/node-runtime/src/ai/skill-manager.ts
-import * as fs26 from "fs";
-import * as path23 from "path";
+import * as fs27 from "fs";
+import * as path24 from "path";
 var SKILLS_DIR_NAME = "skills";
 var defaultLogger2 = {
   info: () => {
@@ -10520,26 +10668,26 @@ var defaultLogger2 = {
 };
 var nodeFs = {
   ensureDir(dir) {
-    fs26.mkdirSync(dir, { recursive: true });
+    fs27.mkdirSync(dir, { recursive: true });
   },
   listFiles(dir, ext) {
-    if (!fs26.existsSync(dir)) return [];
-    return fs26.readdirSync(dir).filter((file) => file.endsWith(ext));
+    if (!fs27.existsSync(dir)) return [];
+    return fs27.readdirSync(dir).filter((file) => file.endsWith(ext));
   },
   readFile(filePath) {
-    return fs26.readFileSync(filePath, "utf-8");
+    return fs27.readFileSync(filePath, "utf-8");
   },
   writeFile(filePath, content) {
-    fs26.writeFileSync(filePath, content, "utf-8");
+    fs27.writeFileSync(filePath, content, "utf-8");
   },
   deleteFile(filePath) {
-    fs26.unlinkSync(filePath);
+    fs27.unlinkSync(filePath);
   },
   fileExists(filePath) {
-    return fs26.existsSync(filePath);
+    return fs27.existsSync(filePath);
   },
   joinPath(...parts) {
-    return path23.join(...parts);
+    return path24.join(...parts);
   }
 };
 var SkillManager = class {
@@ -10549,7 +10697,7 @@ var SkillManager = class {
     this.logger = logger ?? defaultLogger2;
     this.core = new SkillManagerCore({
       fs: nodeFs,
-      skillsDir: path23.join(aiDataDir, SKILLS_DIR_NAME),
+      skillsDir: path24.join(aiDataDir, SKILLS_DIR_NAME),
       builtinRawSkills: [],
       logger: {
         info: () => {
@@ -14379,9 +14527,9 @@ var localeMap = {
   "ja-JP": ja_JP_default,
   "zh-TW": zh_TW_default
 };
-function getNestedValue(obj, path31) {
+function getNestedValue(obj, path33) {
   let current = obj;
-  for (const segment2 of path31.split(".")) {
+  for (const segment2 of path33.split(".")) {
     if (current == null || typeof current !== "object") return void 0;
     current = current[segment2];
   }
@@ -14894,6 +15042,49 @@ var LLMConfigStore = class {
   }
 };
 
+// ../../packages/node-runtime/src/ai/file-config-storage.ts
+import * as fs28 from "fs";
+import * as path25 from "path";
+function createFileConfigStorage(baseDir) {
+  return {
+    readJson(key) {
+      try {
+        return JSON.parse(fs28.readFileSync(path25.join(baseDir, `${key}.json`), "utf-8"));
+      } catch {
+        return null;
+      }
+    },
+    writeJson(key, data) {
+      fs28.mkdirSync(baseDir, { recursive: true });
+      fs28.writeFileSync(path25.join(baseDir, `${key}.json`), JSON.stringify(data, null, 2), "utf-8");
+    }
+  };
+}
+
+// ../../packages/node-runtime/src/ai/auth-profile-llm-config-store.ts
+var defaultDeps = {
+  resolveApiKey: (provider, authProfile) => resolveApiKey(provider, authProfile) || void 0,
+  writeAuthProfile,
+  deleteAuthProfile
+};
+function getAuthProfile2(config) {
+  return config.authProfile;
+}
+function createAuthProfileLlmConfigStore(storage, deps = defaultDeps) {
+  return new LLMConfigStore(storage, {
+    resolveApiKey: deps.resolveApiKey,
+    onApiKeyCreated: (config, apiKey) => {
+      const profileName = config.name?.toLowerCase().replace(/\s+/g, "-") || config.provider;
+      deps.writeAuthProfile(profileName, { type: "api_key", provider: config.provider, key: apiKey });
+      return profileName;
+    },
+    onApiKeyDeleted: (config) => {
+      const profileName = getAuthProfile2(config);
+      if (profileName) deps.deleteAuthProfile(profileName);
+    }
+  });
+}
+
 // ../../packages/node-runtime/src/ai/custom-store.ts
 function generateCustomId() {
   return `custom:${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
@@ -15713,8 +15904,8 @@ function exportWithFormat(params, openDatabase) {
 }
 
 // ../../packages/node-runtime/src/merger/temp-db.ts
-import * as fs27 from "fs";
-import * as path24 from "path";
+import * as fs29 from "fs";
+import * as path26 from "path";
 var TEMP_DB_SCHEMA = `
   CREATE TABLE IF NOT EXISTS meta (
     name TEXT NOT NULL,
@@ -15959,21 +16150,21 @@ function exportSessionToJson(db) {
 }
 function deleteTempDatabase(dbPath) {
   try {
-    if (fs27.existsSync(dbPath)) fs27.unlinkSync(dbPath);
+    if (fs29.existsSync(dbPath)) fs29.unlinkSync(dbPath);
     const walPath = dbPath + "-wal";
     const shmPath = dbPath + "-shm";
-    if (fs27.existsSync(walPath)) fs27.unlinkSync(walPath);
-    if (fs27.existsSync(shmPath)) fs27.unlinkSync(shmPath);
+    if (fs29.existsSync(walPath)) fs29.unlinkSync(walPath);
+    if (fs29.existsSync(shmPath)) fs29.unlinkSync(shmPath);
   } catch {
   }
 }
 function cleanupTempDatabases(tempDir) {
   try {
-    if (!fs27.existsSync(tempDir)) return;
-    const files = fs27.readdirSync(tempDir);
+    if (!fs29.existsSync(tempDir)) return;
+    const files = fs29.readdirSync(tempDir);
     for (const file of files) {
       if (file.startsWith("merge_") && file.endsWith(".db")) {
-        deleteTempDatabase(path24.join(tempDir, file));
+        deleteTempDatabase(path26.join(tempDir, file));
       }
     }
   } catch {
@@ -16052,6 +16243,7 @@ function deleteSession(adapter, sessionId) {
 var member_service_exports = {};
 __export(member_service_exports, {
   deleteMember: () => deleteMember2,
+  deleteMembers: () => deleteMembers2,
   getMemberNameHistory: () => getMemberNameHistory2,
   getMembers: () => getMembers,
   getMembersPaginated: () => getMembersPaginated2,
@@ -16085,6 +16277,10 @@ function deleteMember2(adapter, sessionId, memberId) {
   const db = adapter.ensureWritable(sessionId);
   return deleteMember(db, memberId);
 }
+function deleteMembers2(adapter, sessionId, memberIds) {
+  const db = adapter.ensureWritable(sessionId);
+  return deleteMembers(db, memberIds);
+}
 function getMemberNameHistory2(adapter, sessionId, memberId) {
   const db = adapter.ensureReadonly(sessionId);
   return getMemberNameHistory(db, memberId);
@@ -16353,8 +16549,8 @@ function clearSessionOwner(adapter, sessionId) {
 }
 
 // ../../packages/node-runtime/src/services/contacts/overrides.ts
-import fs28 from "fs";
-import path25 from "path";
+import fs30 from "fs";
+import path27 from "path";
 var CONTACT_OVERRIDES_FILE_NAME = "contact-overrides.json";
 var CONTACT_OVERRIDES_TMP_PREFIX = "contact-overrides.tmp-";
 var CONTACT_OVERRIDES_VERSION = 1;
@@ -16365,23 +16561,23 @@ function createEmptyContactOverridesFile() {
   };
 }
 function getContactOverridesPath(snapshotDir) {
-  return path25.join(snapshotDir, CONTACT_OVERRIDES_FILE_NAME);
+  return path27.join(snapshotDir, CONTACT_OVERRIDES_FILE_NAME);
 }
 function readContactOverrides(snapshotDir) {
   const filePath = getContactOverridesPath(snapshotDir);
-  if (!fs28.existsSync(filePath)) return createEmptyContactOverridesFile();
+  if (!fs30.existsSync(filePath)) return createEmptyContactOverridesFile();
   try {
-    return normalizeContactOverrides(JSON.parse(fs28.readFileSync(filePath, "utf-8")));
+    return normalizeContactOverrides(JSON.parse(fs30.readFileSync(filePath, "utf-8")));
   } catch (error) {
     appLogger.warn("contacts", "contact overrides file is unreadable", error);
     return createEmptyContactOverridesFile();
   }
 }
 function writeContactOverrides(snapshotDir, overrides) {
-  if (!fs28.existsSync(snapshotDir)) fs28.mkdirSync(snapshotDir, { recursive: true });
-  const tmpPath = path25.join(snapshotDir, `${CONTACT_OVERRIDES_TMP_PREFIX}${process.pid}-${Date.now()}`);
-  fs28.writeFileSync(tmpPath, JSON.stringify(normalizeContactOverrides(overrides), null, 2), "utf-8");
-  fs28.renameSync(tmpPath, getContactOverridesPath(snapshotDir));
+  if (!fs30.existsSync(snapshotDir)) fs30.mkdirSync(snapshotDir, { recursive: true });
+  const tmpPath = path27.join(snapshotDir, `${CONTACT_OVERRIDES_TMP_PREFIX}${process.pid}-${Date.now()}`);
+  fs30.writeFileSync(tmpPath, JSON.stringify(normalizeContactOverrides(overrides), null, 2), "utf-8");
+  fs30.renameSync(tmpPath, getContactOverridesPath(snapshotDir));
 }
 function normalizeContactOverrides(value) {
   const input = isRecord2(value) ? value : {};
@@ -16416,23 +16612,23 @@ function buildContactsSignature(adapter, timeRangePreset) {
 }
 
 // ../../packages/node-runtime/src/services/contacts/snapshot.ts
-import fs29 from "fs";
-import path26 from "path";
+import fs31 from "fs";
+import path28 from "path";
 var CONTACTS_SNAPSHOT_TMP_PREFIX = "contacts-snapshot.tmp-";
 function getContactsSnapshotPath(snapshotDir, timeRangePreset) {
   const preset = normalizeContactsTimeRangePreset(timeRangePreset);
-  return path26.join(snapshotDir, `contacts-snapshot-${preset}.json`);
+  return path28.join(snapshotDir, `contacts-snapshot-${preset}.json`);
 }
 function readContactsSnapshot(snapshotDir, timeRangePreset, options2 = {}) {
   const snapshotPath = getContactsSnapshotPath(snapshotDir, timeRangePreset);
-  if (!fs29.existsSync(snapshotPath)) return null;
+  if (!fs31.existsSync(snapshotPath)) return null;
   try {
-    return JSON.parse(fs29.readFileSync(snapshotPath, "utf-8"));
+    return JSON.parse(fs31.readFileSync(snapshotPath, "utf-8"));
   } catch (error) {
     const ts = options2.now?.() ?? Date.now();
-    const backupPath = path26.join(snapshotDir, `contacts-snapshot.corrupt-${ts}.json`);
+    const backupPath = path28.join(snapshotDir, `contacts-snapshot.corrupt-${ts}.json`);
     try {
-      fs29.renameSync(snapshotPath, backupPath);
+      fs31.renameSync(snapshotPath, backupPath);
     } catch (renameError) {
       appLogger.warn("contacts", "failed to backup corrupt contacts snapshot", renameError);
     }
@@ -16441,17 +16637,17 @@ function readContactsSnapshot(snapshotDir, timeRangePreset, options2 = {}) {
   }
 }
 function writeContactsSnapshot(snapshotDir, snapshot) {
-  if (!fs29.existsSync(snapshotDir)) fs29.mkdirSync(snapshotDir, { recursive: true });
-  const tmpPath = path26.join(snapshotDir, `${CONTACTS_SNAPSHOT_TMP_PREFIX}${process.pid}-${Date.now()}`);
-  fs29.writeFileSync(tmpPath, JSON.stringify(snapshot, null, 2), "utf-8");
-  fs29.renameSync(tmpPath, getContactsSnapshotPath(snapshotDir, snapshot.timeRange.preset));
+  if (!fs31.existsSync(snapshotDir)) fs31.mkdirSync(snapshotDir, { recursive: true });
+  const tmpPath = path28.join(snapshotDir, `${CONTACTS_SNAPSHOT_TMP_PREFIX}${process.pid}-${Date.now()}`);
+  fs31.writeFileSync(tmpPath, JSON.stringify(snapshot, null, 2), "utf-8");
+  fs31.renameSync(tmpPath, getContactsSnapshotPath(snapshotDir, snapshot.timeRange.preset));
 }
 function cleanupContactsSnapshotTempFiles(snapshotDir) {
-  if (!fs29.existsSync(snapshotDir)) return;
-  for (const name of fs29.readdirSync(snapshotDir)) {
+  if (!fs31.existsSync(snapshotDir)) return;
+  for (const name of fs31.readdirSync(snapshotDir)) {
     if (!name.startsWith(CONTACTS_SNAPSHOT_TMP_PREFIX)) continue;
     try {
-      fs29.rmSync(path26.join(snapshotDir, name), { force: true });
+      fs31.rmSync(path28.join(snapshotDir, name), { force: true });
     } catch (error) {
       appLogger.warn("contacts", "failed to remove contacts snapshot temp file", error);
     }
@@ -16489,7 +16685,7 @@ function createWorker(workerData, entryUrlInput) {
   return new Worker(bootstrap, options2);
 }
 function createContactsWorkerRunner(options2) {
-  return ({ signature, timeRangePreset, signal, onProgress }) => new Promise((resolve2, reject) => {
+  return ({ signature, timeRangePreset, signal, onProgress }) => new Promise((resolve4, reject) => {
     if (signal.aborted) {
       reject(createAbortError());
       return;
@@ -16520,7 +16716,7 @@ function createContactsWorkerRunner(options2) {
       if (message.type === "success" && message.snapshot) {
         settled = true;
         signal.removeEventListener("abort", abort);
-        resolve2(message.snapshot);
+        resolve4(message.snapshot);
         void worker.terminate();
         return;
       }
@@ -16949,23 +17145,23 @@ function buildPeopleRelationshipsSignature(adapter, timeRangePreset) {
 }
 
 // ../../packages/node-runtime/src/services/people/relationships/snapshot.ts
-import fs30 from "fs";
-import path27 from "path";
+import fs32 from "fs";
+import path29 from "path";
 var PEOPLE_RELATIONSHIPS_SNAPSHOT_TMP_PREFIX = "people-relationships-snapshot.tmp-";
 function getPeopleRelationshipsSnapshotPath(snapshotDir, timeRangePreset) {
   const preset = normalizePeopleRelationshipsTimeRangePreset(timeRangePreset);
-  return path27.join(snapshotDir, `graph-snapshot-${preset}.json`);
+  return path29.join(snapshotDir, `graph-snapshot-${preset}.json`);
 }
 function readPeopleRelationshipsSnapshot(snapshotDir, timeRangePreset, options2 = {}) {
   const snapshotPath = getPeopleRelationshipsSnapshotPath(snapshotDir, timeRangePreset);
-  if (!fs30.existsSync(snapshotPath)) return null;
+  if (!fs32.existsSync(snapshotPath)) return null;
   try {
-    return JSON.parse(fs30.readFileSync(snapshotPath, "utf-8"));
+    return JSON.parse(fs32.readFileSync(snapshotPath, "utf-8"));
   } catch (error) {
     const ts = options2.now?.() ?? Date.now();
-    const backupPath = path27.join(snapshotDir, `graph-snapshot.corrupt-${ts}.json`);
+    const backupPath = path29.join(snapshotDir, `graph-snapshot.corrupt-${ts}.json`);
     try {
-      fs30.renameSync(snapshotPath, backupPath);
+      fs32.renameSync(snapshotPath, backupPath);
     } catch (renameError) {
       appLogger.warn("people-relationships", "failed to backup corrupt people relationships snapshot", renameError);
     }
@@ -16974,17 +17170,17 @@ function readPeopleRelationshipsSnapshot(snapshotDir, timeRangePreset, options2
   }
 }
 function writePeopleRelationshipsSnapshot(snapshotDir, snapshot) {
-  if (!fs30.existsSync(snapshotDir)) fs30.mkdirSync(snapshotDir, { recursive: true });
-  const tmpPath = path27.join(snapshotDir, `${PEOPLE_RELATIONSHIPS_SNAPSHOT_TMP_PREFIX}${process.pid}-${Date.now()}`);
-  fs30.writeFileSync(tmpPath, JSON.stringify(snapshot, null, 2), "utf-8");
-  fs30.renameSync(tmpPath, getPeopleRelationshipsSnapshotPath(snapshotDir, snapshot.timeRange.preset));
+  if (!fs32.existsSync(snapshotDir)) fs32.mkdirSync(snapshotDir, { recursive: true });
+  const tmpPath = path29.join(snapshotDir, `${PEOPLE_RELATIONSHIPS_SNAPSHOT_TMP_PREFIX}${process.pid}-${Date.now()}`);
+  fs32.writeFileSync(tmpPath, JSON.stringify(snapshot, null, 2), "utf-8");
+  fs32.renameSync(tmpPath, getPeopleRelationshipsSnapshotPath(snapshotDir, snapshot.timeRange.preset));
 }
 function cleanupPeopleRelationshipsSnapshotTempFiles(snapshotDir) {
-  if (!fs30.existsSync(snapshotDir)) return;
-  for (const name of fs30.readdirSync(snapshotDir)) {
+  if (!fs32.existsSync(snapshotDir)) return;
+  for (const name of fs32.readdirSync(snapshotDir)) {
     if (!name.startsWith(PEOPLE_RELATIONSHIPS_SNAPSHOT_TMP_PREFIX)) continue;
     try {
-      fs30.rmSync(path27.join(snapshotDir, name), { force: true });
+      fs32.rmSync(path29.join(snapshotDir, name), { force: true });
     } catch (error) {
       appLogger.warn("people-relationships", "failed to remove people relationships snapshot temp file", error);
     }
@@ -17022,7 +17218,7 @@ function createWorker2(workerData, entryUrlInput) {
   return new Worker2(bootstrap, options2);
 }
 function createPeopleRelationshipsWorkerRunner(options2) {
-  return ({ signature, timeRangePreset, signal, onProgress }) => new Promise((resolve2, reject) => {
+  return ({ signature, timeRangePreset, signal, onProgress }) => new Promise((resolve4, reject) => {
     if (signal.aborted) {
       reject(createAbortError2());
       return;
@@ -17053,7 +17249,7 @@ function createPeopleRelationshipsWorkerRunner(options2) {
       if (message.type === "success" && message.snapshot) {
         settled = true;
         signal.removeEventListener("abort", abort);
-        resolve2(message.snapshot);
+        resolve4(message.snapshot);
         void worker.terminate();
         return;
       }
@@ -17506,7 +17702,7 @@ __export(relationships_exports, {
 });
 
 // ../../packages/node-runtime/src/services/global-insight/service.ts
-import fs31 from "fs";
+import fs33 from "fs";
 
 // ../../packages/node-runtime/src/services/global-insight/signature.ts
 function buildAnnualSummarySignature(adapter, range) {
@@ -17533,7 +17729,7 @@ function resolveDefaultAnnualSummaryWorkerEntryUrl(currentModuleUrl = import.met
   return entryExists(sibling) ? sibling : new URL("./global-insight-worker.js", moduleUrl);
 }
 function createAnnualSummaryWorkerRunner(options2) {
-  return ({ signature, range, signal, onProgress }) => new Promise((resolve2, reject) => {
+  return ({ signature, range, signal, onProgress }) => new Promise((resolve4, reject) => {
     if (signal.aborted) {
       reject(new Error("annual summary worker aborted"));
       return;
@@ -17564,7 +17760,7 @@ function createAnnualSummaryWorkerRunner(options2) {
       if (message.type === "success" && message.snapshot) {
         settled = true;
         signal.removeEventListener("abort", abort);
-        resolve2(message.snapshot);
+        resolve4(message.snapshot);
         void worker.terminate();
         return;
       }
@@ -17759,7 +17955,7 @@ var DefaultGlobalInsightService = class {
   }
   getSnapshot(range) {
     const key = toAnnualSummaryRangeKey(range);
-    if (this.snapshots.has(key) && !fs31.existsSync(getAnnualSummarySnapshotPath(this.snapshotDir, range))) {
+    if (this.snapshots.has(key) && !fs33.existsSync(getAnnualSummarySnapshotPath(this.snapshotDir, range))) {
       this.snapshots.delete(key);
     }
     if (!this.snapshots.has(key)) {
@@ -17807,8 +18003,8 @@ __export(global_insight_exports, {
 });
 
 // ../../packages/node-runtime/src/semantic-index/config.ts
-import fs32 from "fs";
-import path28 from "path";
+import fs34 from "fs";
+import path30 from "path";
 var DEFAULT_SEMANTIC_INDEX_MODEL_DOWNLOAD_SOURCE = "huggingface";
 var SEMANTIC_INDEX_CONFIG_VERSION = 1;
 var SEARCH_MAX_RESULTS_DEFAULT = 10;
@@ -17897,9 +18093,9 @@ var SemanticIndexConfigStore = class {
     return this.set({ ...this.get(), enabled });
   }
   get() {
-    if (!fs32.existsSync(this.filePath)) return defaultSemanticIndexConfig();
+    if (!fs34.existsSync(this.filePath)) return defaultSemanticIndexConfig();
     try {
-      const raw = JSON.parse(fs32.readFileSync(this.filePath, "utf-8"));
+      const raw = JSON.parse(fs34.readFileSync(this.filePath, "utf-8"));
       return normalizeConfig(raw);
     } catch {
       return defaultSemanticIndexConfig();
@@ -17907,9 +18103,9 @@ var SemanticIndexConfigStore = class {
   }
   set(config) {
     const normalized = normalizeConfig(config);
-    const dir = path28.dirname(this.filePath);
-    if (!fs32.existsSync(dir)) fs32.mkdirSync(dir, { recursive: true });
-    fs32.writeFileSync(this.filePath, JSON.stringify(normalized, null, 2), "utf-8");
+    const dir = path30.dirname(this.filePath);
+    if (!fs34.existsSync(dir)) fs34.mkdirSync(dir, { recursive: true });
+    fs34.writeFileSync(this.filePath, JSON.stringify(normalized, null, 2), "utf-8");
     return normalized;
   }
   resolveModelId() {
@@ -17918,7 +18114,7 @@ var SemanticIndexConfigStore = class {
 };
 
 // ../../packages/node-runtime/src/semantic-index/service.ts
-import path29 from "path";
+import path31 from "path";
 
 // ../../packages/node-runtime/src/semantic-index/chunker-config.ts
 import { createHash as createHash2 } from "crypto";
@@ -18239,8 +18435,8 @@ function createEmbedder(config, deps = {}) {
     if (!config.api || !config.api.baseUrl || !config.api.model) {
       throw new Error("semantic index API config incomplete: baseUrl and model are required");
     }
-    const resolve2 = deps.resolveApiKey ?? resolveApiKey;
-    const apiKey = resolve2("", config.api.authProfile);
+    const resolve4 = deps.resolveApiKey ?? resolveApiKey;
+    const apiKey = resolve4("", config.api.authProfile);
     return new OpenAICompatibleEmbeddingProvider(
       { baseUrl: config.api.baseUrl, apiKey, model: config.api.model },
       { fetchFn: deps.fetchFn }
@@ -18277,8 +18473,8 @@ function extensionSuffix(platform2) {
   return "so";
 }
 function platformPackageName(platform2, arch2) {
-  const os2 = platform2 === "win32" ? "windows" : platform2;
-  return `${BASE_PACKAGE_NAME}-${os2}-${arch2}`;
+  const os3 = platform2 === "win32" ? "windows" : platform2;
+  return `${BASE_PACKAGE_NAME}-${os3}-${arch2}`;
 }
 function getLoadablePath() {
   if (!validPlatform(platform, arch)) {
@@ -18777,7 +18973,7 @@ var SemanticIndexJobQueue = class {
   /** 等待队列清空（含当前任务） */
   whenIdle() {
     if (!this.processing && this.pending.length === 0) return Promise.resolve();
-    return new Promise((resolve2) => this.idleResolvers.push(resolve2));
+    return new Promise((resolve4) => this.idleResolvers.push(resolve4));
   }
   removePending(dbPathHash) {
     this.pending = this.pending.filter((j) => j.dbPathHash !== dbPathHash);
@@ -18799,7 +18995,7 @@ var SemanticIndexJobQueue = class {
     this.processing = false;
     const resolvers = this.idleResolvers;
     this.idleResolvers = [];
-    for (const resolve2 of resolvers) resolve2();
+    for (const resolve4 of resolvers) resolve4();
   }
 };
 
@@ -19449,16 +19645,16 @@ function resolveSearchToolEvidenceTokens(maxResultTokens) {
   return maxResultTokens && maxResultTokens > 0 ? Math.min(SEARCH_TOOL_EVIDENCE_TOKENS, maxResultTokens) : SEARCH_TOOL_EVIDENCE_TOKENS;
 }
 function sessionIdFromDbPath(dbPath) {
-  return path29.basename(dbPath, ".db");
+  return path31.basename(dbPath, ".db");
 }
 var SEMANTIC_INDEX_DB_FILE = "embedding_index.db";
 var SEMANTIC_INDEX_CONFIG_FILE = "semantic-index-config.json";
 function createSemanticIndexService(params) {
   const { pathProvider } = params;
   return new SemanticIndexService({
-    vectorDbPath: path29.join(pathProvider.getVectorDir(), SEMANTIC_INDEX_DB_FILE),
-    configPath: path29.join(pathProvider.getAiDataDir(), SEMANTIC_INDEX_CONFIG_FILE),
-    modelsCacheDir: path29.join(pathProvider.getAiDataDir(), "models", "semantic-index"),
+    vectorDbPath: path31.join(pathProvider.getVectorDir(), SEMANTIC_INDEX_DB_FILE),
+    configPath: path31.join(pathProvider.getAiDataDir(), SEMANTIC_INDEX_CONFIG_FILE),
+    modelsCacheDir: path31.join(pathProvider.getAiDataDir(), "models", "semantic-index"),
     modelDownloadProxyUrl: params.modelDownloadProxyUrl,
     sessionAdapter: params.sessionAdapter,
     nativeBinding: params.nativeBinding,
@@ -20008,8 +20204,8 @@ ${text}`;
 };
 
 // ../../packages/node-runtime/src/services/merge-cache.ts
-import * as fs33 from "fs";
-import * as path30 from "path";
+import * as fs35 from "fs";
+import * as path32 from "path";
 import * as crypto from "crypto";
 var MergeSessionCache = class {
   cache = /* @__PURE__ */ new Map();
@@ -20018,15 +20214,15 @@ var MergeSessionCache = class {
   constructor(pathProvider, options2) {
     this.tempDir = pathProvider.getTempDir();
     this.nativeBinding = options2?.nativeBinding;
-    if (!fs33.existsSync(this.tempDir)) {
-      fs33.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 path30.join(this.tempDir, `merge_${safeName}_${ts}_${rand}.db`);
+    return path32.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) {
@@ -20037,7 +20233,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 || !fs33.existsSync(entry.tempDbPath)) return null;
+    if (!entry || !fs35.existsSync(entry.tempDbPath)) return null;
     const adapter = openBetterSqliteDatabase(entry.tempDbPath, {
       readonly: true,
       nativeBinding: this.nativeBinding
@@ -20082,20 +20278,44 @@ var MergeSessionCache = class {
 };
 
 // ../../packages/node-runtime/src/services/push-importer.ts
-import * as fs34 from "fs";
+import * as fs36 from "fs";
 var SYSTEM_SENDER_ID = "SYSTEM";
 var SYSTEM_MEMBER_NAME = "\u7CFB\u7EDF\u6D88\u606F";
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateOptionalString(value, field) {
+  return value !== void 0 && typeof value !== "string" ? `${field} must be a string` : null;
+}
 function validatePayload(payload, isNew) {
+  if (!isRecord3(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 (!isRecord3(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))
+      return "chatlab.exportedAt must be a number";
+    const generatorError = validateOptionalString(payload.chatlab.generator, "chatlab.generator");
+    if (generatorError) return generatorError;
+  }
   if (isNew) {
     if (!payload.chatlab) return "chatlab is required for new sessions";
     if (!payload.meta) return "meta is required for new sessions";
-    const m = payload.meta;
-    if (!m.name) return "meta.name is required";
-    if (!m.platform) return "meta.platform is required";
-    if (!m.type) return "meta.type is required";
   }
+  if (payload.meta !== void 0) {
+    if (!isRecord3(payload.meta)) return "meta must be an object";
+    const metaFields = ["name", "platform", "type", "groupId", "groupAvatar", "ownerId"];
+    for (const field of metaFields) {
+      const error = validateOptionalString(payload.meta[field], `meta.${field}`);
+      if (error) return error;
+    }
+    if (isNew && !payload.meta.name) return "meta.name is required";
+    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 && !isRecord3(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'`;
@@ -20106,16 +20326,35 @@ function validatePayload(payload, isNew) {
   if (payload.members !== void 0 && !Array.isArray(payload.members)) return "members must be an array";
   if (payload.members) {
     for (let i = 0; i < payload.members.length; i++) {
-      if (typeof payload.members[i].platformId !== "string" || payload.members[i].platformId.length === 0)
+      const member = payload.members[i];
+      if (!isRecord3(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"]) {
+        const error = validateOptionalString(member[field], `members[${i}].${field}`);
+        if (error) return error;
+      }
+      if (member.roles !== void 0) {
+        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 (!isRecord3(role) || typeof role.id !== "string" || role.id.length === 0)
+            return `members[${i}].roles[${j}].id must be a string`;
+        }
+      }
     }
   }
   for (let i = 0; i < messages.length; i++) {
     const msg = messages[i];
+    if (!isRecord3(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" || msg.timestamp <= 0)
+    if (typeof msg.timestamp !== "number" || !Number.isFinite(msg.timestamp) || msg.timestamp <= 0)
       return `messages[${i}].timestamp must be a positive number`;
-    if (typeof msg.type !== "number") return `messages[${i}].type must be a number`;
+    if (typeof msg.type !== "number" || !Number.isFinite(msg.type)) return `messages[${i}].type must be a number`;
+    for (const field of ["accountName", "groupNickname"]) {
+      const error = validateOptionalString(msg[field], `messages[${i}].${field}`);
+      if (error) return error;
+    }
     if (msg.content !== void 0 && msg.content !== null && typeof msg.content !== "string")
       return `messages[${i}].content must be a string or null`;
     if (msg.platformMessageId !== void 0 && typeof msg.platformMessageId !== "string")
@@ -20136,47 +20375,79 @@ function normalizeSenderAccountName(sender, accountName) {
 function normalizeSenderGroupNickname(sender, groupNickname) {
   return sender === SYSTEM_SENDER_ID ? SYSTEM_MEMBER_NAME : groupNickname;
 }
-function writeMessages(db, messages, existingPmids, existingKeys) {
+function isCountedMember(platformId) {
+  return platformId !== SYSTEM_SENDER_ID;
+}
+function registerPushMessageAndCheckDuplicate(message, dedupState) {
+  return registerMessageAndCheckDuplicate(
+    {
+      platformMessageId: message.platformMessageId,
+      timestamp: message.timestamp,
+      senderPlatformId: message.sender,
+      type: message.type,
+      content: message.content ?? null,
+      replyToMessageId: message.replyToMessageId
+    },
+    dedupState
+  );
+}
+function createExistingMessageDedupState(db) {
+  const existingPmids = /* @__PURE__ */ new Set();
+  const existingKeys = /* @__PURE__ */ new Set();
+  const existingFallbackOnlyKeys = /* @__PURE__ */ new Set();
+  const existingMessages = db.prepare(
+    `SELECT msg.ts, m.platform_id, msg.type, msg.content, msg.reply_to_message_id, msg.platform_message_id
+       FROM message msg
+       JOIN member m ON msg.sender_id = m.id`
+  ).all();
+  for (const message of existingMessages) {
+    if (message.platform_message_id) existingPmids.add(message.platform_message_id);
+    const key = generateFallbackMessageKey({
+      timestamp: message.ts,
+      senderPlatformId: message.platform_id,
+      type: message.type,
+      content: message.content,
+      replyToMessageId: message.reply_to_message_id ?? void 0
+    });
+    existingKeys.add(key);
+    if (!message.platform_message_id) existingFallbackOnlyKeys.add(key);
+  }
+  return createMessageDedupState(existingPmids, existingKeys, existingFallbackOnlyKeys);
+}
+function writeMessages(db, messages, dedupState) {
   const insertMsg = 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 getMemberId = db.prepare("SELECT id FROM member WHERE platform_id = ?");
-  const insertMinimalMember = db.prepare("INSERT OR IGNORE INTO member (platform_id, account_name) VALUES (?, ?)");
+  const insertMinimalMember = db.prepare(
+    "INSERT OR IGNORE INTO member (platform_id, account_name, group_nickname) VALUES (?, ?, ?)"
+  );
   const memberIdCache = /* @__PURE__ */ new Map();
   let writtenCount = 0;
   let duplicateCount = 0;
+  let membersAdded = 0;
   let minWrittenTs = Infinity;
   const ftsEntries = [];
   const sorted = [...messages].sort((a, b) => a.timestamp - b.timestamp);
   db.transaction(() => {
     for (const msg of sorted) {
-      const key = generateMessageKey(msg.timestamp, msg.sender, msg.content ?? null);
-      if (msg.platformMessageId) {
-        if (existingPmids.has(msg.platformMessageId)) {
-          duplicateCount++;
-          continue;
-        }
-        if (existingKeys.has(key)) {
-          duplicateCount++;
-          continue;
-        }
-        existingPmids.add(msg.platformMessageId);
-        existingKeys.add(key);
-      } else {
-        if (existingKeys.has(key)) {
-          duplicateCount++;
-          continue;
-        }
-        existingKeys.add(key);
+      if (registerPushMessageAndCheckDuplicate(msg, dedupState)) {
+        duplicateCount++;
+        continue;
       }
       let memberId = memberIdCache.get(msg.sender);
       if (!memberId) {
-        insertMinimalMember.run(msg.sender, normalizeSenderAccountName(msg.sender, msg.accountName) || null);
+        const insertResult = insertMinimalMember.run(
+          msg.sender,
+          normalizeSenderAccountName(msg.sender, msg.accountName) || null,
+          normalizeSenderGroupNickname(msg.sender, msg.groupNickname) || null
+        );
         const row = getMemberId.get(msg.sender);
         if (row) {
           memberId = row.id;
           memberIdCache.set(msg.sender, memberId);
+          if (isCountedMember(msg.sender)) membersAdded += insertResult.changes;
         }
       }
       if (!memberId) continue;
@@ -20195,7 +20466,7 @@ function writeMessages(db, messages, existingPmids, existingKeys) {
       writtenCount++;
     }
   });
-  return { writtenCount, duplicateCount, minWrittenTs, ftsEntries };
+  return { writtenCount, duplicateCount, membersAdded, minWrittenTs, ftsEntries };
 }
 function fullImport(db, meta, members, messages) {
   db.exec(CHAT_DB_SCHEMA);
@@ -20212,29 +20483,13 @@ function fullImport(db, meta, members, messages) {
     }
   }
   const allMembers = extraMembers.length > 0 ? [...members, ...extraMembers] : members;
-  const pmids = /* @__PURE__ */ new Set();
-  const hashKeys = /* @__PURE__ */ new Set();
+  const dedupState = createMessageDedupState();
   let duplicateCount = 0;
   const dedupedMessages = [];
   for (const msg of messages) {
-    const key = generateMessageKey(msg.timestamp, msg.sender, msg.content ?? null);
-    if (msg.platformMessageId) {
-      if (pmids.has(msg.platformMessageId)) {
-        duplicateCount++;
-        continue;
-      }
-      if (hashKeys.has(key)) {
-        duplicateCount++;
-        continue;
-      }
-      pmids.add(msg.platformMessageId);
-      hashKeys.add(key);
-    } else {
-      if (hashKeys.has(key)) {
-        duplicateCount++;
-        continue;
-      }
-      hashKeys.add(key);
+    if (registerPushMessageAndCheckDuplicate(msg, dedupState)) {
+      duplicateCount++;
+      continue;
     }
     dedupedMessages.push(msg);
   }
@@ -20262,15 +20517,12 @@ function fullImport(db, meta, members, messages) {
     generateSessionIndex(db);
   } catch {
   }
-  return { writtenCount: stats.messageCount, duplicateCount, membersAdded: members.length };
+  return { writtenCount: stats.messageCount, duplicateCount };
 }
-function incrementalImport2(db, payload) {
+function writeIncrementalImport(db, payload) {
   const metaUpdateMode = payload.options?.metaUpdateMode ?? "patch";
   const memberUpdateMode = payload.options?.memberUpdateMode ?? "upsert";
-  const existingPmids = /* @__PURE__ */ new Set();
-  const existingKeys = /* @__PURE__ */ new Set();
-  db.prepare("SELECT platform_message_id FROM message WHERE platform_message_id IS NOT NULL").all().forEach((r) => existingPmids.add(r.platform_message_id));
-  db.prepare(`SELECT msg.ts, m.platform_id, msg.content FROM message msg JOIN member m ON msg.sender_id = m.id`).all().forEach((r) => existingKeys.add(generateMessageKey(r.ts, r.platform_id, r.content)));
+  const dedupState = createExistingMessageDedupState(db);
   let metaUpdated = false;
   let membersAdded = 0;
   let membersUpdated = 0;
@@ -20307,22 +20559,23 @@ function incrementalImport2(db, payload) {
           m.roles ? JSON.stringify(m.roles) : "[]"
         );
         if (!existed) {
-          membersAdded++;
+          if (isCountedMember(m.platformId)) membersAdded++;
           const row = getMemberId.get(m.platformId);
           if (row) existingMemberIds.add(m.platformId);
-        } else {
+        } else if (isCountedMember(m.platformId)) {
           membersUpdated++;
         }
       }
     });
   }
   const preWriteMaxTs = db.prepare("SELECT MAX(ts) as max_ts FROM message").get()?.max_ts ?? 0;
-  const { writtenCount, duplicateCount, minWrittenTs, ftsEntries } = writeMessages(
-    db,
-    payload.messages,
-    existingPmids,
-    existingKeys
-  );
+  const {
+    writtenCount,
+    duplicateCount,
+    membersAdded: autoCreatedMembersAdded,
+    minWrittenTs,
+    ftsEntries
+  } = writeMessages(db, payload.messages, dedupState);
   if (ftsEntries.length > 0) {
     try {
       insertFtsEntries(db, ftsEntries);
@@ -20342,18 +20595,40 @@ function incrementalImport2(db, payload) {
   if (!metaUpdated) {
     db.prepare("UPDATE meta SET imported_at = ?").run(Math.floor(Date.now() / 1e3));
   }
-  return { writtenCount, duplicateCount, metaUpdated, membersAdded, membersUpdated };
+  return {
+    writtenCount,
+    duplicateCount,
+    metaUpdated,
+    membersAdded: membersAdded + autoCreatedMembersAdded,
+    membersUpdated
+  };
+}
+function incrementalImport2(db, payload) {
+  return db.transaction(() => writeIncrementalImport(db, payload));
 }
-var SAFE_SESSION_ID_RE = /^[a-zA-Z0-9_@-][a-zA-Z0-9_@.-]*$/;
 async function pushImport(dbManager, sessionId, payload) {
-  if (!SAFE_SESSION_ID_RE.test(sessionId) || sessionId.includes("..")) {
-    return { ok: false, reason: "invalid_payload", message: "sessionId contains invalid characters" };
-  }
   try {
-    return await withDataDirImportLock(
-      dbManager.getUserDataDir(),
-      () => pushImportUnlocked(dbManager, sessionId, payload)
-    );
+    return await withDataDirImportLock(dbManager.getUserDataDir(), async () => {
+      const outcome = await executePushImportUnlocked(
+        {
+          getDbPath: (id) => dbManager.getDbPath(id),
+          openDatabase: (id, options2) => dbManager.openRawSessionDatabase(id, options2),
+          deleteDatabase: (id) => {
+            dbManager.deleteSessionDatabaseFiles(id);
+          }
+        },
+        sessionId,
+        payload
+      );
+      if (!outcome.ok) return outcome;
+      try {
+        dbManager.raiseCurrentChatDbCompatibilityGate();
+      } catch (error) {
+        if (outcome.result.created) dbManager.deleteSessionDatabaseFiles(sessionId);
+        throw error;
+      }
+      return outcome;
+    });
   } catch (error) {
     if (error instanceof ImportInProgressError) {
       return {
@@ -20365,26 +20640,24 @@ async function pushImport(dbManager, sessionId, payload) {
     throw error;
   }
 }
-async function pushImportUnlocked(dbManager, sessionId, payload) {
-  const dbPath = dbManager.getDbPath(sessionId);
-  const isNew = !fs34.existsSync(dbPath);
+async function executePushImportUnlocked(deps, sessionId, payload) {
+  if (!isValidImportSessionId(sessionId)) {
+    return { ok: false, reason: "invalid_payload", message: "sessionId contains invalid characters" };
+  }
+  const dbPath = deps.getDbPath(sessionId);
+  const isNew = !fs36.existsSync(dbPath);
   const validationError = validatePayload(payload, isNew);
   if (validationError) {
     return { ok: false, reason: "invalid_payload", message: validationError };
   }
   try {
     if (isNew) {
-      const db2 = dbManager.openRawSessionDatabase(sessionId, { create: true });
+      const db2 = deps.openDatabase(sessionId, { create: true });
       try {
-        const { writtenCount, duplicateCount, membersAdded } = fullImport(
-          db2,
-          payload.meta,
-          payload.members ?? [],
-          payload.messages
-        );
+        const { writtenCount, duplicateCount } = fullImport(db2, payload.meta, payload.members ?? [], payload.messages);
         const session = queryStats(db2);
-        dbManager.raiseCurrentChatDbCompatibilityGate();
-        return {
+        const membersAdded = session.memberCount;
+        const outcome = {
           ok: true,
           result: {
             sessionId,
@@ -20394,16 +20667,17 @@ async function pushImportUnlocked(dbManager, sessionId, payload) {
             updates: { metaUpdated: true, membersAdded, membersUpdated: 0 }
           }
         };
+        appLogger.info("push-import", "Push import completed", outcome.result);
+        return outcome;
       } finally {
         db2.close();
       }
     }
-    const db = dbManager.openRawSessionDatabase(sessionId, { readonly: false });
+    const db = deps.openDatabase(sessionId, { readonly: false });
     try {
       const { writtenCount, duplicateCount, metaUpdated, membersAdded, membersUpdated } = incrementalImport2(db, payload);
       const session = queryStats(db);
-      dbManager.raiseCurrentChatDbCompatibilityGate();
-      return {
+      const outcome = {
         ok: true,
         result: {
           sessionId,
@@ -20413,6 +20687,8 @@ async function pushImportUnlocked(dbManager, sessionId, payload) {
           updates: { metaUpdated, membersAdded, membersUpdated }
         }
       };
+      appLogger.info("push-import", "Push import completed", outcome.result);
+      return outcome;
     } finally {
       db.close();
     }
@@ -20420,15 +20696,61 @@ async function pushImportUnlocked(dbManager, sessionId, payload) {
     if (err instanceof DataDirCompatibilityError) throw err;
     if (isNew) {
       try {
-        dbManager.deleteSessionDatabaseFiles(sessionId);
+        deps.deleteDatabase(sessionId);
       } catch {
       }
     }
+    appLogger.error("push-import", "Push import failed", err);
     return { ok: false, reason: "import_failed", message: err instanceof Error ? err.message : String(err) };
   }
 }
 
+// ../../packages/node-runtime/src/services/import-idempotency.ts
+import { createHash as createHash4 } from "crypto";
+var DEFAULT_IMPORT_IDEMPOTENCY_TTL_MS = 60 * 60 * 1e3;
+function hashImportBody(body) {
+  return createHash4("sha256").update(JSON.stringify(body ?? "")).digest("hex");
+}
+var ImportIdempotencyCache = class {
+  constructor(ttlMs = DEFAULT_IMPORT_IDEMPOTENCY_TTL_MS) {
+    this.ttlMs = ttlMs;
+  }
+  ttlMs;
+  entries = /* @__PURE__ */ new Map();
+  start(key, bodyHash, now = Date.now()) {
+    this.prune(now);
+    const entry = this.entries.get(key);
+    if (!entry) {
+      this.entries.set(key, { bodyHash, status: "pending", timestamp: now });
+      return { status: "started" };
+    }
+    if (entry.bodyHash !== bodyHash) return { status: "conflict" };
+    if (entry.status === "pending") return { status: "pending" };
+    return { status: "success", response: entry.response };
+  }
+  success(key, response) {
+    const entry = this.entries.get(key);
+    if (!entry) return;
+    entry.status = "success";
+    entry.response = response;
+  }
+  fail(key) {
+    this.entries.delete(key);
+  }
+  prune(now) {
+    for (const [key, entry] of this.entries) {
+      if (now - entry.timestamp > this.ttlMs) this.entries.delete(key);
+    }
+  }
+};
+
 export {
+  CHATLAB_TEMP_ROOT_ENV,
+  resolveChatLabTempRoot,
+  ensureChatLabTempRoot,
+  getChatLabTempScopeDir,
+  createChatLabTempDir,
+  removeChatLabTempDir,
   writeParseResultToDb,
   detectFormat,
   detectAllFormats,
@@ -20466,8 +20788,10 @@ export {
   streamParseFileInfo,
   analyzeIncrementalImport,
   incrementalImport,
+  isValidImportSessionId,
   resolveAutoImportTarget,
   autoImportFile,
+  analyzeAutoImportFile,
   IMPORT_LOCK_FILENAME,
   IMPORT_IN_PROGRESS_ERROR_KEY,
   ImportInProgressError,
@@ -20548,6 +20872,8 @@ export {
   checkSessionsCanGenerateSummary,
   MAX_CONFIG_COUNT,
   LLMConfigStore,
+  createFileConfigStorage,
+  createAuthProfileLlmConfigStore,
   CustomProviderStore,
   CustomModelStore,
   normalizeAnthropicBaseUrl,
@@ -20636,6 +20962,10 @@ export {
   createSemanticIndexService,
   SemanticIndexService,
   MergeSessionCache,
-  pushImport
+  pushImport,
+  executePushImportUnlocked,
+  DEFAULT_IMPORT_IDEMPOTENCY_TTL_MS,
+  hashImportBody,
+  ImportIdempotencyCache
 };
-//# sourceMappingURL=chunk-T64GA5HP.mjs.map
+//# sourceMappingURL=chunk-5G2INROS.mjs.map