chatlab-cli 0.1.0 → 0.21.1

package/dist/{chunk-JMRDNHIR.mjs → chunk-7HQWGLX6.mjs}

@@ -19,6 +19,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -36,9 +40,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/utils/Utf8Stream.js
+// ../../node_modules/stream-json/utils/Utf8Stream.js
 var require_Utf8Stream = __commonJS({
-  "../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/utils/Utf8Stream.js"(exports, module) {
+  "../../node_modules/stream-json/utils/Utf8Stream.js"(exports, module) {
     "use strict";
     var { Transform } = __require("stream");
     var { StringDecoder } = __require("string_decoder");
@@ -85,9 +89,9 @@ var require_Utf8Stream = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/Parser.js
+// ../../node_modules/stream-json/Parser.js
 var require_Parser = __commonJS({
-  "../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/Parser.js"(exports, module) {
+  "../../node_modules/stream-json/Parser.js"(exports, module) {
     "use strict";
     var Utf8Stream = require_Utf8Stream();
     var patterns = {
@@ -614,18 +618,18 @@ var require_Parser = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/utils/emit.js
+// ../../node_modules/stream-json/utils/emit.js
 var require_emit = __commonJS({
-  "../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/utils/emit.js"(exports, module) {
+  "../../node_modules/stream-json/utils/emit.js"(exports, module) {
     "use strict";
     var emit = (stream) => stream.on("data", (item) => stream.emit(item.name, item.value));
     module.exports = emit;
   }
 });
 
-// ../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/index.js
+// ../../node_modules/stream-json/index.js
 var require_stream_json = __commonJS({
-  "../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/index.js"(exports, module) {
+  "../../node_modules/stream-json/index.js"(exports, module) {
     "use strict";
     var Parser = require_Parser();
     var emit = require_emit();
@@ -636,16 +640,16 @@ var require_stream_json = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/filters/FilterBase.js
+// ../../node_modules/stream-json/filters/FilterBase.js
 var require_FilterBase = __commonJS({
-  "../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/filters/FilterBase.js"(exports, module) {
+  "../../node_modules/stream-json/filters/FilterBase.js"(exports, module) {
     "use strict";
     var { Transform } = __require("stream");
     var FilterBase = class _FilterBase extends Transform {
       static stringFilter(string, separator) {
         return (stack) => {
-          const path36 = stack.join(separator);
-          return path36.length === string.length && path36 === string || path36.length > string.length && path36.substr(0, string.length) === string && path36.substr(string.length, separator.length) === separator;
+          const path37 = stack.join(separator);
+          return path37.length === string.length && path37 === string || path37.length > string.length && path37.substr(0, string.length) === string && path37.substr(string.length, separator.length) === separator;
         };
       }
       static regExpFilter(regExp, separator) {
@@ -811,9 +815,9 @@ var require_FilterBase = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/stream-chain@2.2.5/node_modules/stream-chain/index.js
+// ../../node_modules/stream-chain/index.js
 var require_stream_chain = __commonJS({
-  "../../node_modules/.pnpm/stream-chain@2.2.5/node_modules/stream-chain/index.js"(exports, module) {
+  "../../node_modules/stream-chain/index.js"(exports, module) {
     "use strict";
     var { Readable, Writable, Duplex, Transform } = __require("stream");
     var none = /* @__PURE__ */ Symbol.for("object-stream.none");
@@ -983,9 +987,9 @@ var require_stream_chain = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/utils/withParser.js
+// ../../node_modules/stream-json/utils/withParser.js
 var require_withParser = __commonJS({
-  "../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/utils/withParser.js"(exports, module) {
+  "../../node_modules/stream-json/utils/withParser.js"(exports, module) {
     "use strict";
     var { chain: chain8 } = require_stream_chain();
     var Parser = require_Parser();
@@ -994,9 +998,9 @@ var require_withParser = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/filters/Pick.js
+// ../../node_modules/stream-json/filters/Pick.js
 var require_Pick = __commonJS({
-  "../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/filters/Pick.js"(exports, module) {
+  "../../node_modules/stream-json/filters/Pick.js"(exports, module) {
     "use strict";
     var FilterBase = require_FilterBase();
     var withParser = require_withParser();
@@ -1053,9 +1057,9 @@ var require_Pick = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/Assembler.js
+// ../../node_modules/stream-json/Assembler.js
 var require_Assembler = __commonJS({
-  "../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/Assembler.js"(exports, module) {
+  "../../node_modules/stream-json/Assembler.js"(exports, module) {
     "use strict";
     var EventEmitter = __require("events");
     var startObject = (Ctr) => function() {
@@ -1099,12 +1103,12 @@ var require_Assembler = __commonJS({
         return (this.stack.length >> 1) + (this.done ? 0 : 1);
       }
       get path() {
-        const path36 = [];
+        const path37 = [];
         for (let i = 0; i < this.stack.length; i += 2) {
           const key = this.stack[i + 1];
-          path36.push(key === null ? this.stack[i].length : key);
+          path37.push(key === null ? this.stack[i].length : key);
         }
-        return path36;
+        return path37;
       }
       dropToLevel(level) {
         if (level < this.depth) {
@@ -1194,9 +1198,9 @@ var require_Assembler = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/streamers/StreamBase.js
+// ../../node_modules/stream-json/streamers/StreamBase.js
 var require_StreamBase = __commonJS({
-  "../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/streamers/StreamBase.js"(exports, module) {
+  "../../node_modules/stream-json/streamers/StreamBase.js"(exports, module) {
     "use strict";
     var { Transform } = __require("stream");
     var Assembler = require_Assembler();
@@ -1293,9 +1297,9 @@ var require_StreamBase = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/streamers/StreamValues.js
+// ../../node_modules/stream-json/streamers/StreamValues.js
 var require_StreamValues = __commonJS({
-  "../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/streamers/StreamValues.js"(exports, module) {
+  "../../node_modules/stream-json/streamers/StreamValues.js"(exports, module) {
     "use strict";
     var StreamBase = require_StreamBase();
     var withParser = require_withParser();
@@ -2077,6 +2081,12 @@ function getChatSessionSummary(db, chatSessionId) {
 function saveChatSessionSummary(db, chatSessionId, summary) {
   db.prepare("UPDATE chat_session SET summary = ? WHERE id = ?").run(summary, chatSessionId);
 }
+function updateSessionOwnerId(db, ownerId) {
+  db.prepare("UPDATE meta SET owner_id = ?").run(ownerId);
+}
+function renameSession(db, newName) {
+  db.prepare("UPDATE meta SET name = ?").run(newName);
+}
 function clearSessionIndex(db) {
   db.exec("DELETE FROM message_context");
   db.exec("DELETE FROM chat_session");
@@ -2191,6 +2201,26 @@ function generateIncrementalSessionIndex(db, gapThreshold = DEFAULT_SESSION_GAP_
     return newSessionCount;
   });
 }
+function getPrivateChatMemberAvatar(db, sessionName, ownerId) {
+  const members = db.prepare(
+    `SELECT
+        m.platform_id as platformId,
+        COALESCE(m.group_nickname, m.account_name, m.platform_id) as name,
+        m.avatar
+      FROM member m
+      WHERE COALESCE(m.account_name, '') != '\u7CFB\u7EDF\u6D88\u606F'
+      ORDER BY (SELECT COUNT(*) FROM message WHERE sender_id = m.id) DESC`
+  ).all();
+  if (members.length === 0) return null;
+  if (ownerId) {
+    const other = members.find((m) => m.platformId !== ownerId);
+    if (other?.avatar) return other.avatar;
+  }
+  const sameName = members.find((m) => m.name === sessionName);
+  if (sameName?.avatar) return sameName.avatar;
+  const firstWithAvatar = members.find((m) => m.avatar);
+  return firstWithAvatar?.avatar || null;
+}
 
 // ../../packages/core/src/query/message-sql.ts
 var FULL_MSG_COLUMNS = `
@@ -2455,6 +2485,29 @@ function getSchemaDetailed(db) {
     };
   });
 }
+function getMemberNameHistoryFromMessages(db, memberId) {
+  const rows = db.prepare(
+    `SELECT
+        sender_account_name as accountName,
+        sender_group_nickname as groupNickname,
+        MIN(ts) as startTs,
+        MAX(ts) as endTs
+      FROM message
+      WHERE sender_id = ?
+      GROUP BY sender_account_name, sender_group_nickname
+      ORDER BY startTs`
+  ).all(memberId);
+  const history = [];
+  for (const row of rows) {
+    if (row.accountName) {
+      history.push({ nameType: "account_name", name: row.accountName, startTs: row.startTs, endTs: row.endTs });
+    }
+    if (row.groupNickname) {
+      history.push({ nameType: "group_nickname", name: row.groupNickname, startTs: row.startTs, endTs: row.endTs });
+    }
+  }
+  return history;
+}
 function hydrateMessagesByIds(db, ids) {
   if (ids.length === 0) return [];
   const placeholders = ids.map(() => "?").join(", ");
@@ -2547,11 +2600,12 @@ function getConversationBetween(db, memberId1, memberId2, filter, limit = 100) {
   };
 }
 function getMemberNameHistory(db, memberId) {
-  if (!hasTable(db, "member_name_history")) return [];
-  return db.prepare(
+  if (!hasTable(db, "member_name_history")) return getMemberNameHistoryFromMessages(db, memberId);
+  const history = db.prepare(
     `SELECT name_type as nameType, name, start_ts as startTs, end_ts as endTs
        FROM member_name_history WHERE member_id = ? ORDER BY start_ts DESC`
   ).all(memberId);
+  return history.length > 0 ? history : getMemberNameHistoryFromMessages(db, memberId);
 }
 function getMembersWithAliases(db) {
   const aliasesAvailable = hasColumn(db, "member", "aliases");
@@ -2643,6 +2697,87 @@ function executeParameterizedSql(db, query, params = {}) {
   return stmt.all(params);
 }
 
+// ../../packages/core/src/query/member-ops.ts
+function parseAliases(raw) {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((item) => typeof item === "string" && item.trim().length > 0);
+  } catch {
+    return [];
+  }
+}
+function updateMemberAliases(db, memberId, aliases) {
+  try {
+    db.prepare("UPDATE member SET aliases = ? WHERE id = ?").run(JSON.stringify(aliases), memberId);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function mergeMembers(db, memberId1, memberId2) {
+  if (memberId1 === memberId2) return false;
+  try {
+    const rows = db.prepare(
+      `
+        SELECT
+          m.id,
+          m.platform_id as platformId,
+          m.account_name as accountName,
+          m.group_nickname as groupNickname,
+          m.aliases,
+          m.avatar,
+          COUNT(msg.id) as messageCount
+        FROM member m
+        LEFT JOIN message msg ON m.id = msg.sender_id
+        WHERE m.id IN (?, ?)
+        GROUP BY m.id
+      `
+    ).all(memberId1, memberId2);
+    if (rows.length !== 2) return false;
+    const [memberA, memberB] = rows;
+    let primary = memberA;
+    let secondary = memberB;
+    if (memberB.messageCount > memberA.messageCount || memberB.messageCount === memberA.messageCount && memberB.id < memberA.id) {
+      primary = memberB;
+      secondary = memberA;
+    }
+    const mergedAliases = Array.from(/* @__PURE__ */ new Set([...parseAliases(primary.aliases), ...parseAliases(secondary.aliases)]));
+    const mergedAccountName = primary.accountName || secondary.accountName;
+    const mergedGroupNickname = primary.groupNickname || secondary.groupNickname;
+    const mergedAvatar = primary.avatar || secondary.avatar;
+    db.transaction(() => {
+      db.prepare("UPDATE message SET sender_id = ? WHERE sender_id = ?").run(primary.id, secondary.id);
+      db.prepare("UPDATE member_name_history SET member_id = ? WHERE member_id = ?").run(primary.id, secondary.id);
+      db.prepare("UPDATE meta SET owner_id = ? WHERE owner_id = ?").run(primary.platformId, secondary.platformId);
+      db.prepare(`UPDATE member SET account_name = ?, group_nickname = ?, avatar = ?, aliases = ? WHERE id = ?`).run(
+        mergedAccountName,
+        mergedGroupNickname,
+        mergedAvatar,
+        JSON.stringify(mergedAliases),
+        primary.id
+      );
+      db.prepare("DELETE FROM member WHERE id = ?").run(secondary.id);
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function deleteMember(db, memberId) {
+  try {
+    db.transaction(() => {
+      db.prepare("DELETE FROM message WHERE sender_id = ?").run(memberId);
+      db.prepare("DELETE FROM member_name_history WHERE member_id = ?").run(memberId);
+      db.prepare("DELETE FROM member WHERE id = ?").run(memberId);
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // ../../packages/core/src/query/advanced/repeat.ts
 function getCatchphraseAnalysis(db, filter) {
   const { clause, params } = buildTimeFilter(filter);
@@ -5563,6 +5698,111 @@ function getBuiltinModelsByProvider(providerId) {
   return BUILTIN_MODELS.filter((m) => m.providerId === providerId);
 }
 
+// ../../packages/core/src/ai/content-parser.ts
+var THINK_TAGS = ["think", "analysis", "reasoning", "reflection", "thought", "thinking"];
+
+// ../../packages/core/src/ai/streaming-think-parser.ts
+var StreamingThinkTagParser = class {
+  state = "content";
+  buffer = "";
+  activeTag = "";
+  emit;
+  constructor(emit) {
+    this.emit = emit;
+  }
+  feed(text) {
+    this.buffer += text;
+    this.processBuffer();
+  }
+  /** Flush any remaining buffer (call at stream end). */
+  flush() {
+    if (!this.buffer) return;
+    if (this.state === "thinking") {
+      this.emit({ type: "thinking_delta", content: this.buffer });
+    } else {
+      this.emit({ type: "content", content: this.buffer });
+    }
+    this.buffer = "";
+  }
+  processBuffer() {
+    while (this.buffer.length > 0) {
+      const ltIdx = this.buffer.indexOf("<");
+      if (ltIdx === -1) {
+        this.emitBufferContent(this.buffer);
+        this.buffer = "";
+        return;
+      }
+      if (ltIdx > 0) {
+        this.emitBufferContent(this.buffer.slice(0, ltIdx));
+        this.buffer = this.buffer.slice(ltIdx);
+      }
+      const tagResult = this.tryMatchTag();
+      if (tagResult === "incomplete") {
+        return;
+      }
+      if (tagResult === "matched") {
+        continue;
+      }
+      this.emitBufferContent("<");
+      this.buffer = this.buffer.slice(1);
+    }
+  }
+  /**
+   * Try to match a think tag at the start of buffer.
+   * Returns: 'matched' if a tag was consumed, 'incomplete' if more data
+   * needed, 'no_match' if it's not a valid think tag.
+   */
+  tryMatchTag() {
+    if (this.state === "content") {
+      return this.tryMatchOpenTag();
+    }
+    return this.tryMatchCloseTag();
+  }
+  tryMatchOpenTag() {
+    for (const tag of THINK_TAGS) {
+      const openTag = `<${tag}>`;
+      if (this.buffer.startsWith(openTag)) {
+        this.buffer = this.buffer.slice(openTag.length);
+        this.state = "thinking";
+        this.activeTag = tag;
+        this.emit({ type: "thinking_start", tag });
+        return "matched";
+      }
+      if (openTag.startsWith(this.buffer) && this.buffer.length < openTag.length) {
+        return "incomplete";
+      }
+    }
+    return "no_match";
+  }
+  tryMatchCloseTag() {
+    const closeTag = `</${this.activeTag}>`;
+    if (this.buffer.startsWith(closeTag)) {
+      this.buffer = this.buffer.slice(closeTag.length);
+      this.state = "content";
+      this.emit({ type: "thinking_end" });
+      this.activeTag = "";
+      return "matched";
+    }
+    if (closeTag.startsWith(this.buffer) && this.buffer.length < closeTag.length) {
+      return "incomplete";
+    }
+    this.emit({ type: "thinking_delta", content: "<" });
+    this.buffer = this.buffer.slice(1);
+    return "matched";
+  }
+  emitBufferContent(text) {
+    if (!text) return;
+    if (this.state === "thinking") {
+      this.emit({ type: "thinking_delta", content: text });
+    } else {
+      this.emit({ type: "content", content: text });
+    }
+  }
+};
+function needsStreamingThinkParsing(provider, _modelId) {
+  return provider === "minimax";
+}
+
 // ../../packages/core/src/import/dedup.ts
 function fnv1a64(input) {
   let h0 = 2166136261;
@@ -5845,6 +6085,10 @@ function runMigrations(db, migrationsList, forceRepair = false) {
   return true;
 }
 
+// ../../packages/parser/src/index.ts
+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";
@@ -9476,6 +9720,32 @@ async function* parseFileWithFormat(formatId, options) {
   console.log(`[Parser V2] Using parser (explicit): ${parser9.feature.name}`);
   yield* parser9.parse(options);
 }
+function findEntryFileInDirectory(dirPath, maxDepth = 1) {
+  function walk(current, depth) {
+    if (depth > maxDepth) return null;
+    let entries;
+    try {
+      entries = fs17.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return null;
+    }
+    for (const entry of entries) {
+      const full = path13.join(current, entry.name);
+      if (entry.isFile() && entry.name.endsWith(".json")) {
+        const format = detectFormat(full);
+        if (format) return full;
+      }
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const found = walk(path13.join(current, entry.name), depth + 1);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  return walk(dirPath, 0);
+}
 async function streamParseFile(filePath, callbacks, formatId) {
   const { onProgress, onMeta, onMembers, onMessageBatch, onLog, batchSize = 5e3, formatOptions } = callbacks;
   const generator = formatId ? parseFileWithFormat(formatId, { filePath, batchSize, formatOptions, onProgress, onLog }) : parseFile({ filePath, batchSize, formatOptions, onProgress, onLog });
@@ -9500,11 +9770,11 @@ async function streamParseFile(filePath, callbacks, formatId) {
 }
 
 // ../../packages/node-runtime/src/import/streaming-importer.ts
-import * as fs19 from "fs";
+import * as fs20 from "fs";
 
 // ../../packages/node-runtime/src/nlp/segmenter.ts
-import * as fs17 from "fs";
-import * as path13 from "path";
+import * as fs18 from "fs";
+import * as path14 from "path";
 var _nlpDir = null;
 var jiebaInstances = /* @__PURE__ */ new Map();
 function initNlpDir(nlpDir) {
@@ -9515,14 +9785,14 @@ function getNlpDir() {
 }
 function existsDictOnDisk(dictId) {
   if (!_nlpDir) return false;
-  return fs17.existsSync(path13.join(_nlpDir, `${dictId}.dict`));
+  return fs18.existsSync(path14.join(_nlpDir, `${dictId}.dict`));
 }
 function tryLoadDictFromDisk(dictId) {
   if (!_nlpDir) return null;
-  const dictPath = path13.join(_nlpDir, `${dictId}.dict`);
-  if (!fs17.existsSync(dictPath)) return null;
+  const dictPath = path14.join(_nlpDir, `${dictId}.dict`);
+  if (!fs18.existsSync(dictPath)) return null;
   try {
-    return fs17.readFileSync(dictPath);
+    return fs18.readFileSync(dictPath);
   } catch {
     return null;
   }
@@ -9789,8 +10059,8 @@ function tokenizeQueryForFts(keywords) {
 }
 
 // ../../packages/node-runtime/src/nlp/dict-manager.ts
-import * as fs18 from "fs";
-import * as path14 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 = {
@@ -9802,19 +10072,19 @@ var AVAILABLE_DICTS = [
   { id: "zh-TW", label: "\u7E41\u9AD4\u4E2D\u6587", locale: "zh-TW" }
 ];
 function getDictFilePath(nlpDir, dictId) {
-  return path14.join(nlpDir, `${dictId}.dict`);
+  return path15.join(nlpDir, `${dictId}.dict`);
 }
 function isDictDownloaded(nlpDir, dictId) {
-  return fs18.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 = fs18.existsSync(filePath);
+    const downloaded = fs19.existsSync(filePath);
     let fileSize;
     if (downloaded) {
       try {
-        fileSize = fs18.statSync(filePath).size;
+        fileSize = fs19.statSync(filePath).size;
       } catch {
       }
     }
@@ -9823,9 +10093,9 @@ function getDictList(nlpDir) {
 }
 function loadDictBuffer(nlpDir, dictId) {
   const filePath = getDictFilePath(nlpDir, dictId);
-  if (!fs18.existsSync(filePath)) return null;
+  if (!fs19.existsSync(filePath)) return null;
   try {
-    return fs18.readFileSync(filePath);
+    return fs19.readFileSync(filePath);
   } catch (error) {
     console.error(`[NLP DictManager] Failed to read dict file: ${filePath}`, error);
     return null;
@@ -9835,7 +10105,7 @@ async function downloadDict(nlpDir, dictId, onProgress) {
   if (!AVAILABLE_DICTS.find((d) => d.id === dictId)) {
     return { success: false, error: `Unknown dict: ${dictId}` };
   }
-  fs18.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";
@@ -9876,16 +10146,16 @@ async function downloadDict(nlpDir, dictId, onProgress) {
     if (actualSha256 !== expectedSha256) {
       return { success: false, error: "Dictionary integrity check failed (SHA256 mismatch)" };
     }
-    fs18.writeFileSync(tmpPath, buffer);
-    if (fs18.existsSync(filePath)) fs18.unlinkSync(filePath);
-    fs18.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} (${fs18.statSync(filePath).size} bytes)`);
+    console.log(`[NLP DictManager] Dict downloaded: ${dictId} (${fs19.statSync(filePath).size} bytes)`);
     return { success: true };
   } catch (error) {
-    if (fs18.existsSync(tmpPath)) {
+    if (fs19.existsSync(tmpPath)) {
       try {
-        fs18.unlinkSync(tmpPath);
+        fs19.unlinkSync(tmpPath);
       } catch {
       }
     }
@@ -9896,9 +10166,9 @@ async function downloadDict(nlpDir, dictId, onProgress) {
 }
 function deleteDict(nlpDir, dictId) {
   const filePath = getDictFilePath(nlpDir, dictId);
-  if (!fs18.existsSync(filePath)) return { success: true };
+  if (!fs19.existsSync(filePath)) return { success: true };
   try {
-    fs18.unlinkSync(filePath);
+    fs19.unlinkSync(filePath);
     clearJiebaInstance(dictId);
     console.log(`[NLP DictManager] Dict deleted: ${dictId}`);
     return { success: true };
@@ -10447,7 +10717,7 @@ async function streamParseFileInfo(filePath, deps) {
   if (!formatFeature) {
     throw new Error("Unrecognized file format");
   }
-  const fileSize = fs19.statSync(filePath).size;
+  const fileSize = fs20.statSync(filePath).size;
   deps.onProgress({
     stage: "parsing",
     bytesRead: 0,
@@ -10536,7 +10806,7 @@ async function streamParseFileInfo(filePath, deps) {
     }
     db.close();
     try {
-      if (fs19.existsSync(tempDbPath)) fs19.unlinkSync(tempDbPath);
+      if (fs20.existsSync(tempDbPath)) fs20.unlinkSync(tempDbPath);
     } catch {
     }
     throw error;
@@ -10894,15 +11164,15 @@ async function incrementalImport(sessionId, filePath, deps, options) {
 }
 
 // ../../packages/node-runtime/src/ai/ai-logger.ts
-import * as fs20 from "fs";
-import * as path15 from "path";
+import * as fs21 from "fs";
+import * as path16 from "path";
 var AiLogger = class {
   debugMode = false;
   logDir;
   logFile = null;
   logStream = null;
   constructor(logsDir) {
-    this.logDir = path15.join(logsDir, "ai");
+    this.logDir = path16.join(logsDir, "ai");
   }
   setDebugMode(enabled) {
     this.debugMode = enabled;
@@ -10932,14 +11202,14 @@ var AiLogger = class {
     return this.getLogFilePath();
   }
   getExistingLogPath() {
-    if (this.logFile && fs20.existsSync(this.logFile)) {
+    if (this.logFile && fs21.existsSync(this.logFile)) {
       return this.logFile;
     }
     return null;
   }
   ensureLogDir() {
-    if (!fs20.existsSync(this.logDir)) {
-      fs20.mkdirSync(this.logDir, { recursive: true });
+    if (!fs21.existsSync(this.logDir)) {
+      fs21.mkdirSync(this.logDir, { recursive: true });
     }
   }
   getLogFilePath() {
@@ -10949,14 +11219,14 @@ var AiLogger = class {
     const date = now.toISOString().split("T")[0];
     const hours = String(now.getHours()).padStart(2, "0");
     const minutes = String(now.getMinutes()).padStart(2, "0");
-    this.logFile = path15.join(this.logDir, `ai_${date}_${hours}-${minutes}.log`);
+    this.logFile = path16.join(this.logDir, `ai_${date}_${hours}-${minutes}.log`);
     return this.logFile;
   }
   getLogStream() {
     if (this.logStream) return this.logStream;
     const filePath = this.getLogFilePath();
-    const isNewOrEmptyFile = !fs20.existsSync(filePath) || fs20.statSync(filePath).size === 0;
-    this.logStream = fs20.createWriteStream(filePath, { flags: "a", encoding: "utf-8" });
+    const isNewOrEmptyFile = !fs21.existsSync(filePath) || fs21.statSync(filePath).size === 0;
+    this.logStream = fs21.createWriteStream(filePath, { flags: "a", encoding: "utf-8" });
     if (isNewOrEmptyFile) {
       this.logStream.write(`Local Path:  ${filePath.replace(/ /g, "\\ ")}
 
@@ -11082,12 +11352,12 @@ ${rawErrorLabel}: ${details}`;
 }
 
 // ../../packages/node-runtime/src/ai/assistant-parser.ts
-import * as path16 from "path";
+import * as path17 from "path";
 import matter from "gray-matter";
 function parseAssistantFile(content, filePath) {
   try {
     const { data: fm, content: body } = matter(content);
-    const id = fm.id ?? path16.basename(filePath, ".md");
+    const id = fm.id ?? path17.basename(filePath, ".md");
     const name = fm.name;
     if (!name) return null;
     return {
@@ -11166,8 +11436,8 @@ var AssistantManager = class {
   }
   // ==================== Init ====================
   init() {
-    const { fs: fs38, assistantsDir } = this.deps;
-    fs38.ensureDir(assistantsDir);
+    const { fs: fs40, assistantsDir } = this.deps;
+    fs40.ensureDir(assistantsDir);
     const generalCreated = this.ensureGeneralAssistants();
     this.loadAll();
     this.initialized = true;
@@ -11178,26 +11448,26 @@ var AssistantManager = class {
     return { total: this.cache.size, generalCreated };
   }
   ensureGeneralAssistants() {
-    const { fs: fs38, assistantsDir } = this.deps;
+    const { fs: fs40, assistantsDir } = this.deps;
     let anyCreated = false;
     for (const id of this.generalIds) {
       const config = this.getBuiltinConfig(id);
       if (!config) continue;
-      const filePath = fs38.joinPath(assistantsDir, `${id}.md`);
-      if (fs38.fileExists(filePath)) continue;
-      fs38.writeFile(filePath, serializeAssistant({ ...config, builtinId: config.id }));
+      const filePath = fs40.joinPath(assistantsDir, `${id}.md`);
+      if (fs40.fileExists(filePath)) continue;
+      fs40.writeFile(filePath, serializeAssistant({ ...config, builtinId: config.id }));
       anyCreated = true;
     }
     return anyCreated;
   }
   loadAll() {
-    const { fs: fs38, assistantsDir } = this.deps;
+    const { fs: fs40, assistantsDir } = this.deps;
     this.cache.clear();
-    const files = fs38.listFiles(assistantsDir, ".md");
+    const files = fs40.listFiles(assistantsDir, ".md");
     for (const file of files) {
       try {
-        const filePath = fs38.joinPath(assistantsDir, file);
-        const content = fs38.readFile(filePath);
+        const filePath = fs40.joinPath(assistantsDir, file);
+        const content = fs40.readFile(filePath);
         const config = parseAssistantFile(content, filePath);
         if (config) {
           this.cache.set(config.id, config);
@@ -11309,12 +11579,12 @@ var AssistantManager = class {
 };
 
 // ../../packages/node-runtime/src/ai/skill-parser.ts
-import * as path17 from "path";
+import * as path18 from "path";
 import matter2 from "gray-matter";
 function parseSkillFile(content, filePath) {
   try {
     const { data: fm, content: prompt } = matter2(content);
-    const id = fm.id ?? path17.basename(filePath, ".md");
+    const id = fm.id ?? path18.basename(filePath, ".md");
     const name = fm.name;
     if (!name) return null;
     return {
@@ -11333,7 +11603,7 @@ function parseSkillFile(content, filePath) {
 function extractSkillId(content, filePath) {
   try {
     const { data: fm } = matter2(content);
-    return fm.id ?? path17.basename(filePath, ".md");
+    return fm.id ?? path18.basename(filePath, ".md");
   } catch {
     return null;
   }
@@ -11352,8 +11622,8 @@ function validateChatScope(raw) {
 
 // ../../packages/node-runtime/src/ai/conversations.ts
 import Database2 from "better-sqlite3";
-import * as fs21 from "fs";
-import * as path18 from "path";
+import * as fs22 from "fs";
+import * as path19 from "path";
 var DEFAULT_GENERAL_ID = "general_cn";
 var defaultLogger = {
   warn(_category, message, extra) {
@@ -11372,14 +11642,14 @@ var AIConversationManager = class {
     this.nativeBinding = options?.nativeBinding;
   }
   ensureDir(dir) {
-    if (!fs21.existsSync(dir)) {
-      fs21.mkdirSync(dir, { recursive: true });
+    if (!fs22.existsSync(dir)) {
+      fs22.mkdirSync(dir, { recursive: true });
     }
   }
   getDb() {
     if (this.db) return this.db;
     this.ensureDir(this.aiDataDir);
-    const dbPath = path18.join(this.aiDataDir, "conversations.db");
+    const dbPath = path19.join(this.aiDataDir, "conversations.db");
     this.db = this.nativeBinding ? new Database2(dbPath, { nativeBinding: this.nativeBinding }) : new Database2(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.exec(`
@@ -11766,8 +12036,8 @@ function countMessagesTokens(messages, systemPrompt) {
 }
 
 // ../../packages/node-runtime/src/ai/skill-manager.ts
-import * as fs22 from "fs";
-import * as path19 from "path";
+import * as fs23 from "fs";
+import * as path20 from "path";
 var SKILLS_DIR_NAME = "skills";
 var MAX_SKILL_MENU_ITEMS = 15;
 var defaultLogger2 = {
@@ -11782,7 +12052,7 @@ var SkillManager = class {
   skillsDir;
   logger;
   constructor(aiDataDir, logger) {
-    this.skillsDir = path19.join(aiDataDir, SKILLS_DIR_NAME);
+    this.skillsDir = path20.join(aiDataDir, SKILLS_DIR_NAME);
     this.logger = logger ?? defaultLogger2;
   }
   init() {
@@ -11839,12 +12109,12 @@ ${lines.join("\n")}
   }
   loadAll() {
     this.skills.clear();
-    if (!fs22.existsSync(this.skillsDir)) return;
-    const files = fs22.readdirSync(this.skillsDir).filter((f) => f.endsWith(".md"));
+    if (!fs23.existsSync(this.skillsDir)) return;
+    const files = fs23.readdirSync(this.skillsDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
       try {
-        const filePath = path19.join(this.skillsDir, file);
-        const content = fs22.readFileSync(filePath, "utf-8");
+        const filePath = path20.join(this.skillsDir, file);
+        const content = fs23.readFileSync(filePath, "utf-8");
         const def = parseSkillFile(content, filePath);
         if (def) {
           this.skills.set(def.id, def);
@@ -11911,21 +12181,21 @@ var SkillManagerCore = class {
   }
   // ==================== Init ====================
   init() {
-    const { fs: fs38, skillsDir } = this.deps;
-    fs38.ensureDir(skillsDir);
+    const { fs: fs40, skillsDir } = this.deps;
+    fs40.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: fs38, skillsDir } = this.deps;
+    const { fs: fs40, skillsDir } = this.deps;
     this.cache.clear();
-    const files = fs38.listFiles(skillsDir, ".md");
+    const files = fs40.listFiles(skillsDir, ".md");
     for (const file of files) {
       try {
-        const filePath = fs38.joinPath(skillsDir, file);
-        const content = fs38.readFile(filePath);
+        const filePath = fs40.joinPath(skillsDir, file);
+        const content = fs40.readFile(filePath);
         const def = parseSkillFile(content, filePath);
         if (def) {
           this.cache.set(def.id, def);
@@ -12986,11 +13256,37 @@ async function runAgentCore(options) {
   coreAgent.replaceMessages(toPiHistoryMessages(history));
   let hasReachedToolRoundLimit = false;
   const thinkingStartTime = /* @__PURE__ */ new Map();
+  const useThinkParser = needsStreamingThinkParsing(piModel.provider, piModel.id);
+  let thinkParserStartTime;
+  const thinkParser = useThinkParser ? new StreamingThinkTagParser((ev) => {
+    switch (ev.type) {
+      case "content":
+        onEvent({ type: "content", content: ev.content });
+        break;
+      case "thinking_start":
+        thinkParserStartTime = Date.now();
+        onEvent({ type: "thinking_start" });
+        break;
+      case "thinking_delta":
+        onEvent({ type: "thinking_delta", content: ev.content });
+        break;
+      case "thinking_end": {
+        const durationMs = thinkParserStartTime ? Date.now() - thinkParserStartTime : void 0;
+        thinkParserStartTime = void 0;
+        onEvent({ type: "thinking_end", durationMs });
+        break;
+      }
+    }
+  }) : null;
   const unsubscribe = coreAgent.subscribe((event) => {
     if (event.type === "message_update") {
       const update = event.assistantMessageEvent;
       if (update.type === "text_delta") {
-        onEvent({ type: "content", content: update.delta });
+        if (thinkParser) {
+          thinkParser.feed(update.delta);
+        } else {
+          onEvent({ type: "content", content: update.delta });
+        }
       } else if (update.type === "thinking_start") {
         thinkingStartTime.set(update.contentIndex, Date.now());
         onEvent({ type: "thinking_start" });
@@ -13028,6 +13324,7 @@ async function runAgentCore(options) {
       onEvent({ type: "turn_end", round: toolRounds, hadToolCalls });
     } else if (event.type === "message_end") {
       if (event.message.role === "assistant") {
+        thinkParser?.flush();
         addPiUsage(event.message.usage);
         onEvent({ type: "usage_update", usage: { ...totalUsage } });
       }
@@ -14577,9 +14874,9 @@ var localeMap = {
   "ja-JP": ja_JP_default,
   "zh-TW": zh_TW_default
 };
-function getNestedValue(obj, path36) {
+function getNestedValue(obj, path37) {
   let current = obj;
-  for (const segment2 of path36.split(".")) {
+  for (const segment2 of path37.split(".")) {
     if (current == null || typeof current !== "object") return void 0;
     current = current[segment2];
   }
@@ -15290,8 +15587,8 @@ async function runSimpleLlmStream(options) {
 import { Type, completeSimple as completeSimple4, streamSimple as streamSimple2 } from "@mariozechner/pi-ai";
 
 // ../../packages/node-runtime/src/ai/rag/config.ts
-import * as fs23 from "fs";
-import * as path20 from "path";
+import * as fs24 from "fs";
+import * as path21 from "path";
 import { randomUUID } from "crypto";
 
 // ../../packages/node-runtime/src/ai/rag/types.ts
@@ -15339,25 +15636,25 @@ function requireAiDataDir() {
   return _aiDataDir;
 }
 function getConfigPath() {
-  return path20.join(requireAiDataDir(), "rag-config.json");
+  return path21.join(requireAiDataDir(), "rag-config.json");
 }
 function getEmbeddingConfigPath() {
-  return path20.join(requireAiDataDir(), "embedding-config.json");
+  return path21.join(requireAiDataDir(), "embedding-config.json");
 }
 function getVectorStoreDir() {
-  const dir = path20.join(requireAiDataDir(), "vectors");
-  if (!fs23.existsSync(dir)) {
-    fs23.mkdirSync(dir, { recursive: true });
+  const dir = path21.join(requireAiDataDir(), "vectors");
+  if (!fs24.existsSync(dir)) {
+    fs24.mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
 function loadEmbeddingConfigStore() {
   const configPath = getEmbeddingConfigPath();
-  if (!fs23.existsSync(configPath)) {
+  if (!fs24.existsSync(configPath)) {
     return { ...DEFAULT_EMBEDDING_CONFIG_STORE };
   }
   try {
-    const content = fs23.readFileSync(configPath, "utf-8");
+    const content = fs24.readFileSync(configPath, "utf-8");
     const data = JSON.parse(content);
     return {
       configs: data.configs || [],
@@ -15371,11 +15668,11 @@ function loadEmbeddingConfigStore() {
 }
 function saveEmbeddingConfigStore(store) {
   const configPath = getEmbeddingConfigPath();
-  const dir = path20.dirname(configPath);
-  if (!fs23.existsSync(dir)) {
-    fs23.mkdirSync(dir, { recursive: true });
+  const dir = path21.dirname(configPath);
+  if (!fs24.existsSync(dir)) {
+    fs24.mkdirSync(dir, { recursive: true });
   }
-  fs23.writeFileSync(configPath, JSON.stringify(store, null, 2), "utf-8");
+  fs24.writeFileSync(configPath, JSON.stringify(store, null, 2), "utf-8");
   _logger.info("RAG", "Embedding configs saved");
 }
 function getAllEmbeddingConfigs() {
@@ -15461,10 +15758,10 @@ function getActiveEmbeddingConfigId() {
 function loadRAGConfig() {
   try {
     const configPath = getConfigPath();
-    if (!fs23.existsSync(configPath)) {
+    if (!fs24.existsSync(configPath)) {
       return { ...DEFAULT_RAG_CONFIG };
     }
-    const content = fs23.readFileSync(configPath, "utf-8");
+    const content = fs24.readFileSync(configPath, "utf-8");
     const config = JSON.parse(content);
     return mergeConfig(DEFAULT_RAG_CONFIG, config);
   } catch (error) {
@@ -15475,11 +15772,11 @@ function loadRAGConfig() {
 function saveRAGConfig(config) {
   try {
     const configPath = getConfigPath();
-    const dir = path20.dirname(configPath);
-    if (!fs23.existsSync(dir)) {
-      fs23.mkdirSync(dir, { recursive: true });
+    const dir = path21.dirname(configPath);
+    if (!fs24.existsSync(dir)) {
+      fs24.mkdirSync(dir, { recursive: true });
     }
-    fs23.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+    fs24.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
     _logger.info("RAG", "Configs saved");
   } catch (error) {
     _logger.error("RAG", "Failed to save configs", error);
@@ -15979,7 +16276,7 @@ async function validateEmbeddingConfig(config) {
 }
 
 // ../../packages/node-runtime/src/ai/rag/store/index.ts
-import * as path21 from "path";
+import * as path22 from "path";
 
 // ../../packages/node-runtime/src/ai/rag/store/sqlite.ts
 import Database4 from "better-sqlite3";
@@ -16096,8 +16393,8 @@ var SQLiteVectorStore = class {
     const dimRow = this.db.prepare("SELECT dimensions FROM vectors LIMIT 1").get();
     let sizeBytes;
     try {
-      const fs38 = await import("fs");
-      const stats = fs38.statSync(this.dbPath);
+      const fs40 = await import("fs");
+      const stats = fs40.statSync(this.dbPath);
       sizeBytes = stats.size;
     } catch {
     }
@@ -16294,7 +16591,7 @@ async function createVectorStore(config) {
       return new MemoryVectorStore(capacity);
     }
     case "sqlite": {
-      const dbPath = config.dbPath || path21.join(getVectorStoreDir(), "embeddings.db");
+      const dbPath = config.dbPath || path22.join(getVectorStoreDir(), "embeddings.db");
       _logger7.info("Store Manager", `Using SQLite store: ${dbPath}`);
       return new SQLiteVectorStore(dbPath);
     }
@@ -16508,14 +16805,14 @@ function initRag(options) {
 }
 
 // ../../packages/node-runtime/src/node-path-provider.ts
-import * as fs33 from "fs";
+import * as fs34 from "fs";
 import * as os5 from "os";
-import * as path31 from "path";
+import * as path32 from "path";
 
 // ../../packages/config/src/loader.ts
-import * as fs24 from "fs";
+import * as fs25 from "fs";
 import * as os2 from "os";
-import * as path22 from "path";
+import * as path23 from "path";
 import { parse as parseToml } from "smol-toml";
 
 // ../../packages/config/src/schema.ts
@@ -16550,9 +16847,9 @@ var configSchema = z.object({
 });
 
 // ../../packages/config/src/loader.ts
-var CONFIG_DIR = path22.join(os2.homedir(), ".chatlab");
-var CONFIG_TOML = path22.join(CONFIG_DIR, "config.toml");
-var CONFIG_JSON = path22.join(CONFIG_DIR, "config.json");
+var CONFIG_DIR = path23.join(os2.homedir(), ".chatlab");
+var CONFIG_TOML = path23.join(CONFIG_DIR, "config.toml");
+var CONFIG_JSON = path23.join(CONFIG_DIR, "config.json");
 function loadConfig(overrides) {
   const fileConfig = loadConfigFile();
   const envConfig = loadEnvConfig();
@@ -16560,25 +16857,25 @@ function loadConfig(overrides) {
   return configSchema.parse(merged);
 }
 function getConfigPath2() {
-  if (fs24.existsSync(CONFIG_TOML)) return CONFIG_TOML;
-  if (fs24.existsSync(CONFIG_JSON)) return CONFIG_JSON;
+  if (fs25.existsSync(CONFIG_TOML)) return CONFIG_TOML;
+  if (fs25.existsSync(CONFIG_JSON)) return CONFIG_JSON;
   return CONFIG_TOML;
 }
 function getConfigDir() {
   return CONFIG_DIR;
 }
 function loadConfigFile() {
-  if (fs24.existsSync(CONFIG_TOML)) {
+  if (fs25.existsSync(CONFIG_TOML)) {
     try {
-      const content = fs24.readFileSync(CONFIG_TOML, "utf-8");
+      const content = fs25.readFileSync(CONFIG_TOML, "utf-8");
       return parseToml(content);
     } catch (err) {
       console.warn(`[Config] Failed to parse ${CONFIG_TOML}:`, err);
     }
   }
-  if (fs24.existsSync(CONFIG_JSON)) {
+  if (fs25.existsSync(CONFIG_JSON)) {
     try {
-      const content = fs24.readFileSync(CONFIG_JSON, "utf-8");
+      const content = fs25.readFileSync(CONFIG_JSON, "utf-8");
       return JSON.parse(content);
     } catch (err) {
       console.warn(`[Config] Failed to parse ${CONFIG_JSON}:`, err);
@@ -16607,13 +16904,13 @@ function loadEnvConfig() {
   return result;
 }
 function writeConfigField(section, key, value) {
-  if (!fs24.existsSync(CONFIG_DIR)) {
-    fs24.mkdirSync(CONFIG_DIR, { recursive: true });
+  if (!fs25.existsSync(CONFIG_DIR)) {
+    fs25.mkdirSync(CONFIG_DIR, { recursive: true });
   }
   let existing = {};
-  if (fs24.existsSync(CONFIG_TOML)) {
+  if (fs25.existsSync(CONFIG_TOML)) {
     try {
-      const content = fs24.readFileSync(CONFIG_TOML, "utf-8");
+      const content = fs25.readFileSync(CONFIG_TOML, "utf-8");
       existing = parseToml(content);
     } catch {
     }
@@ -16635,7 +16932,7 @@ function writeConfigField(section, key, value) {
     }
     lines.push("");
   }
-  fs24.writeFileSync(CONFIG_TOML, lines.join("\n"), "utf-8");
+  fs25.writeFileSync(CONFIG_TOML, lines.join("\n"), "utf-8");
 }
 function deepMerge(base, override) {
   const result = { ...base };
@@ -16650,19 +16947,19 @@ function deepMerge(base, override) {
 }
 
 // ../../packages/config/src/auth-profiles.ts
-import * as fs25 from "fs";
-import * as path23 from "path";
+import * as fs26 from "fs";
+import * as path24 from "path";
 var AUTH_PROFILES_FILE = "auth-profiles.json";
 function getAuthProfilesPath() {
-  return path23.join(getConfigDir(), AUTH_PROFILES_FILE);
+  return path24.join(getConfigDir(), AUTH_PROFILES_FILE);
 }
 function loadAuthProfiles() {
   const filePath = getAuthProfilesPath();
-  if (!fs25.existsSync(filePath)) {
+  if (!fs26.existsSync(filePath)) {
     return { version: 1, profiles: {} };
   }
   try {
-    const content = fs25.readFileSync(filePath, "utf-8");
+    const content = fs26.readFileSync(filePath, "utf-8");
     const data = JSON.parse(content);
     if (!data.profiles || typeof data.profiles !== "object") {
       return { version: 1, profiles: {} };
@@ -16695,18 +16992,18 @@ function resolveApiKey(provider, authProfile) {
 }
 function writeAuthProfile(name, profile) {
   const configDir = getConfigDir();
-  if (!fs25.existsSync(configDir)) {
-    fs25.mkdirSync(configDir, { recursive: true });
+  if (!fs26.existsSync(configDir)) {
+    fs26.mkdirSync(configDir, { recursive: true });
   }
   const data = loadAuthProfiles();
   data.profiles[name] = profile;
   const filePath = getAuthProfilesPath();
-  fs25.writeFileSync(filePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+  fs26.writeFileSync(filePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
 }
 
 // ../../packages/config/src/migrations/runner.ts
-import * as fs26 from "fs";
-import * as path24 from "path";
+import * as fs27 from "fs";
+import * as path25 from "path";
 var VERSION_FILE = ".migration-version";
 var MigrationRunner = class {
   migrations;
@@ -16716,10 +17013,10 @@ var MigrationRunner = class {
     this.context = context;
   }
   getCurrentVersion() {
-    const versionPath = path24.join(this.context.dataDir, VERSION_FILE);
+    const versionPath = path25.join(this.context.dataDir, VERSION_FILE);
     try {
-      if (fs26.existsSync(versionPath)) {
-        const raw = fs26.readFileSync(versionPath, "utf-8").trim();
+      if (fs27.existsSync(versionPath)) {
+        const raw = fs27.readFileSync(versionPath, "utf-8").trim();
         const ver = parseInt(raw, 10);
         return Number.isFinite(ver) ? ver : 0;
       }
@@ -16728,12 +17025,12 @@ var MigrationRunner = class {
     return 0;
   }
   writeVersion(version) {
-    const versionPath = path24.join(this.context.dataDir, VERSION_FILE);
+    const versionPath = path25.join(this.context.dataDir, VERSION_FILE);
     try {
-      if (!fs26.existsSync(this.context.dataDir)) {
-        fs26.mkdirSync(this.context.dataDir, { recursive: true });
+      if (!fs27.existsSync(this.context.dataDir)) {
+        fs27.mkdirSync(this.context.dataDir, { recursive: true });
       }
-      fs26.writeFileSync(versionPath, String(version), "utf-8");
+      fs27.writeFileSync(versionPath, String(version), "utf-8");
     } catch (err) {
       this.context.logger.error("Migration", `Failed to write version file: ${err}`);
     }
@@ -16765,8 +17062,8 @@ var MigrationRunner = class {
 };
 
 // ../../packages/config/src/migrations/m001-legacy-to-multi-config.ts
-import * as fs27 from "fs";
-import * as path25 from "path";
+import * as fs28 from "fs";
+import * as path26 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function isLegacyFlatConfig(data) {
   if (!data || typeof data !== "object") return false;
@@ -16778,9 +17075,9 @@ var m001LegacyToMultiConfig = {
   name: "legacy-to-multi-config",
   description: "Convert legacy flat LLM config to multi-config format",
   async up(ctx) {
-    const configPath = path25.join(ctx.aiDataDir, "llm-config.json");
-    if (!fs27.existsSync(configPath)) return;
-    const raw = fs27.readFileSync(configPath, "utf-8");
+    const configPath = path26.join(ctx.aiDataDir, "llm-config.json");
+    if (!fs28.existsSync(configPath)) return;
+    const raw = fs28.readFileSync(configPath, "utf-8");
     let data;
     try {
       data = JSON.parse(raw);
@@ -16806,24 +17103,24 @@ var m001LegacyToMultiConfig = {
       defaultAssistant: { configId: newConfig.id, modelId: newConfig.model },
       fastModel: null
     };
-    fs27.writeFileSync(configPath, JSON.stringify(migrated, null, 2), "utf-8");
+    fs28.writeFileSync(configPath, JSON.stringify(migrated, null, 2), "utf-8");
     ctx.logger.info("Migration", "Legacy config migrated to multi-config format");
   }
 };
 
 // ../../packages/config/src/migrations/m002-schema-v2.ts
-import * as fs28 from "fs";
-import * as path26 from "path";
+import * as fs29 from "fs";
+import * as path27 from "path";
 var m002SchemaV2 = {
   version: 2,
   name: "schema-v2",
   description: "Upgrade LLM config to schema v2 (remove deprecated fields)",
   async up(ctx) {
-    const configPath = path26.join(ctx.aiDataDir, "llm-config.json");
-    if (!fs28.existsSync(configPath)) return;
+    const configPath = path27.join(ctx.aiDataDir, "llm-config.json");
+    if (!fs29.existsSync(configPath)) return;
     let data;
     try {
-      data = JSON.parse(fs28.readFileSync(configPath, "utf-8"));
+      data = JSON.parse(fs29.readFileSync(configPath, "utf-8"));
     } catch {
       return;
     }
@@ -16837,23 +17134,23 @@ var m002SchemaV2 = {
     });
     data.configs = cleanedConfigs;
     data.schemaVersion = 2;
-    fs28.writeFileSync(configPath, JSON.stringify(data, null, 2), "utf-8");
+    fs29.writeFileSync(configPath, JSON.stringify(data, null, 2), "utf-8");
   }
 };
 
 // ../../packages/config/src/migrations/m003-schema-v3.ts
-import * as fs29 from "fs";
-import * as path27 from "path";
+import * as fs30 from "fs";
+import * as path28 from "path";
 var m003SchemaV3 = {
   version: 3,
   name: "schema-v3-dual-slot",
   description: "Upgrade LLM config to schema v3 (dual-slot model selection)",
   async up(ctx) {
-    const configPath = path27.join(ctx.aiDataDir, "llm-config.json");
-    if (!fs29.existsSync(configPath)) return;
+    const configPath = path28.join(ctx.aiDataDir, "llm-config.json");
+    if (!fs30.existsSync(configPath)) return;
     let data;
     try {
-      data = JSON.parse(fs29.readFileSync(configPath, "utf-8"));
+      data = JSON.parse(fs30.readFileSync(configPath, "utf-8"));
     } catch {
       return;
     }
@@ -16867,18 +17164,18 @@ var m003SchemaV3 = {
     data.fastModel = data.fastModel ?? null;
     data.schemaVersion = 3;
     delete data.activeConfigId;
-    fs29.writeFileSync(configPath, JSON.stringify(data, null, 2), "utf-8");
+    fs30.writeFileSync(configPath, JSON.stringify(data, null, 2), "utf-8");
   }
 };
 
 // ../../packages/config/src/migrations/m004-encrypted-keys-to-auth-profiles.ts
-import * as fs31 from "fs";
-import * as path29 from "path";
+import * as fs32 from "fs";
+import * as path30 from "path";
 
 // ../../packages/config/src/migrations/crypto-legacy.ts
-import * as fs30 from "fs";
+import * as fs31 from "fs";
 import * as os3 from "os";
-import * as path28 from "path";
+import * as path29 from "path";
 import { createDecipheriv, createHash as createHash2 } from "crypto";
 import { execSync } from "child_process";
 var ENCRYPTED_PREFIX = "enc:";
@@ -16890,8 +17187,8 @@ function isEncrypted(value) {
 }
 function readKeyFromFile(keyPath) {
   try {
-    if (fs30.existsSync(keyPath)) {
-      const key = fs30.readFileSync(keyPath, "utf-8").trim();
+    if (fs31.existsSync(keyPath)) {
+      const key = fs31.readFileSync(keyPath, "utf-8").trim();
       if (key.length >= 32) return key;
     }
   } catch {
@@ -16900,14 +17197,14 @@ function readKeyFromFile(keyPath) {
 }
 function getAllDeviceKeyPaths() {
   const home = os3.homedir();
-  const paths = [path28.join(home, ".chatlab", DEVICE_KEY_FILE)];
+  const paths = [path29.join(home, ".chatlab", DEVICE_KEY_FILE)];
   if (process.platform === "darwin") {
-    paths.push(path28.join(home, "Library", "Application Support", "ChatLab", "data", DEVICE_KEY_FILE));
+    paths.push(path29.join(home, "Library", "Application Support", "ChatLab", "data", DEVICE_KEY_FILE));
   } else if (process.platform === "win32") {
-    const appData = process.env.APPDATA || path28.join(home, "AppData", "Roaming");
-    paths.push(path28.join(appData, "ChatLab", "data", DEVICE_KEY_FILE));
+    const appData = process.env.APPDATA || path29.join(home, "AppData", "Roaming");
+    paths.push(path29.join(appData, "ChatLab", "data", DEVICE_KEY_FILE));
   } else {
-    paths.push(path28.join(home, ".config", "ChatLab", "data", DEVICE_KEY_FILE));
+    paths.push(path29.join(home, ".config", "ChatLab", "data", DEVICE_KEY_FILE));
   }
   return paths;
 }
@@ -17009,11 +17306,11 @@ var m004EncryptedKeysToAuthProfiles = {
   name: "encrypted-keys-to-auth-profiles",
   description: "Migrate encrypted API keys from llm-config.json to auth-profiles.json",
   async up(ctx) {
-    const configPath = path29.join(ctx.aiDataDir, "llm-config.json");
-    if (!fs31.existsSync(configPath)) return;
+    const configPath = path30.join(ctx.aiDataDir, "llm-config.json");
+    if (!fs32.existsSync(configPath)) return;
     let data;
     try {
-      data = JSON.parse(fs31.readFileSync(configPath, "utf-8"));
+      data = JSON.parse(fs32.readFileSync(configPath, "utf-8"));
     } catch {
       return;
     }
@@ -17050,7 +17347,7 @@ var m004EncryptedKeysToAuthProfiles = {
       }
     }
     if (migrated) {
-      fs31.writeFileSync(configPath, JSON.stringify(data, null, 2), "utf-8");
+      fs32.writeFileSync(configPath, JSON.stringify(data, null, 2), "utf-8");
       ctx.logger.info("Migration", "Cleared API keys from llm-config.json");
     }
   }
@@ -17065,29 +17362,29 @@ var ALL_MIGRATIONS = [
 ];
 
 // ../../packages/node-runtime/src/migrations/electron-data-migration.ts
-import * as fs32 from "fs";
+import * as fs33 from "fs";
 import * as os4 from "os";
-import * as path30 from "path";
+import * as path31 from "path";
 var SYSTEM_SUBDIRS = ["ai", "settings", "cache", "logs", "temp", "nlp"];
 var STORAGE_CONFIG_FILE = "storage.json";
 function getElectronUserDataDir() {
   const home = os4.homedir();
   switch (process.platform) {
     case "darwin":
-      return path30.join(home, "Library", "Application Support", "ChatLab");
+      return path31.join(home, "Library", "Application Support", "ChatLab");
     case "win32": {
-      const appData = process.env.APPDATA || path30.join(home, "AppData", "Roaming");
-      return path30.join(appData, "ChatLab");
+      const appData = process.env.APPDATA || path31.join(home, "AppData", "Roaming");
+      return path31.join(appData, "ChatLab");
     }
     default:
-      return path30.join(home, ".config", "ChatLab");
+      return path31.join(home, ".config", "ChatLab");
   }
 }
 function readElectronStorageConfig(electronUserData) {
-  const configPath = path30.join(electronUserData, STORAGE_CONFIG_FILE);
-  if (!fs32.existsSync(configPath)) return {};
+  const configPath = path31.join(electronUserData, STORAGE_CONFIG_FILE);
+  if (!fs33.existsSync(configPath)) return {};
   try {
-    return JSON.parse(fs32.readFileSync(configPath, "utf-8"));
+    return JSON.parse(fs33.readFileSync(configPath, "utf-8"));
   } catch {
     return {};
   }
@@ -17095,45 +17392,45 @@ function readElectronStorageConfig(electronUserData) {
 function resolveElectronDataDir() {
   const electronUserData = getElectronUserDataDir();
   const storageConfig = readElectronStorageConfig(electronUserData);
-  if (storageConfig.dataDir && path30.isAbsolute(storageConfig.dataDir)) {
+  if (storageConfig.dataDir && path31.isAbsolute(storageConfig.dataDir)) {
     return storageConfig.dataDir;
   }
-  return path30.join(electronUserData, "data");
+  return path31.join(electronUserData, "data");
 }
 function hasDatabases(dir) {
-  const dbDir = path30.join(dir, "databases");
-  if (!fs32.existsSync(dbDir)) return false;
+  const dbDir = path31.join(dir, "databases");
+  if (!fs33.existsSync(dbDir)) return false;
   try {
-    return fs32.readdirSync(dbDir).some((f) => f.endsWith(".db"));
+    return fs33.readdirSync(dbDir).some((f) => f.endsWith(".db"));
   } catch {
     return false;
   }
 }
 function ensureDir2(dirPath) {
-  if (!fs32.existsSync(dirPath)) {
-    fs32.mkdirSync(dirPath, { recursive: true });
+  if (!fs33.existsSync(dirPath)) {
+    fs33.mkdirSync(dirPath, { recursive: true });
   }
 }
 function copyDirMerge(src, dest) {
   const stats = { copied: 0, skipped: 0 };
-  if (!fs32.existsSync(src)) return stats;
+  if (!fs33.existsSync(src)) return stats;
   ensureDir2(dest);
   let entries;
   try {
-    entries = fs32.readdirSync(src, { withFileTypes: true });
+    entries = fs33.readdirSync(src, { withFileTypes: true });
   } catch {
     return stats;
   }
   for (const entry of entries) {
-    const srcPath = path30.join(src, entry.name);
-    const destPath = path30.join(dest, entry.name);
+    const srcPath = path31.join(src, entry.name);
+    const destPath = path31.join(dest, entry.name);
     try {
       if (entry.isDirectory()) {
         const sub = copyDirMerge(srcPath, destPath);
         stats.copied += sub.copied;
         stats.skipped += sub.skipped;
-      } else if (!fs32.existsSync(destPath)) {
-        fs32.copyFileSync(srcPath, destPath);
+      } else if (!fs33.existsSync(destPath)) {
+        fs33.copyFileSync(srcPath, destPath);
         stats.copied++;
       } else {
         stats.skipped++;
@@ -17146,22 +17443,22 @@ function copyDirMerge(src, dest) {
 function writeMigrationLog(logDir, message) {
   try {
     ensureDir2(logDir);
-    const logPath = path30.join(logDir, "app.log");
+    const logPath = path31.join(logDir, "app.log");
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
-    fs32.appendFileSync(logPath, `[${ts}] [MIGRATION] ${message}
+    fs33.appendFileSync(logPath, `[${ts}] [MIGRATION] ${message}
 `, "utf-8");
   } catch {
   }
 }
 function wasElectronUsed() {
   const electronUserData = getElectronUserDataDir();
-  if (!fs32.existsSync(electronUserData)) return false;
-  return fs32.existsSync(path30.join(electronUserData, "Preferences")) || fs32.existsSync(path30.join(electronUserData, "Local Storage")) || fs32.existsSync(path30.join(electronUserData, "Session Storage")) || fs32.existsSync(path30.join(electronUserData, "data"));
+  if (!fs33.existsSync(electronUserData)) return false;
+  return fs33.existsSync(path31.join(electronUserData, "Preferences")) || fs33.existsSync(path31.join(electronUserData, "Local Storage")) || fs33.existsSync(path31.join(electronUserData, "Session Storage")) || fs33.existsSync(path31.join(electronUserData, "data"));
 }
 function verifyCliDataPath(databaseDir) {
-  if (fs32.existsSync(databaseDir)) {
+  if (fs33.existsSync(databaseDir)) {
     try {
-      if (fs32.readdirSync(databaseDir).some((f) => f.endsWith(".db"))) return true;
+      if (fs33.readdirSync(databaseDir).some((f) => f.endsWith(".db"))) return true;
     } catch {
     }
   }
@@ -17179,9 +17476,9 @@ function migrateFromElectronIfNeeded(systemDir) {
     let totalSkipped = 0;
     const movedDirs = [];
     for (const subDir of SYSTEM_SUBDIRS) {
-      const srcDir = path30.join(electronDataDir, subDir);
-      const destDir = path30.join(systemDir, subDir);
-      if (!fs32.existsSync(srcDir)) continue;
+      const srcDir = path31.join(electronDataDir, subDir);
+      const destDir = path31.join(systemDir, subDir);
+      if (!fs33.existsSync(srcDir)) continue;
       const { copied, skipped } = copyDirMerge(srcDir, destDir);
       if (copied > 0 || skipped > 0) {
         movedDirs.push(subDir);
@@ -17191,13 +17488,13 @@ function migrateFromElectronIfNeeded(systemDir) {
       }
     }
     for (const subDir of movedDirs) {
-      const srcDir = path30.join(electronDataDir, subDir);
+      const srcDir = path31.join(electronDataDir, subDir);
       try {
-        fs32.rmSync(srcDir, { recursive: true, force: true });
+        fs33.rmSync(srcDir, { recursive: true, force: true });
       } catch {
       }
     }
-    const logsDir = path30.join(systemDir, "logs");
+    const logsDir = path31.join(systemDir, "logs");
     const summary = `CLI first-run: detected Electron data at ${electronDataDir}, pointed user_data_dir there, copied ${totalCopied} system files (${movedDirs.join(", ") || "none"})`;
     writeMigrationLog(logsDir, summary);
     console.log(`[Migration] ${summary}`);
@@ -17211,7 +17508,7 @@ function migrateFromElectronIfNeeded(systemDir) {
     const errorMsg = error instanceof Error ? error.message : String(error);
     console.error("[Migration] Electron data migration failed:", errorMsg);
     try {
-      writeMigrationLog(path30.join(systemDir, "logs"), `Electron migration failed: ${errorMsg}`);
+      writeMigrationLog(path31.join(systemDir, "logs"), `Electron migration failed: ${errorMsg}`);
     } catch {
     }
     return { migrated: false, electronDetected: true, error: errorMsg };
@@ -17219,7 +17516,7 @@ function migrateFromElectronIfNeeded(systemDir) {
 }
 
 // ../../packages/node-runtime/src/node-path-provider.ts
-var SYSTEM_DIR = path31.join(os5.homedir(), ".chatlab");
+var SYSTEM_DIR = path32.join(os5.homedir(), ".chatlab");
 var _pendingElectronDataWarning = false;
 function hasPendingElectronDataWarning() {
   return _pendingElectronDataWarning;
@@ -17238,25 +17535,25 @@ var NodePathProvider = class {
     return this.userDataDir;
   }
   getDatabaseDir() {
-    return path31.join(this.userDataDir, "databases");
+    return path32.join(this.userDataDir, "databases");
   }
   getAiDataDir() {
-    return path31.join(this.systemDir, "ai");
+    return path32.join(this.systemDir, "ai");
   }
   getSettingsDir() {
-    return path31.join(this.systemDir, "settings");
+    return path32.join(this.systemDir, "settings");
   }
   getCacheDir() {
-    return path31.join(this.systemDir, "cache");
+    return path32.join(this.systemDir, "cache");
   }
   getTempDir() {
-    return path31.join(this.systemDir, "temp");
+    return path32.join(this.systemDir, "temp");
   }
   getLogsDir() {
-    return path31.join(this.systemDir, "logs");
+    return path32.join(this.systemDir, "logs");
   }
   getDownloadsDir() {
-    return path31.join(os5.homedir(), "Downloads");
+    return path32.join(os5.homedir(), "Downloads");
   }
   /**
    * 确保系统目录和用户数据目录都存在
@@ -17273,8 +17570,8 @@ var NodePathProvider = class {
       this.getLogsDir()
     ];
     for (const dir of dirs) {
-      if (!fs33.existsSync(dir)) {
-        fs33.mkdirSync(dir, { recursive: true });
+      if (!fs34.existsSync(dir)) {
+        fs34.mkdirSync(dir, { recursive: true });
       }
     }
   }
@@ -17301,18 +17598,18 @@ function resolveUserDataDir() {
   return defaultDir;
 }
 function getDefaultUserDataDir() {
-  return path31.join(os5.homedir(), ".chatlab", "data");
+  return path32.join(os5.homedir(), ".chatlab", "data");
 }
 function expandHome(filePath) {
   if (filePath.startsWith("~/") || filePath === "~") {
-    return path31.join(os5.homedir(), filePath.slice(1));
+    return path32.join(os5.homedir(), filePath.slice(1));
   }
   return filePath;
 }
 
 // ../../packages/node-runtime/src/database-manager.ts
-import * as fs34 from "fs";
-import * as path32 from "path";
+import * as fs35 from "fs";
+import * as path33 from "path";
 
 // ../../packages/node-runtime/src/migrations/chat-db-migrations.ts
 function getChatDbMigrations(deps) {
@@ -17442,7 +17739,7 @@ var DatabaseManager = class {
       return this.cache.get(sessionId);
     }
     const dbPath = this.getDbPath(sessionId);
-    if (!fs34.existsSync(dbPath)) return null;
+    if (!fs35.existsSync(dbPath)) return null;
     const adapter = openBetterSqliteDatabase(dbPath, {
       readonly: options?.readonly ?? true,
       nativeBinding: this.nativeBinding
@@ -17462,7 +17759,7 @@ var DatabaseManager = class {
       this.cache.delete(sessionId);
     }
     const dbPath = this.getDbPath(sessionId);
-    if (!fs34.existsSync(dbPath)) return null;
+    if (!fs35.existsSync(dbPath)) return null;
     const adapter = openBetterSqliteDatabase(dbPath, {
       readonly: false,
       nativeBinding: this.nativeBinding
@@ -17498,8 +17795,8 @@ var DatabaseManager = class {
    */
   listSessionIds() {
     const dbDir = this.pathProvider.getDatabaseDir();
-    if (!fs34.existsSync(dbDir)) return [];
-    return fs34.readdirSync(dbDir).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", "")).filter((id) => {
+    if (!fs35.existsSync(dbDir)) return [];
+    return fs35.readdirSync(dbDir).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", "")).filter((id) => {
       const db = this.open(id);
       if (!db) return false;
       return isChatSessionDb(db);
@@ -17509,7 +17806,7 @@ var DatabaseManager = class {
    * 获取数据库文件路径
    */
   getDbPath(sessionId) {
-    return path32.join(this.pathProvider.getDatabaseDir(), `${sessionId}.db`);
+    return path33.join(this.pathProvider.getDatabaseDir(), `${sessionId}.db`);
   }
 };
 
@@ -17787,26 +18084,26 @@ function exportSessionMode(db, params, writer, progress) {
 }
 
 // ../../packages/node-runtime/src/cache/session-cache.ts
-import * as fs35 from "fs";
-import * as path33 from "path";
+import * as fs36 from "fs";
+import * as path34 from "path";
 function getCachePath(sessionId, cacheDir) {
-  return path33.join(cacheDir, `${sessionId}.cache.json`);
+  return path34.join(cacheDir, `${sessionId}.cache.json`);
 }
 function readCacheFile(cachePath) {
   try {
-    if (!fs35.existsSync(cachePath)) return null;
-    return JSON.parse(fs35.readFileSync(cachePath, "utf-8"));
+    if (!fs36.existsSync(cachePath)) return null;
+    return JSON.parse(fs36.readFileSync(cachePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeCacheFile(cachePath, content) {
   try {
-    const dir = path33.dirname(cachePath);
-    if (!fs35.existsSync(dir)) {
-      fs35.mkdirSync(dir, { recursive: true });
+    const dir = path34.dirname(cachePath);
+    if (!fs36.existsSync(dir)) {
+      fs36.mkdirSync(dir, { recursive: true });
     }
-    fs35.writeFileSync(cachePath, JSON.stringify(content), "utf-8");
+    fs36.writeFileSync(cachePath, JSON.stringify(content), "utf-8");
   } catch {
   }
 }
@@ -17826,7 +18123,7 @@ function invalidateCache(sessionId, cacheDir, key) {
   const cachePath = getCachePath(sessionId, cacheDir);
   try {
     if (!key) {
-      if (fs35.existsSync(cachePath)) fs35.unlinkSync(cachePath);
+      if (fs36.existsSync(cachePath)) fs36.unlinkSync(cachePath);
     } else {
       const file = readCacheFile(cachePath);
       if (file && file[key]) {
@@ -17840,7 +18137,7 @@ function invalidateCache(sessionId, cacheDir, key) {
 function deleteSessionCache(sessionId, cacheDir) {
   const cachePath = getCachePath(sessionId, cacheDir);
   try {
-    if (fs35.existsSync(cachePath)) fs35.unlinkSync(cachePath);
+    if (fs36.existsSync(cachePath)) fs36.unlinkSync(cachePath);
   } catch {
   }
 }
@@ -17882,8 +18179,8 @@ function computeAndSetMembersCache(db, sessionId, cacheDir) {
 }
 
 // ../../packages/node-runtime/src/preferences.ts
-import * as fs36 from "fs";
-import * as path34 from "path";
+import * as fs37 from "fs";
+import * as path35 from "path";
 var DEFAULTS = {
   pinnedSessionIds: [],
   aiPreprocessConfig: {
@@ -17923,13 +18220,13 @@ var PreferencesManager = class {
   filePath;
   cache = null;
   constructor(systemDir) {
-    this.filePath = path34.join(systemDir, "preferences.json");
+    this.filePath = path35.join(systemDir, "preferences.json");
   }
   load() {
     if (this.cache) return this.cache;
     try {
-      if (fs36.existsSync(this.filePath)) {
-        const raw = fs36.readFileSync(this.filePath, "utf-8");
+      if (fs37.existsSync(this.filePath)) {
+        const raw = fs37.readFileSync(this.filePath, "utf-8");
         const parsed = JSON.parse(raw);
         this.cache = this.mergeDefaults(parsed);
         return this.cache;
@@ -17948,11 +18245,11 @@ var PreferencesManager = class {
         partial
       );
       this.cache = merged;
-      const dir = path34.dirname(this.filePath);
-      if (!fs36.existsSync(dir)) {
-        fs36.mkdirSync(dir, { recursive: true });
+      const dir = path35.dirname(this.filePath);
+      if (!fs37.existsSync(dir)) {
+        fs37.mkdirSync(dir, { recursive: true });
       }
-      fs36.writeFileSync(this.filePath, JSON.stringify(this.cache, null, 2), "utf-8");
+      fs37.writeFileSync(this.filePath, JSON.stringify(this.cache, null, 2), "utf-8");
       return { success: true };
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -18102,8 +18399,8 @@ function* serializeChatLabToJsonl(data) {
 }
 
 // ../../packages/node-runtime/src/merger/temp-db.ts
-import * as fs37 from "fs";
-import * as path35 from "path";
+import * as fs38 from "fs";
+import * as path36 from "path";
 var TEMP_DB_SCHEMA = `
   CREATE TABLE IF NOT EXISTS meta (
     name TEXT NOT NULL,
@@ -18348,27 +18645,277 @@ function exportSessionToJson(db) {
 }
 function deleteTempDatabase(dbPath) {
   try {
-    if (fs37.existsSync(dbPath)) fs37.unlinkSync(dbPath);
+    if (fs38.existsSync(dbPath)) fs38.unlinkSync(dbPath);
     const walPath = dbPath + "-wal";
     const shmPath = dbPath + "-shm";
-    if (fs37.existsSync(walPath)) fs37.unlinkSync(walPath);
-    if (fs37.existsSync(shmPath)) fs37.unlinkSync(shmPath);
+    if (fs38.existsSync(walPath)) fs38.unlinkSync(walPath);
+    if (fs38.existsSync(shmPath)) fs38.unlinkSync(shmPath);
   } catch {
   }
 }
 function cleanupTempDatabases(tempDir) {
   try {
-    if (!fs37.existsSync(tempDir)) return;
-    const files = fs37.readdirSync(tempDir);
+    if (!fs38.existsSync(tempDir)) return;
+    const files = fs38.readdirSync(tempDir);
     for (const file of files) {
       if (file.startsWith("merge_") && file.endsWith(".db")) {
-        deleteTempDatabase(path35.join(tempDir, file));
+        deleteTempDatabase(path36.join(tempDir, file));
       }
     }
   } catch {
   }
 }
 
+// ../../packages/node-runtime/src/services/session-service.ts
+var session_service_exports = {};
+__export(session_service_exports, {
+  deleteSession: () => deleteSession,
+  getAnalysisSession: () => getAnalysisSession,
+  listAnalysisSessions: () => listAnalysisSessions,
+  renameSession: () => renameSession2,
+  updateSessionOwnerId: () => updateSessionOwnerId2
+});
+function buildSession(db, id, dbPath, options) {
+  const meta = getSessionMeta(db);
+  if (!meta) return null;
+  const overview = options?.resolveOverview ? options.resolveOverview(db, id) : void 0;
+  const info = overview ? buildSessionInfo(meta, overview, getSummaryCount(db)) : getSessionInfo(db);
+  if (!info) return null;
+  let memberAvatar = null;
+  if (meta.type === "private") {
+    memberAvatar = getPrivateChatMemberAvatar(db, meta.name, meta.ownerId);
+  }
+  let dto = { ...info, id, dbPath, memberAvatar, aiConversationCount: 0 };
+  if (options?.enrichSession) {
+    dto = options.enrichSession(dto);
+  }
+  return dto;
+}
+function listAnalysisSessions(adapter, options) {
+  const sessionIds = adapter.listSessionIds();
+  const sessions = [];
+  for (const id of sessionIds) {
+    const db = adapter.openReadonly(id);
+    if (!db) continue;
+    if (!isChatSessionDb(db)) continue;
+    const dto = buildSession(db, id, adapter.getDbPath(id), options);
+    if (dto) sessions.push(dto);
+  }
+  return sessions.sort((a, b) => b.importedAt - a.importedAt);
+}
+function getAnalysisSession(adapter, sessionId, options) {
+  const db = adapter.openReadonly(sessionId);
+  if (!db) return null;
+  return buildSession(db, sessionId, adapter.getDbPath(sessionId), options);
+}
+function renameSession2(adapter, sessionId, name) {
+  const db = adapter.ensureWritable(sessionId);
+  renameSession(db, name);
+}
+function updateSessionOwnerId2(adapter, sessionId, ownerId) {
+  const db = adapter.ensureWritable(sessionId);
+  updateSessionOwnerId(db, ownerId);
+}
+function deleteSession(adapter, sessionId) {
+  return adapter.deleteSessionFile(sessionId);
+}
+
+// ../../packages/node-runtime/src/services/member-service.ts
+var member_service_exports = {};
+__export(member_service_exports, {
+  deleteMember: () => deleteMember2,
+  getMemberNameHistory: () => getMemberNameHistory2,
+  getMembers: () => getMembers2,
+  getMembersPaginated: () => getMembersPaginated2,
+  mergeMembers: () => mergeMembers3,
+  updateMemberAliases: () => updateMemberAliases2
+});
+function getMembers2(adapter, sessionId) {
+  const db = adapter.ensureReadonly(sessionId);
+  return getMembersWithAliases(db);
+}
+function getMembersPaginated2(adapter, sessionId, params) {
+  const db = adapter.ensureReadonly(sessionId);
+  const result = getMembersPaginated(db, params);
+  return {
+    items: result.members,
+    total: result.total,
+    page: result.page,
+    pageSize: result.pageSize,
+    totalPages: result.totalPages
+  };
+}
+function updateMemberAliases2(adapter, sessionId, memberId, aliases) {
+  const db = adapter.ensureWritable(sessionId);
+  return updateMemberAliases(db, memberId, aliases);
+}
+function mergeMembers3(adapter, sessionId, memberId1, memberId2) {
+  const db = adapter.ensureWritable(sessionId);
+  return mergeMembers(db, memberId1, memberId2);
+}
+function deleteMember2(adapter, sessionId, memberId) {
+  const db = adapter.ensureWritable(sessionId);
+  return deleteMember(db, memberId);
+}
+function getMemberNameHistory2(adapter, sessionId, memberId) {
+  const db = adapter.ensureReadonly(sessionId);
+  return getMemberNameHistory(db, memberId);
+}
+
+// ../../packages/node-runtime/src/services/session-index-service.ts
+var session_index_service_exports = {};
+__export(session_index_service_exports, {
+  clearIndex: () => clearIndex,
+  generateIncrementalIndex: () => generateIncrementalIndex,
+  generateIndex: () => generateIndex,
+  getFtsStatus: () => getFtsStatus,
+  rebuildFts: () => rebuildFts,
+  searchFts: () => searchFts
+});
+function generateIndex(adapter, sessionId, gapThreshold = 1800) {
+  const db = adapter.ensureWritable(sessionId);
+  return generateSessionIndex(db, gapThreshold);
+}
+function generateIncrementalIndex(adapter, sessionId, gapThreshold = 1800) {
+  const db = adapter.ensureWritable(sessionId);
+  return generateIncrementalSessionIndex(db, gapThreshold);
+}
+function clearIndex(adapter, sessionId) {
+  const db = adapter.ensureWritable(sessionId);
+  clearSessionIndex(db);
+}
+function getFtsStatus(adapter, sessionId) {
+  const db = adapter.ensureReadonly(sessionId);
+  return hasFtsTable(db);
+}
+function searchFts(adapter, sessionId, keywords, limit, offset) {
+  const db = adapter.ensureReadonly(sessionId);
+  return searchByFts(db, keywords, limit, offset);
+}
+function rebuildFts(adapter, sessionId) {
+  const db = adapter.ensureWritable(sessionId);
+  return rebuildFtsIndex(db);
+}
+
+// ../../packages/node-runtime/src/services/summary-service.ts
+var summary_service_exports = {};
+__export(summary_service_exports, {
+  generateAllSummaries: () => generateAllSummaries,
+  generateSummary: () => generateSummary
+});
+function buildSummaryDeps(db, llmConfig, deps) {
+  const piModel = deps.buildPiModel(llmConfig);
+  return {
+    loadMessages(chatSessionId, limit = 500) {
+      const data = getSessionMessages(db, chatSessionId, limit);
+      if (!data) return null;
+      return data.messages.map((m) => ({ senderName: m.senderName, content: m.content }));
+    },
+    saveSummary(chatSessionId, summary) {
+      saveChatSessionSummary(db, chatSessionId, summary);
+    },
+    getSummary(chatSessionId) {
+      return getChatSessionSummary(db, chatSessionId);
+    },
+    async llmComplete(systemPrompt, userPrompt, options) {
+      const result = await completeSimple4(
+        piModel,
+        {
+          systemPrompt,
+          messages: [{ role: "user", content: [{ type: "text", text: userPrompt }], timestamp: Date.now() }]
+        },
+        { apiKey: llmConfig.apiKey, maxTokens: options?.maxTokens, temperature: options?.temperature }
+      );
+      return result.content.filter((item) => item.type === "text").map((item) => item.text).join("");
+    },
+    t: (key) => key
+  };
+}
+async function generateSummary(adapter, sessionId, chatSessionId, serviceDeps, options) {
+  const llmConfig = serviceDeps.getLlmConfig();
+  if (!llmConfig) {
+    return { success: false, error: "No LLM configuration available" };
+  }
+  const db = adapter.ensureWritable(sessionId);
+  const deps = buildSummaryDeps(db, llmConfig, serviceDeps);
+  return generateSessionSummary(deps, chatSessionId, options);
+}
+async function generateAllSummaries(adapter, sessionId, serviceDeps, options) {
+  const llmConfig = serviceDeps.getLlmConfig();
+  if (!llmConfig) {
+    return { success: 0, failed: 0, total: 0, error: "No LLM configuration available" };
+  }
+  const db = adapter.ensureWritable(sessionId);
+  const chatSessions = getChatSessionList(db);
+  const deps = buildSummaryDeps(db, llmConfig, serviceDeps);
+  let success = 0;
+  let failed = 0;
+  for (const cs of chatSessions) {
+    const result = await generateSessionSummary(deps, cs.id, options);
+    if (result.success) success++;
+    else failed++;
+  }
+  return { success, failed, total: chatSessions.length };
+}
+
+// ../../packages/node-runtime/src/services/export-service.ts
+var export_service_exports = {};
+__export(export_service_exports, {
+  exportMarkdown: () => exportMarkdown
+});
+function exportMarkdown(adapter, params) {
+  const chunks = [];
+  const result = exportFilterResultToMarkdown(
+    params,
+    {
+      openDatabase(sessionId) {
+        return adapter.openReadonly(sessionId);
+      }
+    },
+    {
+      write(chunk) {
+        chunks.push(chunk);
+      },
+      end() {
+      }
+    }
+  );
+  return { result, content: chunks.join("") };
+}
+
+// ../../packages/node-runtime/src/services/adapters/database-manager-adapter.ts
+import * as fs39 from "fs";
+function createDatabaseManagerAdapter(dbManager) {
+  return {
+    listSessionIds: () => dbManager.listSessionIds(),
+    openReadonly: (sessionId) => dbManager.open(sessionId),
+    openWritable: (sessionId) => dbManager.openWritable(sessionId),
+    closeSession: (sessionId) => dbManager.close(sessionId),
+    getDbPath: (sessionId) => dbManager.getDbPath(sessionId),
+    deleteSessionFile(sessionId) {
+      dbManager.close(sessionId);
+      const dbPath = dbManager.getDbPath(sessionId);
+      if (!fs39.existsSync(dbPath)) return false;
+      fs39.unlinkSync(dbPath);
+      return true;
+    },
+    ensureReadonly(sessionId) {
+      const db = dbManager.open(sessionId);
+      if (!db) {
+        throw Object.assign(new Error(`Session not found: ${sessionId}`), { statusCode: 404 });
+      }
+      return db;
+    },
+    ensureWritable(sessionId) {
+      const db = dbManager.openWritable(sessionId);
+      if (!db) {
+        throw Object.assign(new Error(`Session not found: ${sessionId}`), { statusCode: 404 });
+      }
+      return db;
+    }
+  };
+}
+
 export {
   DEFAULT_API_PORT,
   loadConfig,
@@ -18409,10 +18956,6 @@ export {
   searchSessions,
   getSessionMessages,
   getSessionSummaries,
-  getChatSessionList,
-  getChatSessionSummary,
-  saveChatSessionSummary,
-  clearSessionIndex,
   generateSessionIndex,
   generateIncrementalSessionIndex,
   queryMessages,
@@ -18428,7 +18971,6 @@ export {
   getConversationBetween,
   getMemberNameHistory,
   getMembersWithAliases,
-  getMembersPaginated,
   executeParameterizedSql,
   getCatchphraseAnalysis,
   getMentionAnalysis,
@@ -18452,6 +18994,7 @@ export {
   getSupportedFormats,
   getFormatFeatureById,
   scanMultiChatFile,
+  findEntryFileInDirectory,
   initNlpDir,
   getNlpDir,
   getJieba,
@@ -18596,6 +19139,12 @@ export {
   TempDbReader,
   exportSessionToJson,
   deleteTempDatabase,
-  cleanupTempDatabases
+  cleanupTempDatabases,
+  session_service_exports,
+  member_service_exports,
+  session_index_service_exports,
+  summary_service_exports,
+  export_service_exports,
+  createDatabaseManagerAdapter
 };
-//# sourceMappingURL=chunk-JMRDNHIR.mjs.map
+//# sourceMappingURL=chunk-7HQWGLX6.mjs.map