chatlab-cli 0.31.1 → 0.31.2-beta.1

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

@@ -9,7 +9,7 @@ import {
   createEmptyContactsDiagnostics,
   normalizeContactsTimeRangePreset,
   resolveContactsTimeRange
-} from "./chunk-7HBVGVOB.mjs";
+} from "./chunk-ZF67S6RY.mjs";
 import {
   PEOPLE_RELATIONSHIPS_ALGORITHM_VERSION,
   buildPeopleRelationshipsNeighborhoodGraph,
@@ -18,7 +18,7 @@ import {
   computePeopleRelationshipsSnapshot,
   normalizePeopleRelationshipsTimeRangePreset,
   resolvePeopleRelationshipsTimeRange
-} from "./chunk-LJXSUN25.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-DQ45LDKZ.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,7 +3949,7 @@ 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) {
@@ -3975,8 +4046,8 @@ 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;
     });
@@ -4031,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) {
@@ -4093,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",
@@ -4143,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) {
@@ -4161,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;
@@ -4171,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/")) {
@@ -4192,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
@@ -4223,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;
@@ -4277,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?.(
@@ -4405,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 = {
@@ -4479,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";
 }
@@ -4547,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;
@@ -4599,9 +4670,9 @@ async function* parseWeFlow(options2) {
           } catch {
           }
         }
-        resolve2();
+        resolve4();
       });
-      sessionStream.on("error", () => resolve2());
+      sessionStream.on("error", () => resolve4());
     });
   } catch {
   }
@@ -4670,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;
@@ -4727,9 +4798,9 @@ async function* parseWeFlow(options2) {
             } catch {
             }
           }
-          resolve2();
+          resolve4();
         });
-        avatarStream.on("error", () => resolve2());
+        avatarStream.on("error", () => resolve4());
       });
     } catch {
     }
@@ -4737,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")) {
@@ -4746,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 {
   }
@@ -4763,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;
     });
@@ -4836,7 +4907,7 @@ async function* parseWeFlow(options2) {
       if (batchCollector.length > 0) {
         messageBatch.push(...batchCollector);
       }
-      resolve2();
+      resolve4();
     });
     pipeline2.on("error", reject);
   });
@@ -4901,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;
@@ -5050,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;
     });
@@ -5129,7 +5200,7 @@ ${stickerTexts.join("\n")}` : stickerTexts.join("\n");
       if (batchCollector.length > 0) {
         messageBatch.push(...batchCollector);
       }
-      resolve2();
+      resolve4();
     });
     pipeline2.on("error", reject);
   });
@@ -5167,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) {
@@ -5252,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;
@@ -5266,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}`));
@@ -5285,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;
     });
@@ -5299,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);
   });
@@ -5394,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;
@@ -5423,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);
   });
@@ -5522,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);
@@ -5534,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) {
@@ -5713,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
@@ -5834,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";
 }
@@ -5920,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
@@ -6020,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",
@@ -6047,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) {
@@ -6116,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}`);
@@ -6211,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;
@@ -6295,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;
@@ -6313,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),
@@ -6391,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) => {
@@ -6444,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",
@@ -6473,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";
 }
@@ -6653,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);
@@ -6961,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;
@@ -6974,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;
       }
     }
@@ -7023,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";
@@ -7036,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");
@@ -7061,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 {
     }
   }
@@ -7071,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 {
     }
@@ -7091,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 {
   }
 }
@@ -7116,7 +7187,7 @@ Total members: ${totalMembers.toLocaleString()}
 Errors: ${errorCount}
 `;
   try {
-    fs18.appendFileSync(currentLogFile, summary, "utf-8");
+    fs19.appendFileSync(currentLogFile, summary, "utf-8");
   } catch {
   }
 }
@@ -7215,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 = {
@@ -7228,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 {
       }
     }
@@ -7249,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;
@@ -7261,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";
@@ -7302,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 {
       }
     }
@@ -7322,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 };
@@ -7424,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) {
@@ -7456,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);
@@ -7959,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,
@@ -8048,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;
@@ -8693,8 +8764,8 @@ async function analyzeAutoImportFile(filePath, deps, options2 = {}) {
 }
 
 // ../../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";
@@ -8708,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;
     }
@@ -8731,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 {
@@ -8746,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);
   }
@@ -8755,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;
@@ -8786,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 {
@@ -8807,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;
@@ -8927,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) {
@@ -8945,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;
@@ -9075,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(
         {
@@ -9107,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 {
@@ -9119,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);
@@ -9180,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);
@@ -9231,7 +9302,7 @@ var ArchiveImportSourceManager = class {
   }
   removePath(targetPath) {
     try {
-      fs24.rmSync(targetPath, { recursive: true, force: true });
+      fs25.rmSync(targetPath, { recursive: true, force: true });
     } catch {
     }
   }
@@ -9301,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 {
@@ -9385,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;
@@ -9397,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);
@@ -9528,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 {
@@ -9552,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;
   }
@@ -9571,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) {
@@ -9591,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(`
@@ -9841,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() {
@@ -10420,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);
@@ -10586,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: () => {
@@ -10597,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 {
@@ -10626,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: () => {
@@ -14456,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];
   }
@@ -14971,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)}`;
@@ -15790,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,
@@ -16036,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 {
@@ -16129,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,
@@ -16162,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);
@@ -16430,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;
@@ -16442,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 : {};
@@ -16493,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);
     }
@@ -16518,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);
     }
@@ -16566,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;
@@ -16597,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;
       }
@@ -17026,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);
     }
@@ -17051,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);
     }
@@ -17099,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;
@@ -17130,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;
       }
@@ -17583,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) {
@@ -17610,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;
@@ -17641,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;
       }
@@ -17836,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)) {
@@ -17884,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;
@@ -17974,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();
@@ -17984,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() {
@@ -17995,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";
@@ -18316,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 }
@@ -18354,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)) {
@@ -18854,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);
@@ -18876,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();
   }
 };
 
@@ -19526,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,
@@ -20085,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();
@@ -20095,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) {
@@ -20114,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
@@ -20159,7 +20278,7 @@ 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) {
@@ -20526,7 +20645,7 @@ async function executePushImportUnlocked(deps, sessionId, payload) {
     return { ok: false, reason: "invalid_payload", message: "sessionId contains invalid characters" };
   }
   const dbPath = deps.getDbPath(sessionId);
-  const isNew = !fs34.existsSync(dbPath);
+  const isNew = !fs36.existsSync(dbPath);
   const validationError = validatePayload(payload, isNew);
   if (validationError) {
     return { ok: false, reason: "invalid_payload", message: validationError };
@@ -20626,6 +20745,12 @@ var ImportIdempotencyCache = class {
 };
 
 export {
+  CHATLAB_TEMP_ROOT_ENV,
+  resolveChatLabTempRoot,
+  ensureChatLabTempRoot,
+  getChatLabTempScopeDir,
+  createChatLabTempDir,
+  removeChatLabTempDir,
   writeParseResultToDb,
   detectFormat,
   detectAllFormats,
@@ -20747,6 +20872,8 @@ export {
   checkSessionsCanGenerateSummary,
   MAX_CONFIG_COUNT,
   LLMConfigStore,
+  createFileConfigStorage,
+  createAuthProfileLlmConfigStore,
   CustomProviderStore,
   CustomModelStore,
   normalizeAnthropicBaseUrl,
@@ -20841,4 +20968,4 @@ export {
   hashImportBody,
   ImportIdempotencyCache
 };
-//# sourceMappingURL=chunk-KCPGEILH.mjs.map
+//# sourceMappingURL=chunk-5G2INROS.mjs.map