chatlab-cli 0.31.2-beta.1 → 0.31.2

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

@@ -9,7 +9,7 @@ import {
   createEmptyContactsDiagnostics,
   normalizeContactsTimeRangePreset,
   resolveContactsTimeRange
-} from "./chunk-ZF67S6RY.mjs";
+} from "./chunk-F2NZ7HAY.mjs";
 import {
   PEOPLE_RELATIONSHIPS_ALGORITHM_VERSION,
   buildPeopleRelationshipsNeighborhoodGraph,
@@ -18,7 +18,7 @@ import {
   computePeopleRelationshipsSnapshot,
   normalizePeopleRelationshipsTimeRangePreset,
   resolvePeopleRelationshipsTimeRange
-} from "./chunk-HUKZ2PBC.mjs";
+} from "./chunk-OAXVKNPN.mjs";
 import {
   ANNUAL_SUMMARY_ALGORITHM_VERSION
 } from "./chunk-YAQLYL52.mjs";
@@ -42,9 +42,7 @@ import {
   clearSessionIndex,
   collectPosTagStats,
   deleteAnnualSummarySnapshots,
-  deleteAuthProfile,
   deleteMember,
-  deleteMembers,
   generateIncrementalSessionIndex,
   generateMessageKey,
   generateSessionIndex,
@@ -95,7 +93,7 @@ import {
   updateSessionOwnerId,
   writeAnnualSummarySnapshot,
   writeAuthProfile
-} from "./chunk-XZ5FFDLX.mjs";
+} from "./chunk-IK7GJTGY.mjs";
 import {
   __commonJS,
   __export,
@@ -711,8 +709,8 @@ var require_FilterBase = __commonJS({
     var FilterBase = class _FilterBase extends Transform {
       static stringFilter(string, separator) {
         return (stack) => {
-          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;
+          const path31 = stack.join(separator);
+          return path31.length === string.length && path31 === string || path31.length > string.length && path31.substr(0, string.length) === string && path31.substr(string.length, separator.length) === separator;
         };
       }
       static regExpFilter(regExp, separator) {
@@ -1166,12 +1164,12 @@ var require_Assembler = __commonJS({
         return (this.stack.length >> 1) + (this.done ? 0 : 1);
       }
       get path() {
-        const path33 = [];
+        const path31 = [];
         for (let i = 0; i < this.stack.length; i += 2) {
           const key = this.stack[i + 1];
-          path33.push(key === null ? this.stack[i].length : key);
+          path31.push(key === null ? this.stack[i].length : key);
         }
-        return path33;
+        return path31;
       }
       dropToLevel(level) {
         if (level < this.depth) {
@@ -1453,7 +1451,7 @@ var require_pend = __commonJS({
 var require_fd_slicer = __commonJS({
   "../../packages/node-runtime/node_modules/yauzl/fd-slicer.js"(exports) {
     "use strict";
-    var fs37 = __require("fs");
+    var fs35 = __require("fs");
     var util = __require("util");
     var stream = __require("stream");
     var Readable = stream.Readable;
@@ -1473,7 +1471,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs37.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+        fs35.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
           cb();
           callback(err, bytesRead, buffer2);
         });
@@ -1490,7 +1488,7 @@ var require_fd_slicer = __commonJS({
       self.refCount -= 1;
       if (self.refCount < 0) throw new Error("invalid unref");
       if (self.refCount > 0) return;
-      fs37.close(self.fd, onCloseDone);
+      fs35.close(self.fd, onCloseDone);
       function onCloseDone(err) {
         if (err) {
           self.emit("error", err);
@@ -1522,7 +1520,7 @@ var require_fd_slicer = __commonJS({
       }
       self.context.pend.go(function(cb) {
         var buffer = Buffer.allocUnsafe(toRead);
-        fs37.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
+        fs35.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
           if (err) {
             self.destroy(err);
           } else if (bytesRead === 0) {
@@ -1884,7 +1882,7 @@ var require_crc32 = __commonJS({
 var require_yauzl = __commonJS({
   "../../packages/node-runtime/node_modules/yauzl/index.js"(exports) {
     "use strict";
-    var fs37 = __require("fs");
+    var fs35 = __require("fs");
     var zlib = __require("zlib");
     var fd_slicer = require_fd_slicer();
     var util = __require("util");
@@ -1909,39 +1907,39 @@ var require_yauzl = __commonJS({
     exports.Entry = Entry;
     exports.LocalFileHeader = LocalFileHeader;
     exports.RandomAccessReader = RandomAccessReader;
-    function openPromise2(path33, options2) {
-      return new Promise((resolve4, reject) => {
-        open(path33, { ...options2, lazyEntries: true }, function(err, zipfile) {
+    function openPromise2(path31, options2) {
+      return new Promise((resolve2, reject) => {
+        open(path31, { ...options2, lazyEntries: true }, function(err, zipfile) {
           if (err) return reject(err);
-          resolve4(zipfile);
+          resolve2(zipfile);
         });
       });
     }
     function fromFdPromise(fd, options2) {
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve2, reject) => {
         fromFd(fd, { ...options2, lazyEntries: true }, function(err, zipfile) {
           if (err) return reject(err);
-          resolve4(zipfile);
+          resolve2(zipfile);
         });
       });
     }
     function fromBufferPromise(buffer, options2) {
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve2, reject) => {
         fromBuffer(buffer, { ...options2, lazyEntries: true }, function(err, zipfile) {
           if (err) return reject(err);
-          resolve4(zipfile);
+          resolve2(zipfile);
         });
       });
     }
     function fromRandomAccessReaderPromise(reader, totalSize, options2) {
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve2, reject) => {
         fromRandomAccessReader(reader, totalSize, { ...options2, lazyEntries: true }, function(err, zipfile) {
           if (err) return reject(err);
-          resolve4(zipfile);
+          resolve2(zipfile);
         });
       });
     }
-    function open(path33, options2, callback) {
+    function open(path31, options2, callback) {
       if (typeof options2 === "function") {
         callback = options2;
         options2 = null;
@@ -1953,10 +1951,10 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs37.open(path33, "r", function(err, fd) {
+      fs35.open(path31, "r", function(err, fd) {
         if (err) return callback(err);
         fromFd(fd, options2, function(err2, zipfile) {
-          if (err2) fs37.close(fd, defaultCallback);
+          if (err2) fs35.close(fd, defaultCallback);
           callback(err2, zipfile);
         });
       });
@@ -1973,7 +1971,7 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs37.fstat(fd, function(err, stats) {
+      fs35.fstat(fd, function(err, stats) {
         if (err) return callback(err);
         var reader = new fd_slicer.FdSlicer(fd);
         fromRandomAccessReader(reader, stats.size, options2, callback);
@@ -2221,15 +2219,15 @@ var require_yauzl = __commonJS({
         if (self.autoClose) self.close();
       }
       function onEntry(entry) {
-        let { resolve: resolve4 } = pendingResolveReject;
+        let { resolve: resolve2 } = pendingResolveReject;
         pendingResolveReject = null;
-        resolve4({ value: entry });
+        resolve2({ value: entry });
       }
       function onEnd() {
-        let { resolve: resolve4 } = pendingResolveReject;
+        let { resolve: resolve2 } = pendingResolveReject;
         pendingResolveReject = null;
         cleanup();
-        resolve4({ done: true });
+        resolve2({ done: true });
       }
       function onError(err) {
         let { reject } = pendingResolveReject;
@@ -2242,9 +2240,9 @@ var require_yauzl = __commonJS({
           return this;
         },
         next() {
-          const promise = new Promise((resolve4, reject) => {
+          const promise = new Promise((resolve2, reject) => {
             if (pendingResolveReject != null) throw new Error("next() called before previous Promise was resolved.");
-            pendingResolveReject = { resolve: resolve4, reject };
+            pendingResolveReject = { resolve: resolve2, reject };
           });
           self.readEntry();
           return promise;
@@ -2433,26 +2431,26 @@ var require_yauzl = __commonJS({
       });
     };
     ZipFile.prototype.openReadStreamPromise = function(entry, options2) {
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve2, reject) => {
         this.openReadStream(entry, options2, function(err, readStream) {
           if (err) return reject(err);
-          resolve4(readStream);
+          resolve2(readStream);
         });
       });
     };
     ZipFile.prototype.openReadStreamLowLevelPromise = function(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize) {
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve2, reject) => {
         this.openReadStream(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize, function(err, readStream) {
           if (err) return reject(err);
-          resolve4(readStream);
+          resolve2(readStream);
         });
       });
     };
     ZipFile.prototype.readLocalFileHeaderPromise = function(entry, options2) {
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve2, reject) => {
         this.readLocalFileHeader(entry, options2, function(err, localFileHeader) {
           if (err) return reject(err);
-          resolve4(localFileHeader);
+          resolve2(localFileHeader);
         });
       });
     };
@@ -2740,73 +2738,6 @@ 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;
@@ -2921,28 +2852,28 @@ function writeParseResultToDb(db, meta, members, messages) {
 }
 
 // ../../packages/parser/src/index.ts
-import * as fs18 from "fs";
-import * as path14 from "path";
+import * as fs17 from "fs";
+import * as path13 from "path";
 
 // ../../packages/parser/src/sniffer.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs from "fs";
+import * as path from "path";
 var HEAD_SIZE = 64 * 1024;
 function readFileHead(filePath, size = HEAD_SIZE) {
-  const fd = fs2.openSync(filePath, "r");
+  const fd = fs.openSync(filePath, "r");
   const buffer = Buffer.alloc(size);
-  const bytesRead = fs2.readSync(fd, buffer, 0, size, 0);
-  fs2.closeSync(fd);
+  const bytesRead = fs.readSync(fd, buffer, 0, size, 0);
+  fs.closeSync(fd);
   return buffer.slice(0, bytesRead).toString("utf-8");
 }
 function getExtension(filePath) {
-  return path2.extname(filePath).toLowerCase();
+  return path.extname(filePath).toLowerCase();
 }
 function matchHeadSignatures(headContent, patterns) {
   return patterns.some((pattern) => pattern.test(headContent));
 }
 function matchFilenameSignatures(filePath, patterns) {
-  const filename = path2.basename(filePath);
+  const filename = path.basename(filePath);
   return patterns.some((pattern) => pattern.test(filename));
 }
 function matchRequiredFields(headContent, fields) {
@@ -3090,18 +3021,18 @@ var import_stream_json = __toESM(require_stream_json(), 1);
 var import_Pick = __toESM(require_Pick(), 1);
 var import_StreamValues = __toESM(require_StreamValues(), 1);
 var import_stream_chain = __toESM(require_stream_chain(), 1);
-import * as fs4 from "fs";
+import * as fs3 from "fs";
 
 // ../../packages/parser/src/utils.ts
-import * as fs3 from "fs";
+import * as fs2 from "fs";
 function getFileSize(filePath) {
-  return fs3.statSync(filePath).size;
+  return fs2.statSync(filePath).size;
 }
 function readFileHeadBytes(filePath, size) {
-  const fd = fs3.openSync(filePath, "r");
+  const fd = fs2.openSync(filePath, "r");
   const buffer = Buffer.alloc(size);
-  const bytesRead = fs3.readSync(fd, buffer, 0, size, 0);
-  fs3.closeSync(fd);
+  const bytesRead = fs2.readSync(fd, buffer, 0, size, 0);
+  fs2.closeSync(fd);
   return buffer.slice(0, bytesRead).toString("utf-8");
 }
 var createProgress = (stage, bytesRead, totalBytes, messagesProcessed, message) => {
@@ -3131,7 +3062,7 @@ function isValidYear(timestampSeconds) {
 }
 
 // ../../packages/parser/src/formats/chatlab.ts
-import * as path3 from "path";
+import * as path2 from "path";
 
 // ../../packages/parser/src/native/loader.ts
 import { createRequire } from "module";
@@ -3214,7 +3145,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((resolve4) => setImmediate(resolve4));
+    await new Promise((resolve2) => setImmediate(resolve2));
   }
   const doneProgress = createProgress("done", totalBytes, totalBytes, messagesProcessed, "");
   yield { type: "progress", data: doneProgress };
@@ -3312,7 +3243,7 @@ var { pick } = import_Pick.default;
 var { streamValues } = import_StreamValues.default;
 var { chain } = import_stream_chain.default;
 function extractNameFromFilePath(filePath) {
-  const basename13 = path3.basename(filePath);
+  const basename13 = path2.basename(filePath);
   const name = basename13.replace(/\.json$/i, "");
   return name || "\u672A\u77E5\u7FA4\u804A";
 }
@@ -3386,8 +3317,8 @@ async function* parseChatLab(options2) {
   const members = [];
   const memberMapFromMessages = /* @__PURE__ */ new Map();
   const messageBatch = [];
-  await new Promise((resolve4, reject) => {
-    const readStream = fs4.createReadStream(filePath, { encoding: "utf-8" });
+  await new Promise((resolve2, reject) => {
+    const readStream = fs3.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
@@ -3441,7 +3372,7 @@ async function* parseChatLab(options2) {
       if (batchCollector.length > 0) {
         messageBatch.push(...batchCollector);
       }
-      resolve4();
+      resolve2();
     });
     pipeline2.on("error", reject);
   });
@@ -3479,11 +3410,11 @@ var module_ = {
 var chatlab_default = module_;
 
 // ../../packages/parser/src/formats/chatlab-jsonl.ts
-import * as fs5 from "fs";
+import * as fs4 from "fs";
 import * as readline from "readline";
-import * as path4 from "path";
+import * as path3 from "path";
 function extractNameFromFilePath2(filePath) {
-  const basename13 = path4.basename(filePath);
+  const basename13 = path3.basename(filePath);
   const name = basename13.replace(/\.jsonl$/i, "");
   return name || "\u672A\u77E5\u7FA4\u804A";
 }
@@ -3524,7 +3455,7 @@ async function* parseChatLabJsonl(options2) {
   const messageBatch = [];
   let meta = null;
   let headerParsed = false;
-  const fileStream = fs5.createReadStream(filePath, { encoding: "utf-8" });
+  const fileStream = fs4.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline.createInterface({
     input: fileStream,
     crlfDelay: Infinity
@@ -3649,30 +3580,28 @@ var import_stream_json3 = __toESM(require_stream_json(), 1);
 var import_Pick3 = __toESM(require_Pick(), 1);
 var import_StreamValues3 = __toESM(require_StreamValues(), 1);
 var import_stream_chain3 = __toESM(require_stream_chain(), 1);
-import * as fs7 from "fs";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as path5 from "path";
 
 // ../../packages/parser/src/formats/shuakami-qq-preprocessor.ts
 var import_stream_json2 = __toESM(require_stream_json(), 1);
 var import_Pick2 = __toESM(require_Pick(), 1);
 var import_StreamValues2 = __toESM(require_StreamValues(), 1);
 var import_stream_chain2 = __toESM(require_stream_chain(), 1);
-import * as fs6 from "fs";
-import * as path5 from "path";
-import * as os2 from "os";
+import * as fs5 from "fs";
+import * as path4 from "path";
+import * as os from "os";
 var { parser: parser3 } = import_stream_json2.default;
 var { pick: pick2 } = import_Pick2.default;
 var { streamValues: streamValues2 } = import_StreamValues2.default;
 var { chain: chain2 } = import_stream_chain2.default;
 var PREPROCESS_THRESHOLD = 50 * 1024 * 1024;
 function getTempDir() {
-  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");
+  return path4.join(os.tmpdir(), "chatlab");
 }
 function ensureDir(dir) {
-  if (!fs6.existsSync(dir)) {
-    fs6.mkdirSync(dir, { recursive: true, mode: 448 });
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
   }
 }
 function extractJsonObject(content, key) {
@@ -3714,12 +3643,12 @@ function extractJsonObject(content, key) {
 }
 function readAvatarsFromFile(filePath) {
   try {
-    const stats = fs6.statSync(filePath);
+    const stats = fs5.statSync(filePath);
     const tailSize = Math.min(stats.size, 5e6);
-    const fd = fs6.openSync(filePath, "r");
+    const fd = fs5.openSync(filePath, "r");
     const buffer = Buffer.alloc(tailSize);
-    fs6.readSync(fd, buffer, 0, tailSize, stats.size - tailSize);
-    fs6.closeSync(fd);
+    fs5.readSync(fd, buffer, 0, tailSize, stats.size - tailSize);
+    fs5.closeSync(fd);
     const tailContent = buffer.toString("utf-8");
     return extractJsonObject(tailContent, "avatars");
   } catch {
@@ -3778,15 +3707,15 @@ async function preprocessQQJson(inputPath, onProgress) {
   let messagesProcessed = 0;
   const tempDir = getTempDir();
   ensureDir(tempDir);
-  const outputFilename = `slim_${Date.now()}_${path5.basename(inputPath)}`;
-  const outputPath = path5.join(tempDir, outputFilename);
+  const outputFilename = `slim_${Date.now()}_${path4.basename(inputPath)}`;
+  const outputPath = path4.join(tempDir, outputFilename);
   onProgress?.(createProgress("parsing", 0, totalBytes, 0, ""));
   const avatarsStr = readAvatarsFromFile(inputPath);
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve2, reject) => {
     const headChunks = [];
     let headSize = 0;
     const maxHeadSize = 1e5;
-    const headStream = fs6.createReadStream(inputPath, { encoding: "utf-8" });
+    const headStream = fs5.createReadStream(inputPath, { encoding: "utf-8" });
     let chatInfo = { name: "\u672A\u77E5\u7FA4\u804A", type: "group" };
     let metadata;
     let statistics;
@@ -3823,8 +3752,8 @@ async function preprocessQQJson(inputPath, onProgress) {
       } catch {
       }
       onProgress?.(createProgress("parsing", 0, totalBytes, 0, ""));
-      const readStream = fs6.createReadStream(inputPath, { encoding: "utf-8" });
-      const writeStream = fs6.createWriteStream(outputPath, { encoding: "utf-8" });
+      const readStream = fs5.createReadStream(inputPath, { encoding: "utf-8" });
+      const writeStream = fs5.createWriteStream(outputPath, { encoding: "utf-8" });
       readStream.on("data", (chunk) => {
         bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
       });
@@ -3864,13 +3793,13 @@ async function preprocessQQJson(inputPath, onProgress) {
         writeStream.end();
         writeStream.on("finish", () => {
           onProgress?.(createProgress("done", totalBytes, totalBytes, messagesProcessed, ""));
-          resolve4(outputPath);
+          resolve2(outputPath);
         });
       });
       pipeline2.on("error", (err) => {
         writeStream.destroy();
-        if (fs6.existsSync(outputPath)) {
-          fs6.unlinkSync(outputPath);
+        if (fs5.existsSync(outputPath)) {
+          fs5.unlinkSync(outputPath);
         }
         onProgress?.(createProgress("error", bytesRead, totalBytes, messagesProcessed, err.message));
         reject(err);
@@ -3881,8 +3810,8 @@ async function preprocessQQJson(inputPath, onProgress) {
 }
 function cleanupTempFile(filePath) {
   try {
-    if (fs6.existsSync(filePath) && path5.dirname(path5.resolve(filePath)) === path5.resolve(getTempDir())) {
-      fs6.unlinkSync(filePath);
+    if (fs5.existsSync(filePath) && filePath.includes(getTempDir())) {
+      fs5.unlinkSync(filePath);
     }
   } catch {
   }
@@ -3949,7 +3878,7 @@ function extractJsonObject2(content, key) {
   return null;
 }
 function extractNameFromFilePath3(filePath) {
-  const basename13 = path6.basename(filePath);
+  const basename13 = path5.basename(filePath);
   return basename13.replace(/\.json$/i, "") || "\u672A\u77E5\u7FA4\u804A";
 }
 function isPlaceholderSenderId(id) {
@@ -4046,8 +3975,8 @@ async function* parseV4(options2) {
   yield { type: "meta", data: meta };
   const memberMap = /* @__PURE__ */ new Map();
   const messageBatch = [];
-  await new Promise((resolve4, reject) => {
-    const readStream = fs7.createReadStream(filePath, { encoding: "utf-8" });
+  await new Promise((resolve2, reject) => {
+    const readStream = fs6.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
@@ -4102,17 +4031,17 @@ async function* parseV4(options2) {
         onProgress?.(progress);
       }
     });
-    pipeline2.on("end", resolve4);
+    pipeline2.on("end", resolve2);
     pipeline2.on("error", reject);
   });
   const avatarsMap = /* @__PURE__ */ new Map();
   try {
-    const stats = fs7.statSync(filePath);
+    const stats = fs6.statSync(filePath);
     const tailSize = Math.min(stats.size, 5e6);
-    const fd = fs7.openSync(filePath, "r");
+    const fd = fs6.openSync(filePath, "r");
     const buffer = Buffer.alloc(tailSize);
-    fs7.readSync(fd, buffer, 0, tailSize, stats.size - tailSize);
-    fs7.closeSync(fd);
+    fs6.readSync(fd, buffer, 0, tailSize, stats.size - tailSize);
+    fs6.closeSync(fd);
     const tailContent = buffer.toString("utf-8");
     const avatarsStr = extractJsonObject2(tailContent, "avatars");
     if (avatarsStr) {
@@ -4164,8 +4093,8 @@ var module_3 = {
 var shuakami_qq_exporter_default = module_3;
 
 // ../../packages/parser/src/formats/shuakami-qq-exporter-chunked.ts
-import * as fs8 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path6 from "path";
 import * as readline2 from "readline";
 var feature4 = {
   id: "shuakami-qq-exporter-chunked",
@@ -4214,7 +4143,7 @@ function convertMessageType2(msgType, content, isRecalled) {
   return 0 /* TEXT */;
 }
 function readManifest(manifestPath) {
-  const content = fs8.readFileSync(manifestPath, "utf-8");
+  const content = fs7.readFileSync(manifestPath, "utf-8");
   return JSON.parse(content);
 }
 function getChunkRelativePath(chunk) {
@@ -4232,9 +4161,9 @@ function calculateTotalBytes(manifest, baseDir) {
   let total = 0;
   for (const chunk of manifest.chunked.chunks) {
     const relativePath = getChunkRelativePath(chunk);
-    const chunkPath = path7.join(baseDir, relativePath);
-    if (fs8.existsSync(chunkPath)) {
-      total += fs8.statSync(chunkPath).size;
+    const chunkPath = path6.join(baseDir, relativePath);
+    if (fs7.existsSync(chunkPath)) {
+      total += fs7.statSync(chunkPath).size;
     }
   }
   return total;
@@ -4242,10 +4171,10 @@ function calculateTotalBytes(manifest, baseDir) {
 function readAvatars(baseDir, avatarsInfo) {
   const avatarsMap = /* @__PURE__ */ new Map();
   if (!avatarsInfo?.file) return avatarsMap;
-  const avatarsPath = path7.join(baseDir, avatarsInfo.file);
-  if (!fs8.existsSync(avatarsPath)) return avatarsMap;
+  const avatarsPath = path6.join(baseDir, avatarsInfo.file);
+  if (!fs7.existsSync(avatarsPath)) return avatarsMap;
   try {
-    const content = fs8.readFileSync(avatarsPath, "utf-8");
+    const content = fs7.readFileSync(avatarsPath, "utf-8");
     const avatars = JSON.parse(content);
     for (const [uin, avatar] of Object.entries(avatars)) {
       if (avatar && typeof avatar === "string" && avatar.startsWith("data:image/")) {
@@ -4263,7 +4192,7 @@ async function* readJsonlFile(filePath, onParseError) {
   let parseErrorCount = 0;
   const MAX_PARSE_ERRORS_TO_LOG = 10;
   try {
-    fileStream = fs8.createReadStream(filePath, { encoding: "utf-8" });
+    fileStream = fs7.createReadStream(filePath, { encoding: "utf-8" });
     rl = readline2.createInterface({
       input: fileStream,
       crlfDelay: Infinity
@@ -4294,7 +4223,7 @@ async function* readJsonlFile(filePath, onParseError) {
 async function* parseChunkedJsonl(options2) {
   const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const manifestPath = filePath;
-  const baseDir = path7.dirname(manifestPath);
+  const baseDir = path6.dirname(manifestPath);
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 manifest: ${manifestPath}`);
   onLog?.("info", `\u57FA\u7840\u76EE\u5F55: ${baseDir}`);
   let manifest;
@@ -4348,13 +4277,13 @@ async function* parseChunkedJsonl(options2) {
   for (let chunkIndex = 0; chunkIndex < manifest.chunked.chunks.length; chunkIndex++) {
     const chunkInfo = manifest.chunked.chunks[chunkIndex];
     const relativePath = getChunkRelativePath(chunkInfo);
-    const chunkPath = path7.join(baseDir, relativePath);
+    const chunkPath = path6.join(baseDir, relativePath);
     const chunkMessageCount = getChunkMessageCount(chunkInfo);
-    if (!fs8.existsSync(chunkPath)) {
+    if (!fs7.existsSync(chunkPath)) {
       onLog?.("error", `\u5206\u5757\u6587\u4EF6\u4E0D\u5B58\u5728: ${chunkPath}`);
       continue;
     }
-    const chunkSize = fs8.statSync(chunkPath).size;
+    const chunkSize = fs7.statSync(chunkPath).size;
     let chunkMessagesRead = 0;
     let chunkParseErrors = 0;
     onLog?.(
@@ -4476,8 +4405,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 fs9 from "fs";
-import * as path8 from "path";
+import * as fs8 from "fs";
+import * as path7 from "path";
 
 // ../../packages/parser/src/native/weflow-native.ts
 var weflowAdapter = {
@@ -4550,7 +4479,7 @@ var { pick: pick4 } = import_Pick4.default;
 var { streamValues: streamValues4 } = import_StreamValues4.default;
 var { chain: chain4 } = import_stream_chain4.default;
 function extractNameFromFilePath4(filePath) {
-  const basename13 = path8.basename(filePath);
+  const basename13 = path7.basename(filePath);
   const name = basename13.replace(/\.json$/i, "");
   return name || "\u672A\u77E5\u804A\u5929";
 }
@@ -4618,8 +4547,8 @@ async function* parseWeFlow(options2) {
   const headContent = readFileHeadBytes(filePath, 5e3);
   let session = null;
   try {
-    await new Promise((resolve4) => {
-      const sessionStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
+    await new Promise((resolve2) => {
+      const sessionStream = fs8.createReadStream(filePath, { encoding: "utf-8" });
       let sessionContent = "";
       let inSession = false;
       let braceDepth = 0;
@@ -4670,9 +4599,9 @@ async function* parseWeFlow(options2) {
           } catch {
           }
         }
-        resolve4();
+        resolve2();
       });
-      sessionStream.on("error", () => resolve4());
+      sessionStream.on("error", () => resolve2());
     });
   } catch {
   }
@@ -4741,8 +4670,8 @@ async function* parseWeFlow(options2) {
   }
   if (avatarsMap.size === 0) {
     try {
-      await new Promise((resolve4) => {
-        const avatarStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
+      await new Promise((resolve2) => {
+        const avatarStream = fs8.createReadStream(filePath, { encoding: "utf-8" });
         let avatarsContent = "";
         let inAvatars = false;
         let braceDepth = 0;
@@ -4798,9 +4727,9 @@ async function* parseWeFlow(options2) {
             } catch {
             }
           }
-          resolve4();
+          resolve2();
         });
-        avatarStream.on("error", () => resolve4());
+        avatarStream.on("error", () => resolve2());
       });
     } catch {
     }
@@ -4808,8 +4737,8 @@ async function* parseWeFlow(options2) {
   const groupAvatar = sessionData?.avatar || (groupId ? avatarsMap.get(groupId) : void 0);
   let ownerId;
   try {
-    await new Promise((resolve4) => {
-      const scanStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
+    await new Promise((resolve2) => {
+      const scanStream = fs8.createReadStream(filePath, { encoding: "utf-8" });
       const scanPipeline = chain4([scanStream, parser5(), pick4({ filter: /^messages\.\d+$/ }), streamValues4()]);
       scanPipeline.on("data", ({ value }) => {
         if (value.isSend === 1 && value.senderUsername && !value.senderUsername.endsWith("@chatroom")) {
@@ -4817,9 +4746,9 @@ async function* parseWeFlow(options2) {
           scanStream.destroy();
         }
       });
-      scanStream.on("close", () => resolve4());
-      scanPipeline.on("end", () => resolve4());
-      scanPipeline.on("error", () => resolve4());
+      scanStream.on("close", () => resolve2());
+      scanPipeline.on("end", () => resolve2());
+      scanPipeline.on("error", () => resolve2());
     });
   } catch {
   }
@@ -4834,8 +4763,8 @@ async function* parseWeFlow(options2) {
   yield { type: "meta", data: meta };
   const memberMap = /* @__PURE__ */ new Map();
   const messageBatch = [];
-  await new Promise((resolve4, reject) => {
-    const readStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
+  await new Promise((resolve2, reject) => {
+    const readStream = fs8.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
@@ -4907,7 +4836,7 @@ async function* parseWeFlow(options2) {
       if (batchCollector.length > 0) {
         messageBatch.push(...batchCollector);
       }
-      resolve4();
+      resolve2();
     });
     pipeline2.on("error", reject);
   });
@@ -4972,7 +4901,7 @@ var import_stream_json5 = __toESM(require_stream_json(), 1);
 var import_Pick5 = __toESM(require_Pick(), 1);
 var import_StreamValues5 = __toESM(require_StreamValues(), 1);
 var import_stream_chain5 = __toESM(require_stream_chain(), 1);
-import * as fs10 from "fs";
+import * as fs9 from "fs";
 var { parser: parser6 } = import_stream_json5.default;
 var { pick: pick5 } = import_Pick5.default;
 var { streamValues: streamValues5 } = import_StreamValues5.default;
@@ -5121,8 +5050,8 @@ async function* parseDiscordExporter(options2) {
   onLog?.("info", `\u7FA4\u804A\u540D\u79F0: ${chatName}`);
   const memberMap = /* @__PURE__ */ new Map();
   const messageBatch = [];
-  await new Promise((resolve4, reject) => {
-    const readStream = fs10.createReadStream(filePath, { encoding: "utf-8" });
+  await new Promise((resolve2, reject) => {
+    const readStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
@@ -5200,7 +5129,7 @@ ${stickerTexts.join("\n")}` : stickerTexts.join("\n");
       if (batchCollector.length > 0) {
         messageBatch.push(...batchCollector);
       }
-      resolve4();
+      resolve2();
     });
     pipeline2.on("error", reject);
   });
@@ -5238,7 +5167,7 @@ var import_stream_chain6 = __toESM(require_stream_chain(), 1);
 var import_stream_json6 = __toESM(require_stream_json(), 1);
 var import_Pick6 = __toESM(require_Pick(), 1);
 var import_StreamValues6 = __toESM(require_StreamValues(), 1);
-import * as fs11 from "fs";
+import * as fs10 from "fs";
 
 // ../../packages/parser/src/formats/utils/telegram-utils.ts
 function mapChatType(telegramType) {
@@ -5323,8 +5252,8 @@ var feature8 = {
 };
 async function scanChats(filePath) {
   const chats = [];
-  return new Promise((resolve4, reject) => {
-    const readStream = fs11.createReadStream(filePath, { encoding: "utf-8" });
+  return new Promise((resolve2, reject) => {
+    const readStream = fs10.createReadStream(filePath, { encoding: "utf-8" });
     const pipeline2 = chain6([readStream, parser7(), pick6({ filter: /^chats\.list\.\d+$/ }), streamValues6()]);
     pipeline2.on("data", ({ value }) => {
       const chat = value;
@@ -5337,7 +5266,7 @@ async function scanChats(filePath) {
       });
     });
     pipeline2.on("end", () => {
-      resolve4(chats);
+      resolve2(chats);
     });
     pipeline2.on("error", (err) => {
       reject(new Error(`\u626B\u63CF Telegram \u6587\u4EF6\u5931\u8D25: ${err.message}`));
@@ -5356,8 +5285,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((resolve4, reject) => {
-    const readStream = fs11.createReadStream(filePath, { encoding: "utf-8" });
+  const chatData = await new Promise((resolve2, reject) => {
+    const readStream = fs10.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
@@ -5370,10 +5299,10 @@ async function* parseTelegram(options2) {
     let found = false;
     pipeline2.on("data", ({ value }) => {
       found = true;
-      resolve4(value);
+      resolve2(value);
     });
     pipeline2.on("end", () => {
-      if (!found) resolve4(null);
+      if (!found) resolve2(null);
     });
     pipeline2.on("error", reject);
   });
@@ -5465,7 +5394,7 @@ var telegram_native_default = module_8;
 var import_stream_chain7 = __toESM(require_stream_chain(), 1);
 var import_stream_json7 = __toESM(require_stream_json(), 1);
 var import_StreamValues7 = __toESM(require_StreamValues(), 1);
-import * as fs12 from "fs";
+import * as fs11 from "fs";
 var { chain: chain7 } = import_stream_chain7.default;
 var { parser: parser8 } = import_stream_json7.default;
 var { streamValues: streamValues7 } = import_StreamValues7.default;
@@ -5494,18 +5423,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((resolve4, reject) => {
-    const readStream = fs12.createReadStream(filePath, { encoding: "utf-8" });
+  const chatData = await new Promise((resolve2, reject) => {
+    const readStream = fs11.createReadStream(filePath, { encoding: "utf-8" });
     const pipeline2 = chain7([readStream, parser8(), streamValues7()]);
     let found = false;
     pipeline2.on("data", ({ value }) => {
       if (!found) {
         found = true;
-        resolve4(value);
+        resolve2(value);
       }
     });
     pipeline2.on("end", () => {
-      if (!found) resolve4(null);
+      if (!found) resolve2(null);
     });
     pipeline2.on("error", reject);
   });
@@ -5593,11 +5522,11 @@ var module_9 = {
 var telegram_native_single_default = module_9;
 
 // ../../packages/parser/src/formats/whatsapp-native-txt.ts
-import * as fs13 from "fs";
-import * as path9 from "path";
+import * as fs12 from "fs";
+import * as path8 from "path";
 import * as readline3 from "readline";
 function extractNameFromFilePath5(filePath) {
-  const basename13 = path9.basename(filePath);
+  const basename13 = path8.basename(filePath);
   const matchZhCn = basename13.match(/^与(.+?)的\s*WhatsApp\s*聊天\.txt$/i);
   if (matchZhCn) return matchZhCn[1].trim();
   const matchZhTw = basename13.match(/^與(.+?)的\s*WhatsApp\s*對話\.txt$/i);
@@ -5605,7 +5534,7 @@ function extractNameFromFilePath5(filePath) {
   return basename13.replace(/\.txt$/i, "") || "\u672A\u77E5\u804A\u5929";
 }
 function shouldInferPrivateChatName(filePath, fallbackName) {
-  const basename13 = path9.basename(filePath);
+  const basename13 = path8.basename(filePath);
   return /^_chat\.txt$/i.test(basename13) || /^whatsapp(?:[-_\s].*)?$/i.test(fallbackName);
 }
 function inferPrivateChatName(memberMap, fallbackName) {
@@ -5784,7 +5713,7 @@ async function* parseWhatsApp(options2) {
       messagesProcessed++;
     }
   };
-  const fileStream = fs13.createReadStream(filePath, { encoding: "utf-8" });
+  const fileStream = fs12.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline3.createInterface({
     input: fileStream,
     crlfDelay: Infinity
@@ -5905,11 +5834,11 @@ var module_10 = {
 var whatsapp_native_txt_default = module_10;
 
 // ../../packages/parser/src/formats/qq-native-txt.ts
-import * as fs14 from "fs";
-import * as path10 from "path";
+import * as fs13 from "fs";
+import * as path9 from "path";
 import * as readline4 from "readline";
 function extractNameFromFilePath6(filePath) {
-  const basename13 = path10.basename(filePath);
+  const basename13 = path9.basename(filePath);
   const name = basename13.replace(/\.txt$/i, "");
   return name || "\u672A\u77E5\u7FA4\u804A";
 }
@@ -5991,7 +5920,7 @@ async function* parseTxt(options2) {
       messagesProcessed++;
     }
   };
-  const fileStream = fs14.createReadStream(filePath, { encoding: "utf-8" });
+  const fileStream = fs13.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline4.createInterface({
     input: fileStream,
     crlfDelay: Infinity
@@ -6091,8 +6020,8 @@ var module_11 = {
 var qq_native_txt_default = module_11;
 
 // ../../packages/parser/src/formats/instagram-native.ts
-import * as fs15 from "fs";
-import * as path11 from "path";
+import * as fs14 from "fs";
+import * as path10 from "path";
 var feature12 = {
   id: "instagram-native",
   name: "Instagram \u5B98\u65B9\u5BFC\u51FA",
@@ -6118,7 +6047,7 @@ function decodeInstagramText(text) {
   }
 }
 function extractNameFromFilePath7(filePath) {
-  const basename13 = path11.basename(filePath);
+  const basename13 = path10.basename(filePath);
   return basename13.replace(/\.json$/i, "") || "\u672A\u77E5\u5BF9\u8BDD";
 }
 function isSystemMessage2(content) {
@@ -6187,7 +6116,7 @@ async function* parseInstagram(options2) {
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 Instagram \u804A\u5929\u8BB0\u5F55\uFF0C\u5927\u5C0F: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`);
   let data;
   try {
-    const content = fs15.readFileSync(filePath, "utf-8");
+    const content = fs14.readFileSync(filePath, "utf-8");
     data = JSON.parse(content);
   } catch (error) {
     const err = new Error(`\u65E0\u6CD5\u89E3\u6790 Instagram JSON \u6587\u4EF6: ${error}`);
@@ -6282,8 +6211,8 @@ var import_stream_chain8 = __toESM(require_stream_chain(), 1);
 var import_stream_json8 = __toESM(require_stream_json(), 1);
 var import_Pick7 = __toESM(require_Pick(), 1);
 var import_StreamValues8 = __toESM(require_StreamValues(), 1);
-import * as fs16 from "fs";
-import * as path12 from "path";
+import * as fs15 from "fs";
+import * as path11 from "path";
 var { chain: chain8 } = import_stream_chain8.default;
 var { parser: parser9 } = import_stream_json8.default;
 var { pick: pick7 } = import_Pick7.default;
@@ -6366,12 +6295,12 @@ function normalizeIdentity(user) {
   };
 }
 function readJson(filePath) {
-  return JSON.parse(fs16.readFileSync(filePath, "utf8"));
+  return JSON.parse(fs15.readFileSync(filePath, "utf8"));
 }
 function resolveManifestFile(manifestDir, relativePath) {
-  const resolved = path12.resolve(manifestDir, relativePath);
-  const relative2 = path12.relative(manifestDir, resolved);
-  if (relative2.startsWith("..") || path12.isAbsolute(relative2)) {
+  const resolved = path11.resolve(manifestDir, relativePath);
+  const relative2 = path11.relative(manifestDir, resolved);
+  if (relative2.startsWith("..") || path11.isAbsolute(relative2)) {
     throw new Error(`Google Chat manifest path escapes its directory: ${relativePath}`);
   }
   return resolved;
@@ -6384,7 +6313,7 @@ function readManifest2(filePath) {
   if (manifest.chatType !== "private" && manifest.chatType !== "group") {
     throw new Error("Invalid Google Chat chat type");
   }
-  const manifestDir = path12.dirname(filePath);
+  const manifestDir = path11.dirname(filePath);
   return {
     manifest,
     userInfoPath: resolveManifestFile(manifestDir, manifest.userInfoFile),
@@ -6462,7 +6391,7 @@ async function* parseGoogleChat(options2) {
     });
   }
   yield { type: "members", data: Array.from(memberMap.values()) };
-  const readStream = fs16.createReadStream(messagesPath, { encoding: "utf8" });
+  const readStream = fs15.createReadStream(messagesPath, { encoding: "utf8" });
   let bytesRead = 0;
   let messagesProcessed = 0;
   readStream.on("data", (chunk) => {
@@ -6515,8 +6444,8 @@ var module_13 = {
 var google_chat_takeout_default = module_13;
 
 // ../../packages/parser/src/formats/line-native-txt.ts
-import * as fs17 from "fs";
-import * as path13 from "path";
+import * as fs16 from "fs";
+import * as path12 from "path";
 var feature14 = {
   id: "line-native-txt",
   name: "LINE \u5B98\u65B9\u5BFC\u51FA TXT",
@@ -6544,7 +6473,7 @@ var feature14 = {
   }
 };
 function extractNameFromFilePath8(filePath) {
-  const basename13 = path13.basename(filePath, ".txt");
+  const basename13 = path12.basename(filePath, ".txt");
   const name = basename13.replace(/^\[LINE\]\s*/i, "").trim();
   return name || "\u672A\u77E5\u804A\u5929";
 }
@@ -6724,7 +6653,7 @@ async function* parseLINE(options2) {
   yield { type: "progress", data: initialProgress };
   onProgress?.(initialProgress);
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 LINE \u5BFC\u51FA\u6587\u4EF6\uFF0C\u5927\u5C0F: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`);
-  const content = fs17.readFileSync(filePath, "utf-8");
+  const content = fs16.readFileSync(filePath, "utf-8");
   const lines = content.split("\n").map((line) => line.replace(/\r$/, ""));
   let currentDate = null;
   let chatName = extractNameFromFilePath8(filePath);
@@ -7032,12 +6961,12 @@ function findEntryFileInDirectory(dirPath, maxDepth = 1) {
     if (depth > maxDepth) return null;
     let entries;
     try {
-      entries = fs18.readdirSync(current, { withFileTypes: true });
+      entries = fs17.readdirSync(current, { withFileTypes: true });
     } catch {
       return null;
     }
     for (const entry of entries) {
-      const full = path14.join(current, entry.name);
+      const full = path13.join(current, entry.name);
       if (entry.isFile() && entry.name.endsWith(".json")) {
         const format = detectFormat(full);
         if (format) return full;
@@ -7045,7 +6974,7 @@ function findEntryFileInDirectory(dirPath, maxDepth = 1) {
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const found = walk(path14.join(current, entry.name), depth + 1);
+        const found = walk(path13.join(current, entry.name), depth + 1);
         if (found) return found;
       }
     }
@@ -7094,8 +7023,8 @@ function logNativeParserStatus() {
 }
 
 // ../../packages/node-runtime/src/import/perf-logger.ts
-import * as fs19 from "fs";
-import * as path15 from "path";
+import * as fs18 from "fs";
+import * as path14 from "path";
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2["ERROR"] = "ERROR";
   LogLevel2["INFO"] = "INFO";
@@ -7107,11 +7036,11 @@ var currentLogFile = null;
 var errorCount = 0;
 function initPerfLog(sessionId, logDir) {
   try {
-    if (!fs19.existsSync(logDir)) {
-      fs19.mkdirSync(logDir, { recursive: true });
+    if (!fs18.existsSync(logDir)) {
+      fs18.mkdirSync(logDir, { recursive: true });
     }
-    currentLogFile = path15.join(logDir, `import_${sessionId}_${Date.now()}.log`);
-    fs19.writeFileSync(currentLogFile, `=== Import Log ===
+    currentLogFile = path14.join(logDir, `import_${sessionId}_${Date.now()}.log`);
+    fs18.writeFileSync(currentLogFile, `=== Import Log ===
 Start time: ${(/* @__PURE__ */ new Date()).toISOString()}
 
 `, "utf-8");
@@ -7132,7 +7061,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 {
-      fs19.appendFileSync(currentLogFile, logLine, "utf-8");
+      fs18.appendFileSync(currentLogFile, logLine, "utf-8");
     } catch {
     }
   }
@@ -7142,7 +7071,7 @@ function logPerf(event, messagesProcessed, batchSize) {
 function logPerfDetail(detail) {
   if (currentLogFile) {
     try {
-      fs19.appendFileSync(currentLogFile, `  ${detail}
+      fs18.appendFileSync(currentLogFile, `  ${detail}
 `, "utf-8");
     } catch {
     }
@@ -7162,7 +7091,7 @@ function writeLogLine(level, message) {
   const logLine = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${message}
 `;
   try {
-    fs19.appendFileSync(currentLogFile, logLine, "utf-8");
+    fs18.appendFileSync(currentLogFile, logLine, "utf-8");
   } catch {
   }
 }
@@ -7187,7 +7116,7 @@ Total members: ${totalMembers.toLocaleString()}
 Errors: ${errorCount}
 `;
   try {
-    fs19.appendFileSync(currentLogFile, summary, "utf-8");
+    fs18.appendFileSync(currentLogFile, summary, "utf-8");
   } catch {
   }
 }
@@ -7286,8 +7215,8 @@ function segmentText(text, locale, minLength) {
 }
 
 // ../../packages/node-runtime/src/nlp/dict-manager.ts
-import * as fs20 from "fs";
-import * as path16 from "path";
+import * as fs19 from "fs";
+import * as path15 from "path";
 import { createHash } from "crypto";
 var DICT_DOWNLOAD_URL_BASE = "https://chatlab.fun/assets/nlp";
 var DICT_SHA256 = {
@@ -7299,19 +7228,19 @@ var AVAILABLE_DICTS = [
   { id: "zh-TW", label: "\u7E41\u9AD4\u4E2D\u6587", locale: "zh-TW" }
 ];
 function getDictFilePath(nlpDir, dictId) {
-  return path16.join(nlpDir, `${dictId}.dict`);
+  return path15.join(nlpDir, `${dictId}.dict`);
 }
 function isDictDownloaded(nlpDir, dictId) {
-  return fs20.existsSync(getDictFilePath(nlpDir, dictId));
+  return fs19.existsSync(getDictFilePath(nlpDir, dictId));
 }
 function getDictList(nlpDir) {
   return AVAILABLE_DICTS.map((d) => {
     const filePath = getDictFilePath(nlpDir, d.id);
-    const downloaded = fs20.existsSync(filePath);
+    const downloaded = fs19.existsSync(filePath);
     let fileSize;
     if (downloaded) {
       try {
-        fileSize = fs20.statSync(filePath).size;
+        fileSize = fs19.statSync(filePath).size;
       } catch {
       }
     }
@@ -7320,9 +7249,9 @@ function getDictList(nlpDir) {
 }
 function loadDictBuffer(nlpDir, dictId) {
   const filePath = getDictFilePath(nlpDir, dictId);
-  if (!fs20.existsSync(filePath)) return null;
+  if (!fs19.existsSync(filePath)) return null;
   try {
-    return fs20.readFileSync(filePath);
+    return fs19.readFileSync(filePath);
   } catch (error) {
     console.error(`[NLP DictManager] Failed to read dict file: ${filePath}`, error);
     return null;
@@ -7332,7 +7261,7 @@ async function downloadDict(nlpDir, dictId, onProgress) {
   if (!AVAILABLE_DICTS.find((d) => d.id === dictId)) {
     return { success: false, error: `Unknown dict: ${dictId}` };
   }
-  fs20.mkdirSync(nlpDir, { recursive: true });
+  fs19.mkdirSync(nlpDir, { recursive: true });
   const url = `${DICT_DOWNLOAD_URL_BASE}/${dictId}.dict`;
   const filePath = getDictFilePath(nlpDir, dictId);
   const tmpPath = filePath + ".tmp";
@@ -7373,16 +7302,16 @@ async function downloadDict(nlpDir, dictId, onProgress) {
     if (actualSha256 !== expectedSha256) {
       return { success: false, error: "Dictionary integrity check failed (SHA256 mismatch)" };
     }
-    fs20.writeFileSync(tmpPath, buffer);
-    if (fs20.existsSync(filePath)) fs20.unlinkSync(filePath);
-    fs20.renameSync(tmpPath, filePath);
+    fs19.writeFileSync(tmpPath, buffer);
+    if (fs19.existsSync(filePath)) fs19.unlinkSync(filePath);
+    fs19.renameSync(tmpPath, filePath);
     clearJiebaInstance(dictId);
-    console.log(`[NLP DictManager] Dict downloaded: ${dictId} (${fs20.statSync(filePath).size} bytes)`);
+    console.log(`[NLP DictManager] Dict downloaded: ${dictId} (${fs19.statSync(filePath).size} bytes)`);
     return { success: true };
   } catch (error) {
-    if (fs20.existsSync(tmpPath)) {
+    if (fs19.existsSync(tmpPath)) {
       try {
-        fs20.unlinkSync(tmpPath);
+        fs19.unlinkSync(tmpPath);
       } catch {
       }
     }
@@ -7393,9 +7322,9 @@ async function downloadDict(nlpDir, dictId, onProgress) {
 }
 function deleteDict(nlpDir, dictId) {
   const filePath = getDictFilePath(nlpDir, dictId);
-  if (!fs20.existsSync(filePath)) return { success: true };
+  if (!fs19.existsSync(filePath)) return { success: true };
   try {
-    fs20.unlinkSync(filePath);
+    fs19.unlinkSync(filePath);
     clearJiebaInstance(dictId);
     console.log(`[NLP DictManager] Dict deleted: ${dictId}`);
     return { success: true };
@@ -7495,7 +7424,7 @@ function searchByFts(db, keywords, limit = 1e3, offset = 0) {
 }
 
 // ../../packages/node-runtime/src/import/streaming-importer.ts
-import * as fs21 from "fs";
+import * as fs20 from "fs";
 
 // ../../packages/node-runtime/src/import/message-deduplicator.ts
 function generateFallbackMessageKey(message) {
@@ -7527,7 +7456,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((resolve4) => setImmediate(resolve4));
+var yieldToEventLoop = () => new Promise((resolve2) => setImmediate(resolve2));
 function defaultGenerateSessionId() {
   const ts = Date.now();
   const rand = Math.random().toString(36).substring(2, 8);
@@ -8030,7 +7959,7 @@ async function streamParseFileInfo(filePath, deps) {
   if (!formatFeature) {
     throw new Error("Unrecognized file format");
   }
-  const fileSize = fs21.statSync(filePath).size;
+  const fileSize = fs20.statSync(filePath).size;
   deps.onProgress({
     stage: "parsing",
     bytesRead: 0,
@@ -8119,7 +8048,7 @@ async function streamParseFileInfo(filePath, deps) {
     }
     db.close();
     try {
-      if (fs21.existsSync(tempDbPath)) fs21.unlinkSync(tempDbPath);
+      if (fs20.existsSync(tempDbPath)) fs20.unlinkSync(tempDbPath);
     } catch {
     }
     throw error;
@@ -8764,8 +8693,8 @@ async function analyzeAutoImportFile(filePath, deps, options2 = {}) {
 }
 
 // ../../packages/node-runtime/src/import/import-lock.ts
-import * as fs22 from "fs";
-import * as path17 from "path";
+import * as fs21 from "fs";
+import * as path16 from "path";
 import { randomUUID } from "crypto";
 var IMPORT_LOCK_FILENAME = ".chatlab-import.lock";
 var IMPORT_IN_PROGRESS_ERROR_KEY = "error.import_in_progress";
@@ -8779,7 +8708,7 @@ var ImportInProgressError = class extends Error {
 };
 function parseOwner(lockPath) {
   try {
-    const parsed = JSON.parse(fs22.readFileSync(lockPath, "utf-8"));
+    const parsed = JSON.parse(fs21.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;
     }
@@ -8802,13 +8731,13 @@ function removeStaleLock(lockPath) {
     if (isProcessRunning(owner.pid)) return false;
   } else {
     try {
-      if (Date.now() - fs22.statSync(lockPath).mtimeMs < 5e3) return false;
+      if (Date.now() - fs21.statSync(lockPath).mtimeMs < 5e3) return false;
     } catch {
       return true;
     }
   }
   try {
-    fs22.unlinkSync(lockPath);
+    fs21.unlinkSync(lockPath);
     appLogger.warn("import-lock", "Removed stale import lock", { ownerPid: owner?.pid });
     return true;
   } catch {
@@ -8817,7 +8746,7 @@ function removeStaleLock(lockPath) {
 }
 function releaseLock(lockPath, fd, owner) {
   try {
-    fs22.closeSync(fd);
+    fs21.closeSync(fd);
   } catch (error) {
     appLogger.error("import-lock", "Failed to close import lock", error);
   }
@@ -8826,19 +8755,19 @@ function releaseLock(lockPath, fd, owner) {
       appLogger.warn("import-lock", "Import lock ownership changed before release");
       return;
     }
-    fs22.unlinkSync(lockPath);
+    fs21.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) {
-  fs22.mkdirSync(userDataDir, { recursive: true });
-  const lockPath = path17.join(userDataDir, IMPORT_LOCK_FILENAME);
+  fs21.mkdirSync(userDataDir, { recursive: true });
+  const lockPath = path16.join(userDataDir, IMPORT_LOCK_FILENAME);
   let fd = null;
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      fd = fs22.openSync(lockPath, "wx");
+      fd = fs21.openSync(lockPath, "wx");
       break;
     } catch (error) {
       const code = error.code;
@@ -8857,8 +8786,8 @@ async function withDataDirImportLock(userDataDir, task) {
     startedAt: Date.now()
   };
   try {
-    fs22.writeFileSync(fd, JSON.stringify(owner), "utf-8");
-    fs22.fsyncSync(fd);
+    fs21.writeFileSync(fd, JSON.stringify(owner), "utf-8");
+    fs21.fsyncSync(fd);
     appLogger.info("import-lock", "Import lock acquired");
     return await task();
   } finally {
@@ -8878,8 +8807,8 @@ var ArchiveImportError = class extends Error {
 
 // ../../packages/node-runtime/src/import/archive/archive-reader.ts
 var import_yauzl = __toESM(require_yauzl(), 1);
-import * as fs23 from "fs";
-import * as path18 from "path";
+import * as fs22 from "fs";
+import * as path17 from "path";
 import { pipeline } from "stream/promises";
 var DEFAULT_MAX_ENTRIES = 1e5;
 var DEFAULT_MAX_ENTRY_BYTES = 20 * 1024 * 1024 * 1024;
@@ -8998,8 +8927,8 @@ var ZipArchiveReader = class {
     await this.visitEntries(async (entry, openStream) => {
       const destination = targets.get(entry.name);
       if (!destination || entry.isDirectory) return;
-      fs23.mkdirSync(path18.dirname(destination), { recursive: true });
-      await pipeline(await openStream(), fs23.createWriteStream(destination, { flags: "wx" }));
+      fs22.mkdirSync(path17.dirname(destination), { recursive: true });
+      await pipeline(await openStream(), fs22.createWriteStream(destination, { flags: "wx" }));
       remaining.delete(entry.name);
     });
     if (remaining.size > 0) {
@@ -9016,8 +8945,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 fs24 from "fs";
-import * as path19 from "path";
+import * as fs23 from "fs";
+import * as path18 from "path";
 var { chain: chain9 } = import_stream_chain9.default;
 var { parser: parser10 } = import_stream_json9.default;
 var { pick: pick8 } = import_Pick8.default;
@@ -9146,16 +9075,16 @@ var GoogleChatTakeoutResolver = class {
         `Google Chat conversation is missing required files: ${chat.chatId}`
       );
     }
-    fs24.mkdirSync(targetDir, { recursive: true });
+    fs23.mkdirSync(targetDir, { recursive: true });
     await reader.pipeEntries(
       /* @__PURE__ */ new Map([
-        [userInfoEntry, path19.join(targetDir, "user_info.json")],
-        [groupInfoEntry, path19.join(targetDir, "group_info.json")],
-        [messagesEntry, path19.join(targetDir, "messages.json")]
+        [userInfoEntry, path18.join(targetDir, "user_info.json")],
+        [groupInfoEntry, path18.join(targetDir, "group_info.json")],
+        [messagesEntry, path18.join(targetDir, "messages.json")]
       ])
     );
-    const manifestPath = path19.join(targetDir, "google-chat-import.json");
-    fs24.writeFileSync(
+    const manifestPath = path18.join(targetDir, "google-chat-import.json");
+    fs23.writeFileSync(
       manifestPath,
       JSON.stringify(
         {
@@ -9178,8 +9107,8 @@ var GoogleChatTakeoutResolver = class {
 };
 
 // ../../packages/node-runtime/src/import/archive/source-manager.ts
-import * as fs25 from "fs";
-import * as path20 from "path";
+import * as fs24 from "fs";
+import * as path19 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 var DEFAULT_TTL_MS = 30 * 60 * 1e3;
 var ArchiveImportSourceManager = class {
@@ -9190,11 +9119,11 @@ var ArchiveImportSourceManager = class {
   now;
   resolvers;
   constructor(options2 = {}) {
-    this.tempRoot = options2.tempRoot ?? createChatLabTempDir("imports", "sources-");
+    this.tempRoot = options2.tempRoot ?? path19.join(process.cwd(), ".chatlab-import-sources");
     this.ttlMs = options2.ttlMs ?? DEFAULT_TTL_MS;
     this.now = options2.now ?? Date.now;
     this.resolvers = options2.resolvers ?? [new GoogleChatTakeoutResolver()];
-    fs25.mkdirSync(this.tempRoot, { recursive: true });
+    fs24.mkdirSync(this.tempRoot, { recursive: true });
   }
   prepareLocalArchive(archivePath) {
     return this.prepareArchive(archivePath, false);
@@ -9251,7 +9180,7 @@ var ArchiveImportSourceManager = class {
         `Archive conversation was not found: ${chatId}`
       );
     }
-    const materializedDir = fs25.mkdtempSync(path20.join(this.tempRoot, `materialized-${sourceId}-`));
+    const materializedDir = fs24.mkdtempSync(path19.join(this.tempRoot, `materialized-${sourceId}-`));
     try {
       const reader = new ZipArchiveReader(record.archivePath);
       const materialized = await record.resolver.materialize(reader, chat, materializedDir);
@@ -9302,7 +9231,7 @@ var ArchiveImportSourceManager = class {
   }
   removePath(targetPath) {
     try {
-      fs25.rmSync(targetPath, { recursive: true, force: true });
+      fs24.rmSync(targetPath, { recursive: true, force: true });
     } catch {
     }
   }
@@ -9372,12 +9301,12 @@ ${rawErrorLabel}: ${details}`;
 }
 
 // ../../packages/node-runtime/src/ai/assistant-parser.ts
-import * as path21 from "path";
+import * as path20 from "path";
 import matter from "gray-matter";
 function parseAssistantFile(content, filePath) {
   try {
     const { data: fm, content: body } = matter(content);
-    const id = fm.id ?? path21.basename(filePath, ".md");
+    const id = fm.id ?? path20.basename(filePath, ".md");
     const name = fm.name;
     if (!name) return null;
     return {
@@ -9456,8 +9385,8 @@ var AssistantManager = class {
   }
   // ==================== Init ====================
   init() {
-    const { fs: fs37, assistantsDir } = this.deps;
-    fs37.ensureDir(assistantsDir);
+    const { fs: fs35, assistantsDir } = this.deps;
+    fs35.ensureDir(assistantsDir);
     const generalCreated = this.ensureGeneralAssistants();
     this.loadAll();
     this.initialized = true;
@@ -9468,26 +9397,26 @@ var AssistantManager = class {
     return { total: this.cache.size, generalCreated };
   }
   ensureGeneralAssistants() {
-    const { fs: fs37, assistantsDir } = this.deps;
+    const { fs: fs35, assistantsDir } = this.deps;
     let anyCreated = false;
     for (const id of this.generalIds) {
       const config = this.getBuiltinConfig(id);
       if (!config) continue;
-      const filePath = fs37.joinPath(assistantsDir, `${id}.md`);
-      if (fs37.fileExists(filePath)) continue;
-      fs37.writeFile(filePath, serializeAssistant({ ...config, builtinId: config.id }));
+      const filePath = fs35.joinPath(assistantsDir, `${id}.md`);
+      if (fs35.fileExists(filePath)) continue;
+      fs35.writeFile(filePath, serializeAssistant({ ...config, builtinId: config.id }));
       anyCreated = true;
     }
     return anyCreated;
   }
   loadAll() {
-    const { fs: fs37, assistantsDir } = this.deps;
+    const { fs: fs35, assistantsDir } = this.deps;
     this.cache.clear();
-    const files = fs37.listFiles(assistantsDir, ".md");
+    const files = fs35.listFiles(assistantsDir, ".md");
     for (const file of files) {
       try {
-        const filePath = fs37.joinPath(assistantsDir, file);
-        const content = fs37.readFile(filePath);
+        const filePath = fs35.joinPath(assistantsDir, file);
+        const content = fs35.readFile(filePath);
         const config = parseAssistantFile(content, filePath);
         if (config) {
           this.cache.set(config.id, config);
@@ -9599,12 +9528,12 @@ var AssistantManager = class {
 };
 
 // ../../packages/node-runtime/src/ai/skill-parser.ts
-import * as path22 from "path";
+import * as path21 from "path";
 import matter2 from "gray-matter";
 function parseSkillFile(content, filePath) {
   try {
     const { data: fm, content: prompt } = matter2(content);
-    const id = fm.id ?? path22.basename(filePath, ".md");
+    const id = fm.id ?? path21.basename(filePath, ".md");
     const name = fm.name;
     if (!name) return null;
     return {
@@ -9623,7 +9552,7 @@ function parseSkillFile(content, filePath) {
 function extractSkillId(content, filePath) {
   try {
     const { data: fm } = matter2(content);
-    return fm.id ?? path22.basename(filePath, ".md");
+    return fm.id ?? path21.basename(filePath, ".md");
   } catch {
     return null;
   }
@@ -9642,8 +9571,8 @@ function validateChatScope(raw) {
 
 // ../../packages/node-runtime/src/ai/chats.ts
 import Database from "better-sqlite3";
-import * as fs26 from "fs";
-import * as path23 from "path";
+import * as fs25 from "fs";
+import * as path22 from "path";
 var DEFAULT_GENERAL_ID = "general_cn";
 var defaultLogger = {
   warn(_category, message, extra) {
@@ -9662,14 +9591,14 @@ var AIChatManager = class {
     this.nativeBinding = options2?.nativeBinding;
   }
   ensureDir(dir) {
-    if (!fs26.existsSync(dir)) {
-      fs26.mkdirSync(dir, { recursive: true });
+    if (!fs25.existsSync(dir)) {
+      fs25.mkdirSync(dir, { recursive: true });
     }
   }
   getDb() {
     if (this.db) return this.db;
     this.ensureDir(this.aiDataDir);
-    const dbPath = path23.join(this.aiDataDir, "conversations.db");
+    const dbPath = path22.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(`
@@ -9912,16 +9841,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 path33 = [];
+    const path31 = [];
     const seen = /* @__PURE__ */ new Set();
     while (currentId && !seen.has(currentId)) {
       seen.add(currentId);
       const row = rowMap.get(currentId);
       if (!row) break;
-      path33.push(row);
+      path31.push(row);
       currentId = row.parentId;
     }
-    return path33.length > 0 ? path33.reverse() : allRows;
+    return path31.length > 0 ? path31.reverse() : allRows;
   }
   // ==================== 生命周期 ====================
   close() {
@@ -10491,21 +10420,21 @@ var SkillManagerCore = class {
   }
   // ==================== Init ====================
   init() {
-    const { fs: fs37, skillsDir } = this.deps;
-    fs37.ensureDir(skillsDir);
+    const { fs: fs35, skillsDir } = this.deps;
+    fs35.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: fs37, skillsDir } = this.deps;
+    const { fs: fs35, skillsDir } = this.deps;
     this.cache.clear();
-    const files = fs37.listFiles(skillsDir, ".md");
+    const files = fs35.listFiles(skillsDir, ".md");
     for (const file of files) {
       try {
-        const filePath = fs37.joinPath(skillsDir, file);
-        const content = fs37.readFile(filePath);
+        const filePath = fs35.joinPath(skillsDir, file);
+        const content = fs35.readFile(filePath);
         const def = parseSkillFile(content, filePath);
         if (def) {
           this.cache.set(def.id, def);
@@ -10657,8 +10586,8 @@ var SkillManagerCore = class {
 };
 
 // ../../packages/node-runtime/src/ai/skill-manager.ts
-import * as fs27 from "fs";
-import * as path24 from "path";
+import * as fs26 from "fs";
+import * as path23 from "path";
 var SKILLS_DIR_NAME = "skills";
 var defaultLogger2 = {
   info: () => {
@@ -10668,26 +10597,26 @@ var defaultLogger2 = {
 };
 var nodeFs = {
   ensureDir(dir) {
-    fs27.mkdirSync(dir, { recursive: true });
+    fs26.mkdirSync(dir, { recursive: true });
   },
   listFiles(dir, ext) {
-    if (!fs27.existsSync(dir)) return [];
-    return fs27.readdirSync(dir).filter((file) => file.endsWith(ext));
+    if (!fs26.existsSync(dir)) return [];
+    return fs26.readdirSync(dir).filter((file) => file.endsWith(ext));
   },
   readFile(filePath) {
-    return fs27.readFileSync(filePath, "utf-8");
+    return fs26.readFileSync(filePath, "utf-8");
   },
   writeFile(filePath, content) {
-    fs27.writeFileSync(filePath, content, "utf-8");
+    fs26.writeFileSync(filePath, content, "utf-8");
   },
   deleteFile(filePath) {
-    fs27.unlinkSync(filePath);
+    fs26.unlinkSync(filePath);
   },
   fileExists(filePath) {
-    return fs27.existsSync(filePath);
+    return fs26.existsSync(filePath);
   },
   joinPath(...parts) {
-    return path24.join(...parts);
+    return path23.join(...parts);
   }
 };
 var SkillManager = class {
@@ -10697,7 +10626,7 @@ var SkillManager = class {
     this.logger = logger ?? defaultLogger2;
     this.core = new SkillManagerCore({
       fs: nodeFs,
-      skillsDir: path24.join(aiDataDir, SKILLS_DIR_NAME),
+      skillsDir: path23.join(aiDataDir, SKILLS_DIR_NAME),
       builtinRawSkills: [],
       logger: {
         info: () => {
@@ -14527,9 +14456,9 @@ var localeMap = {
   "ja-JP": ja_JP_default,
   "zh-TW": zh_TW_default
 };
-function getNestedValue(obj, path33) {
+function getNestedValue(obj, path31) {
   let current = obj;
-  for (const segment2 of path33.split(".")) {
+  for (const segment2 of path31.split(".")) {
     if (current == null || typeof current !== "object") return void 0;
     current = current[segment2];
   }
@@ -15042,49 +14971,6 @@ 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)}`;
@@ -15904,8 +15790,8 @@ function exportWithFormat(params, openDatabase) {
 }
 
 // ../../packages/node-runtime/src/merger/temp-db.ts
-import * as fs29 from "fs";
-import * as path26 from "path";
+import * as fs27 from "fs";
+import * as path24 from "path";
 var TEMP_DB_SCHEMA = `
   CREATE TABLE IF NOT EXISTS meta (
     name TEXT NOT NULL,
@@ -16150,21 +16036,21 @@ function exportSessionToJson(db) {
 }
 function deleteTempDatabase(dbPath) {
   try {
-    if (fs29.existsSync(dbPath)) fs29.unlinkSync(dbPath);
+    if (fs27.existsSync(dbPath)) fs27.unlinkSync(dbPath);
     const walPath = dbPath + "-wal";
     const shmPath = dbPath + "-shm";
-    if (fs29.existsSync(walPath)) fs29.unlinkSync(walPath);
-    if (fs29.existsSync(shmPath)) fs29.unlinkSync(shmPath);
+    if (fs27.existsSync(walPath)) fs27.unlinkSync(walPath);
+    if (fs27.existsSync(shmPath)) fs27.unlinkSync(shmPath);
   } catch {
   }
 }
 function cleanupTempDatabases(tempDir) {
   try {
-    if (!fs29.existsSync(tempDir)) return;
-    const files = fs29.readdirSync(tempDir);
+    if (!fs27.existsSync(tempDir)) return;
+    const files = fs27.readdirSync(tempDir);
     for (const file of files) {
       if (file.startsWith("merge_") && file.endsWith(".db")) {
-        deleteTempDatabase(path26.join(tempDir, file));
+        deleteTempDatabase(path24.join(tempDir, file));
       }
     }
   } catch {
@@ -16243,7 +16129,6 @@ function deleteSession(adapter, sessionId) {
 var member_service_exports = {};
 __export(member_service_exports, {
   deleteMember: () => deleteMember2,
-  deleteMembers: () => deleteMembers2,
   getMemberNameHistory: () => getMemberNameHistory2,
   getMembers: () => getMembers,
   getMembersPaginated: () => getMembersPaginated2,
@@ -16277,10 +16162,6 @@ 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);
@@ -16549,8 +16430,8 @@ function clearSessionOwner(adapter, sessionId) {
 }
 
 // ../../packages/node-runtime/src/services/contacts/overrides.ts
-import fs30 from "fs";
-import path27 from "path";
+import fs28 from "fs";
+import path25 from "path";
 var CONTACT_OVERRIDES_FILE_NAME = "contact-overrides.json";
 var CONTACT_OVERRIDES_TMP_PREFIX = "contact-overrides.tmp-";
 var CONTACT_OVERRIDES_VERSION = 1;
@@ -16561,23 +16442,23 @@ function createEmptyContactOverridesFile() {
   };
 }
 function getContactOverridesPath(snapshotDir) {
-  return path27.join(snapshotDir, CONTACT_OVERRIDES_FILE_NAME);
+  return path25.join(snapshotDir, CONTACT_OVERRIDES_FILE_NAME);
 }
 function readContactOverrides(snapshotDir) {
   const filePath = getContactOverridesPath(snapshotDir);
-  if (!fs30.existsSync(filePath)) return createEmptyContactOverridesFile();
+  if (!fs28.existsSync(filePath)) return createEmptyContactOverridesFile();
   try {
-    return normalizeContactOverrides(JSON.parse(fs30.readFileSync(filePath, "utf-8")));
+    return normalizeContactOverrides(JSON.parse(fs28.readFileSync(filePath, "utf-8")));
   } catch (error) {
     appLogger.warn("contacts", "contact overrides file is unreadable", error);
     return createEmptyContactOverridesFile();
   }
 }
 function writeContactOverrides(snapshotDir, overrides) {
-  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));
+  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));
 }
 function normalizeContactOverrides(value) {
   const input = isRecord2(value) ? value : {};
@@ -16612,23 +16493,23 @@ function buildContactsSignature(adapter, timeRangePreset) {
 }
 
 // ../../packages/node-runtime/src/services/contacts/snapshot.ts
-import fs31 from "fs";
-import path28 from "path";
+import fs29 from "fs";
+import path26 from "path";
 var CONTACTS_SNAPSHOT_TMP_PREFIX = "contacts-snapshot.tmp-";
 function getContactsSnapshotPath(snapshotDir, timeRangePreset) {
   const preset = normalizeContactsTimeRangePreset(timeRangePreset);
-  return path28.join(snapshotDir, `contacts-snapshot-${preset}.json`);
+  return path26.join(snapshotDir, `contacts-snapshot-${preset}.json`);
 }
 function readContactsSnapshot(snapshotDir, timeRangePreset, options2 = {}) {
   const snapshotPath = getContactsSnapshotPath(snapshotDir, timeRangePreset);
-  if (!fs31.existsSync(snapshotPath)) return null;
+  if (!fs29.existsSync(snapshotPath)) return null;
   try {
-    return JSON.parse(fs31.readFileSync(snapshotPath, "utf-8"));
+    return JSON.parse(fs29.readFileSync(snapshotPath, "utf-8"));
   } catch (error) {
     const ts = options2.now?.() ?? Date.now();
-    const backupPath = path28.join(snapshotDir, `contacts-snapshot.corrupt-${ts}.json`);
+    const backupPath = path26.join(snapshotDir, `contacts-snapshot.corrupt-${ts}.json`);
     try {
-      fs31.renameSync(snapshotPath, backupPath);
+      fs29.renameSync(snapshotPath, backupPath);
     } catch (renameError) {
       appLogger.warn("contacts", "failed to backup corrupt contacts snapshot", renameError);
     }
@@ -16637,17 +16518,17 @@ function readContactsSnapshot(snapshotDir, timeRangePreset, options2 = {}) {
   }
 }
 function writeContactsSnapshot(snapshotDir, snapshot) {
-  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));
+  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));
 }
 function cleanupContactsSnapshotTempFiles(snapshotDir) {
-  if (!fs31.existsSync(snapshotDir)) return;
-  for (const name of fs31.readdirSync(snapshotDir)) {
+  if (!fs29.existsSync(snapshotDir)) return;
+  for (const name of fs29.readdirSync(snapshotDir)) {
     if (!name.startsWith(CONTACTS_SNAPSHOT_TMP_PREFIX)) continue;
     try {
-      fs31.rmSync(path28.join(snapshotDir, name), { force: true });
+      fs29.rmSync(path26.join(snapshotDir, name), { force: true });
     } catch (error) {
       appLogger.warn("contacts", "failed to remove contacts snapshot temp file", error);
     }
@@ -16685,7 +16566,7 @@ function createWorker(workerData, entryUrlInput) {
   return new Worker(bootstrap, options2);
 }
 function createContactsWorkerRunner(options2) {
-  return ({ signature, timeRangePreset, signal, onProgress }) => new Promise((resolve4, reject) => {
+  return ({ signature, timeRangePreset, signal, onProgress }) => new Promise((resolve2, reject) => {
     if (signal.aborted) {
       reject(createAbortError());
       return;
@@ -16716,7 +16597,7 @@ function createContactsWorkerRunner(options2) {
       if (message.type === "success" && message.snapshot) {
         settled = true;
         signal.removeEventListener("abort", abort);
-        resolve4(message.snapshot);
+        resolve2(message.snapshot);
         void worker.terminate();
         return;
       }
@@ -17145,23 +17026,23 @@ function buildPeopleRelationshipsSignature(adapter, timeRangePreset) {
 }
 
 // ../../packages/node-runtime/src/services/people/relationships/snapshot.ts
-import fs32 from "fs";
-import path29 from "path";
+import fs30 from "fs";
+import path27 from "path";
 var PEOPLE_RELATIONSHIPS_SNAPSHOT_TMP_PREFIX = "people-relationships-snapshot.tmp-";
 function getPeopleRelationshipsSnapshotPath(snapshotDir, timeRangePreset) {
   const preset = normalizePeopleRelationshipsTimeRangePreset(timeRangePreset);
-  return path29.join(snapshotDir, `graph-snapshot-${preset}.json`);
+  return path27.join(snapshotDir, `graph-snapshot-${preset}.json`);
 }
 function readPeopleRelationshipsSnapshot(snapshotDir, timeRangePreset, options2 = {}) {
   const snapshotPath = getPeopleRelationshipsSnapshotPath(snapshotDir, timeRangePreset);
-  if (!fs32.existsSync(snapshotPath)) return null;
+  if (!fs30.existsSync(snapshotPath)) return null;
   try {
-    return JSON.parse(fs32.readFileSync(snapshotPath, "utf-8"));
+    return JSON.parse(fs30.readFileSync(snapshotPath, "utf-8"));
   } catch (error) {
     const ts = options2.now?.() ?? Date.now();
-    const backupPath = path29.join(snapshotDir, `graph-snapshot.corrupt-${ts}.json`);
+    const backupPath = path27.join(snapshotDir, `graph-snapshot.corrupt-${ts}.json`);
     try {
-      fs32.renameSync(snapshotPath, backupPath);
+      fs30.renameSync(snapshotPath, backupPath);
     } catch (renameError) {
       appLogger.warn("people-relationships", "failed to backup corrupt people relationships snapshot", renameError);
     }
@@ -17170,17 +17051,17 @@ function readPeopleRelationshipsSnapshot(snapshotDir, timeRangePreset, options2
   }
 }
 function writePeopleRelationshipsSnapshot(snapshotDir, snapshot) {
-  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));
+  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));
 }
 function cleanupPeopleRelationshipsSnapshotTempFiles(snapshotDir) {
-  if (!fs32.existsSync(snapshotDir)) return;
-  for (const name of fs32.readdirSync(snapshotDir)) {
+  if (!fs30.existsSync(snapshotDir)) return;
+  for (const name of fs30.readdirSync(snapshotDir)) {
     if (!name.startsWith(PEOPLE_RELATIONSHIPS_SNAPSHOT_TMP_PREFIX)) continue;
     try {
-      fs32.rmSync(path29.join(snapshotDir, name), { force: true });
+      fs30.rmSync(path27.join(snapshotDir, name), { force: true });
     } catch (error) {
       appLogger.warn("people-relationships", "failed to remove people relationships snapshot temp file", error);
     }
@@ -17218,7 +17099,7 @@ function createWorker2(workerData, entryUrlInput) {
   return new Worker2(bootstrap, options2);
 }
 function createPeopleRelationshipsWorkerRunner(options2) {
-  return ({ signature, timeRangePreset, signal, onProgress }) => new Promise((resolve4, reject) => {
+  return ({ signature, timeRangePreset, signal, onProgress }) => new Promise((resolve2, reject) => {
     if (signal.aborted) {
       reject(createAbortError2());
       return;
@@ -17249,7 +17130,7 @@ function createPeopleRelationshipsWorkerRunner(options2) {
       if (message.type === "success" && message.snapshot) {
         settled = true;
         signal.removeEventListener("abort", abort);
-        resolve4(message.snapshot);
+        resolve2(message.snapshot);
         void worker.terminate();
         return;
       }
@@ -17702,7 +17583,7 @@ __export(relationships_exports, {
 });
 
 // ../../packages/node-runtime/src/services/global-insight/service.ts
-import fs33 from "fs";
+import fs31 from "fs";
 
 // ../../packages/node-runtime/src/services/global-insight/signature.ts
 function buildAnnualSummarySignature(adapter, range) {
@@ -17729,7 +17610,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((resolve4, reject) => {
+  return ({ signature, range, signal, onProgress }) => new Promise((resolve2, reject) => {
     if (signal.aborted) {
       reject(new Error("annual summary worker aborted"));
       return;
@@ -17760,7 +17641,7 @@ function createAnnualSummaryWorkerRunner(options2) {
       if (message.type === "success" && message.snapshot) {
         settled = true;
         signal.removeEventListener("abort", abort);
-        resolve4(message.snapshot);
+        resolve2(message.snapshot);
         void worker.terminate();
         return;
       }
@@ -17955,7 +17836,7 @@ var DefaultGlobalInsightService = class {
   }
   getSnapshot(range) {
     const key = toAnnualSummaryRangeKey(range);
-    if (this.snapshots.has(key) && !fs33.existsSync(getAnnualSummarySnapshotPath(this.snapshotDir, range))) {
+    if (this.snapshots.has(key) && !fs31.existsSync(getAnnualSummarySnapshotPath(this.snapshotDir, range))) {
       this.snapshots.delete(key);
     }
     if (!this.snapshots.has(key)) {
@@ -18003,8 +17884,8 @@ __export(global_insight_exports, {
 });
 
 // ../../packages/node-runtime/src/semantic-index/config.ts
-import fs34 from "fs";
-import path30 from "path";
+import fs32 from "fs";
+import path28 from "path";
 var DEFAULT_SEMANTIC_INDEX_MODEL_DOWNLOAD_SOURCE = "huggingface";
 var SEMANTIC_INDEX_CONFIG_VERSION = 1;
 var SEARCH_MAX_RESULTS_DEFAULT = 10;
@@ -18093,9 +17974,9 @@ var SemanticIndexConfigStore = class {
     return this.set({ ...this.get(), enabled });
   }
   get() {
-    if (!fs34.existsSync(this.filePath)) return defaultSemanticIndexConfig();
+    if (!fs32.existsSync(this.filePath)) return defaultSemanticIndexConfig();
     try {
-      const raw = JSON.parse(fs34.readFileSync(this.filePath, "utf-8"));
+      const raw = JSON.parse(fs32.readFileSync(this.filePath, "utf-8"));
       return normalizeConfig(raw);
     } catch {
       return defaultSemanticIndexConfig();
@@ -18103,9 +17984,9 @@ var SemanticIndexConfigStore = class {
   }
   set(config) {
     const normalized = normalizeConfig(config);
-    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");
+    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");
     return normalized;
   }
   resolveModelId() {
@@ -18114,7 +17995,7 @@ var SemanticIndexConfigStore = class {
 };
 
 // ../../packages/node-runtime/src/semantic-index/service.ts
-import path31 from "path";
+import path29 from "path";
 
 // ../../packages/node-runtime/src/semantic-index/chunker-config.ts
 import { createHash as createHash2 } from "crypto";
@@ -18435,8 +18316,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 resolve4 = deps.resolveApiKey ?? resolveApiKey;
-    const apiKey = resolve4("", config.api.authProfile);
+    const resolve2 = deps.resolveApiKey ?? resolveApiKey;
+    const apiKey = resolve2("", config.api.authProfile);
     return new OpenAICompatibleEmbeddingProvider(
       { baseUrl: config.api.baseUrl, apiKey, model: config.api.model },
       { fetchFn: deps.fetchFn }
@@ -18473,8 +18354,8 @@ function extensionSuffix(platform2) {
   return "so";
 }
 function platformPackageName(platform2, arch2) {
-  const os3 = platform2 === "win32" ? "windows" : platform2;
-  return `${BASE_PACKAGE_NAME}-${os3}-${arch2}`;
+  const os2 = platform2 === "win32" ? "windows" : platform2;
+  return `${BASE_PACKAGE_NAME}-${os2}-${arch2}`;
 }
 function getLoadablePath() {
   if (!validPlatform(platform, arch)) {
@@ -18973,7 +18854,7 @@ var SemanticIndexJobQueue = class {
   /** 等待队列清空（含当前任务） */
   whenIdle() {
     if (!this.processing && this.pending.length === 0) return Promise.resolve();
-    return new Promise((resolve4) => this.idleResolvers.push(resolve4));
+    return new Promise((resolve2) => this.idleResolvers.push(resolve2));
   }
   removePending(dbPathHash) {
     this.pending = this.pending.filter((j) => j.dbPathHash !== dbPathHash);
@@ -18995,7 +18876,7 @@ var SemanticIndexJobQueue = class {
     this.processing = false;
     const resolvers = this.idleResolvers;
     this.idleResolvers = [];
-    for (const resolve4 of resolvers) resolve4();
+    for (const resolve2 of resolvers) resolve2();
   }
 };
 
@@ -19645,16 +19526,16 @@ function resolveSearchToolEvidenceTokens(maxResultTokens) {
   return maxResultTokens && maxResultTokens > 0 ? Math.min(SEARCH_TOOL_EVIDENCE_TOKENS, maxResultTokens) : SEARCH_TOOL_EVIDENCE_TOKENS;
 }
 function sessionIdFromDbPath(dbPath) {
-  return path31.basename(dbPath, ".db");
+  return path29.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: 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"),
+    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"),
     modelDownloadProxyUrl: params.modelDownloadProxyUrl,
     sessionAdapter: params.sessionAdapter,
     nativeBinding: params.nativeBinding,
@@ -20204,8 +20085,8 @@ ${text}`;
 };
 
 // ../../packages/node-runtime/src/services/merge-cache.ts
-import * as fs35 from "fs";
-import * as path32 from "path";
+import * as fs33 from "fs";
+import * as path30 from "path";
 import * as crypto from "crypto";
 var MergeSessionCache = class {
   cache = /* @__PURE__ */ new Map();
@@ -20214,15 +20095,15 @@ var MergeSessionCache = class {
   constructor(pathProvider, options2) {
     this.tempDir = pathProvider.getTempDir();
     this.nativeBinding = options2?.nativeBinding;
-    if (!fs35.existsSync(this.tempDir)) {
-      fs35.mkdirSync(this.tempDir, { recursive: true });
+    if (!fs33.existsSync(this.tempDir)) {
+      fs33.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 path32.join(this.tempDir, `merge_${safeName}_${ts}_${rand}.db`);
+    return path30.join(this.tempDir, `merge_${safeName}_${ts}_${rand}.db`);
   }
   /** Store a parsed file's temp DB and return a handle for subsequent requests. */
   store(filename, tempDbPath) {
@@ -20233,7 +20114,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 || !fs35.existsSync(entry.tempDbPath)) return null;
+    if (!entry || !fs33.existsSync(entry.tempDbPath)) return null;
     const adapter = openBetterSqliteDatabase(entry.tempDbPath, {
       readonly: true,
       nativeBinding: this.nativeBinding
@@ -20278,7 +20159,7 @@ var MergeSessionCache = class {
 };
 
 // ../../packages/node-runtime/src/services/push-importer.ts
-import * as fs36 from "fs";
+import * as fs34 from "fs";
 var SYSTEM_SENDER_ID = "SYSTEM";
 var SYSTEM_MEMBER_NAME = "\u7CFB\u7EDF\u6D88\u606F";
 function isRecord3(value) {
@@ -20645,7 +20526,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 = !fs36.existsSync(dbPath);
+  const isNew = !fs34.existsSync(dbPath);
   const validationError = validatePayload(payload, isNew);
   if (validationError) {
     return { ok: false, reason: "invalid_payload", message: validationError };
@@ -20745,12 +20626,6 @@ var ImportIdempotencyCache = class {
 };
 
 export {
-  CHATLAB_TEMP_ROOT_ENV,
-  resolveChatLabTempRoot,
-  ensureChatLabTempRoot,
-  getChatLabTempScopeDir,
-  createChatLabTempDir,
-  removeChatLabTempDir,
   writeParseResultToDb,
   detectFormat,
   detectAllFormats,
@@ -20872,8 +20747,6 @@ export {
   checkSessionsCanGenerateSummary,
   MAX_CONFIG_COUNT,
   LLMConfigStore,
-  createFileConfigStorage,
-  createAuthProfileLlmConfigStore,
   CustomProviderStore,
   CustomModelStore,
   normalizeAnthropicBaseUrl,
@@ -20968,4 +20841,4 @@ export {
   hashImportBody,
   ImportIdempotencyCache
 };
-//# sourceMappingURL=chunk-5G2INROS.mjs.map
+//# sourceMappingURL=chunk-GYPBWKAU.mjs.map