chatlab-cli 0.26.1 → 0.26.3

package/dist/{chunk-AZZYKUBR.mjs → chunk-QMXNJRTT.mjs}

@@ -7,28 +7,31 @@ const __dirname = __pathDirname(__filename);
 import {
   importData,
   parseFile
-} from "./chunk-3APSMVOM.mjs";
+} from "./chunk-D5MWER7N.mjs";
 import {
   analyzeIncrementalImport,
   analyzeNewImport,
   incrementalImport,
   streamImport
-} from "./chunk-FAOZNMPK.mjs";
+} from "./chunk-VCN64OD6.mjs";
 import {
   assertCliDataDirCompatible
-} from "./chunk-MZG2GLJR.mjs";
+} from "./chunk-742TAKEP.mjs";
 import {
   getVersion
 } from "./chunk-5ADKYYNA.mjs";
+import {
+  resolveCliPath
+} from "./chunk-FJ35V3TE.mjs";
 import {
   closeServerAiLogger,
   createCliRunAgentStream,
   initServerAiLogger
-} from "./chunk-6O2SW5GL.mjs";
+} from "./chunk-GNGZHBKM.mjs";
 import {
   AGENT_TOOL_REGISTRY,
   CoreDataProvider
-} from "./chunk-FACKH2BR.mjs";
+} from "./chunk-RMITK4IC.mjs";
 import {
   AIChatManager,
   ALL_MIGRATIONS,
@@ -71,29 +74,41 @@ import {
   getAvailableYears,
   getBuiltinModelsByProvider,
   getCatchphraseAnalysis,
+  getCheckInAnalysis,
   getClusterGraph,
   getDailyActivity,
+  getDbFileVersion,
   getDefaultNodeUserDataDir,
   getDefaultRulesForLocale,
   getDictList,
+  getDivingAnalysis,
+  getDragonKingAnalysis,
   getHourlyActivity,
   getLanguagePreferenceAnalysis,
   getLaughAnalysis,
+  getLongMessageCount,
   getMemberActivity,
+  getMemberMonthlyTrend,
   getMembers,
   getMembersDetailed,
+  getMemeBattleAnalysis,
   getMentionAnalysis,
   getMentionGraph,
   getMessageLengthDistribution,
   getMessageTypeStats,
   getMonthlyActivity,
+  getNightOwlAnalysis,
+  getOrComputeAnalysisCache,
   getPendingNodeDataDirMigration,
   getRelationshipStats,
+  getRepeatAnalysis,
   getSchemaDetailed,
   getSessionInfo,
   getSessionMeta,
   getSessionOverview,
   getSupportedFormats,
+  getTextLengthPercentiles,
+  getTextStats,
   getTimeRange,
   getWeekdayActivity,
   getYearlyActivity,
@@ -104,6 +119,7 @@ import {
   loadConfig,
   member_service_exports,
   mergeRulesForLocale,
+  owner_profile_service_exports,
   queryMessages,
   resolveApiKey,
   runSimpleLlmStream,
@@ -119,13 +135,10 @@ import {
   verifyCliDataPath,
   writeAuthProfile,
   writeConfigField
-} from "./chunk-GUGKY2GV.mjs";
-import {
-  resolveCliPath
-} from "./chunk-FJ35V3TE.mjs";
+} from "./chunk-YPTJVTVJ.mjs";
 
 // src/http/index.ts
-import * as fs9 from "fs";
+import * as fs11 from "fs";
 import * as crypto4 from "crypto";
 
 // src/http/server.ts
@@ -444,14 +457,25 @@ function registerRestSessionRoutes(server2, ctx) {
 // ../../packages/http-routes/src/routes/web/sessions.ts
 function registerSessionRoutes(server2, ctx) {
   const { sessionAdapter: adapter } = ctx;
+  let preferencesInstance = null;
+  const preferences = () => {
+    preferencesInstance ??= ctx.preferencesManager ?? new PreferencesManager(ctx.pathProvider.getSystemDir());
+    return preferencesInstance;
+  };
   server2.get("/_web/sessions", async () => {
-    return session_service_exports.listAnalysisSessions(adapter);
+    const aiChatCounts = ctx.aiChatManager?.getAIChatCountsBySession();
+    return session_service_exports.listAnalysisSessions(adapter, {
+      enrichSession: aiChatCounts?.size ? (dto) => ({ ...dto, aiConversationCount: aiChatCounts.get(dto.id) ?? 0 }) : void 0
+    });
   });
   server2.get("/_web/sessions/:id", async (request) => {
     const session = session_service_exports.getAnalysisSession(adapter, request.params.id);
     if (!session) {
       throw Object.assign(new Error(`Session not found: ${request.params.id}`), { statusCode: 404 });
     }
+    if (ctx.aiChatManager) {
+      session.aiConversationCount = ctx.aiChatManager.getAIChats(request.params.id).length;
+    }
     return session;
   });
   server2.delete("/_web/sessions/:id", async (request, reply) => {
@@ -477,6 +501,24 @@ function registerSessionRoutes(server2, ctx) {
       return { success: true };
     }
   );
+  server2.post("/_web/sessions/:id/owner/apply-profile", async (request) => {
+    return owner_profile_service_exports.tryApplyOwnerProfile(adapter, preferences(), request.params.id);
+  });
+  server2.post(
+    "/_web/sessions/:id/owner/select",
+    async (request) => {
+      return owner_profile_service_exports.setOwnerAndApplyProfile(
+        adapter,
+        preferences(),
+        request.params.id,
+        request.body.ownerPlatformId
+      );
+    }
+  );
+  server2.post("/_web/sessions/:id/owner/dismiss-prompt", async (request) => {
+    owner_profile_service_exports.dismissOwnerPrompt(preferences(), request.params.id);
+    return { success: true };
+  });
 }
 
 // ../../packages/http-routes/src/routes/web/members.ts
@@ -565,6 +607,10 @@ function registerPreferencesRoutes(server2, ctx) {
   });
 }
 
+// ../../packages/http-routes/src/routes/web/analytics.ts
+import * as fs from "fs";
+import * as path2 from "path";
+
 // ../../packages/http-routes/src/helpers.ts
 function parseTimeFilter(query) {
   const { startTs, endTs, memberId } = query;
@@ -576,9 +622,32 @@ function parseTimeFilter(query) {
   return filter;
 }
 
+// ../../packages/http-routes/src/analytics-cache.ts
+import * as path from "path";
+function canonical(value) {
+  if (value === void 0) return "null";
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  const obj = value;
+  const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${canonical(obj[k])}`).join(",")}}`;
+}
+function buildAnalyticsCacheKey(namespace, params) {
+  return `${namespace}:${canonical(params)}`;
+}
+function withAnalyticsCache(ctx, sessionId, namespace, params, compute, options) {
+  const queryCacheDir = path.join(ctx.pathProvider.getCacheDir(), "query");
+  const dateStr = options?.dailyInvalidate ? `|date:${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}` : "";
+  const extraStr = options?.extraVersion ? `|${options.extraVersion}` : "";
+  const version = `${ctx.getVersion()}|${getDbFileVersion(ctx.sessionAdapter.getDbPath(sessionId))}${dateStr}${extraStr}`;
+  const key = buildAnalyticsCacheKey(namespace, params);
+  return getOrComputeAnalysisCache(sessionId, key, queryCacheDir, version, compute);
+}
+
 // ../../packages/http-routes/src/routes/web/analytics.ts
 function registerAnalyticsRoutes(server2, ctx) {
   const { sessionAdapter: adapter } = ctx;
+  const cached = (name, sessionId, params, compute, options) => withAnalyticsCache(ctx, sessionId, `analytics.${name}`, params, compute, options);
   server2.get("/_web/sessions/:id/years", async (request) => {
     const db = adapter.ensureReadonly(request.params.id);
     return getAvailableYears(db);
@@ -590,111 +659,252 @@ function registerAnalyticsRoutes(server2, ctx) {
   server2.get(
     "/_web/sessions/:id/stats/member-activity",
     async (request) => {
-      const db = adapter.ensureReadonly(request.params.id);
-      return getMemberActivity(db, parseTimeFilter(request.query));
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("member-activity", id, { ...filter }, () => getMemberActivity(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
     "/_web/sessions/:id/stats/hourly",
     async (request) => {
-      const db = adapter.ensureReadonly(request.params.id);
-      return getHourlyActivity(db, parseTimeFilter(request.query));
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("hourly", id, { ...filter }, () => getHourlyActivity(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
     "/_web/sessions/:id/stats/daily",
     async (request) => {
-      const db = adapter.ensureReadonly(request.params.id);
-      return getDailyActivity(db, parseTimeFilter(request.query));
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("daily", id, { ...filter }, () => getDailyActivity(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
     "/_web/sessions/:id/stats/weekday",
     async (request) => {
-      const db = adapter.ensureReadonly(request.params.id);
-      return getWeekdayActivity(db, parseTimeFilter(request.query));
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("weekday", id, { ...filter }, () => getWeekdayActivity(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
     "/_web/sessions/:id/stats/message-types",
     async (request) => {
-      const db = adapter.ensureReadonly(request.params.id);
-      return getMessageTypeStats(db, parseTimeFilter(request.query));
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("message-types", id, { ...filter }, () => getMessageTypeStats(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
     "/_web/sessions/:id/analytics/relationship",
     async (request) => {
-      const db = adapter.ensureReadonly(request.params.id);
-      return getRelationshipStats(db, parseTimeFilter(request.query));
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("relationship", id, { ...filter }, () => getRelationshipStats(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
     "/_web/sessions/:id/analytics/catchphrase",
     async (request) => {
-      const db = adapter.ensureReadonly(request.params.id);
-      return getCatchphraseAnalysis(db, parseTimeFilter(request.query));
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("catchphrase", id, { ...filter }, () => getCatchphraseAnalysis(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
     "/_web/sessions/:id/analytics/mention",
     async (request) => {
-      const db = adapter.ensureReadonly(request.params.id);
-      return getMentionAnalysis(db, parseTimeFilter(request.query));
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("mention", id, { ...filter }, () => getMentionAnalysis(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
     "/_web/sessions/:id/analytics/mention-graph",
     async (request) => {
-      const db = adapter.ensureReadonly(request.params.id);
-      return getMentionGraph(db, parseTimeFilter(request.query));
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("mention-graph", id, { ...filter }, () => getMentionGraph(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
     "/_web/sessions/:id/analytics/laugh",
     async (request) => {
-      const db = adapter.ensureReadonly(request.params.id);
-      return getLaughAnalysis(db, parseTimeFilter(request.query));
-    }
-  );
-  server2.get(
-    "/_web/sessions/:id/analytics/cluster",
-    async (request) => {
-      const db = adapter.ensureReadonly(request.params.id);
+      const id = request.params.id;
       const filter = parseTimeFilter(request.query);
-      const topEdges = request.query.topEdges ? parseInt(request.query.topEdges, 10) : void 0;
-      return getClusterGraph(db, filter, topEdges ? { topEdges } : void 0);
+      return cached("laugh", id, { ...filter }, () => getLaughAnalysis(adapter.ensureReadonly(id), filter));
     }
   );
+  server2.get("/_web/sessions/:id/analytics/cluster", async (request) => {
+    const id = request.params.id;
+    const filter = parseTimeFilter(request.query);
+    const options = {};
+    if (request.query.topEdges) options.topEdges = parseInt(request.query.topEdges, 10);
+    if (request.query.lookAhead) options.lookAhead = parseInt(request.query.lookAhead, 10);
+    if (request.query.decaySeconds) options.decaySeconds = parseInt(request.query.decaySeconds, 10);
+    const hasOptions = Object.keys(options).length > 0;
+    return cached(
+      "cluster",
+      id,
+      { ...filter, ...options },
+      () => getClusterGraph(adapter.ensureReadonly(id), filter, hasOptions ? options : void 0)
+    );
+  });
   server2.get(
     "/_web/sessions/:id/analytics/language-preference",
     async (request) => {
-      const db = adapter.ensureReadonly(request.params.id);
+      const id = request.params.id;
       const filter = parseTimeFilter(request.query);
       const locale = request.query.locale || "zh-CN";
-      const nlpProvider = createJiebaNlpProvider();
-      return getLanguagePreferenceAnalysis(db, { locale, timeFilter: filter, nlpProvider });
+      const zhDictPath = path2.join(ctx.pathProvider.getSystemDir(), "nlp", "zh-CN.dict");
+      let zhDictVersion;
+      try {
+        const st = fs.statSync(zhDictPath);
+        zhDictVersion = `${Math.floor(st.mtimeMs)}:${st.size}`;
+      } catch {
+        zhDictVersion = "-";
+      }
+      return cached(
+        "language-preference",
+        id,
+        { ...filter, locale },
+        () => getLanguagePreferenceAnalysis(adapter.ensureReadonly(id), {
+          locale,
+          timeFilter: filter,
+          nlpProvider: createJiebaNlpProvider()
+        }),
+        { extraVersion: `dict:${zhDictVersion}` }
+      );
     }
   );
   server2.get(
     "/_web/sessions/:id/analytics/monthly-activity",
     async (request) => {
-      const db = adapter.ensureReadonly(request.params.id);
-      return getMonthlyActivity(db, parseTimeFilter(request.query));
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("monthly-activity", id, { ...filter }, () => getMonthlyActivity(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
     "/_web/sessions/:id/analytics/yearly-activity",
     async (request) => {
-      const db = adapter.ensureReadonly(request.params.id);
-      return getYearlyActivity(db, parseTimeFilter(request.query));
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("yearly-activity", id, { ...filter }, () => getYearlyActivity(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
     "/_web/sessions/:id/analytics/message-length-distribution",
     async (request) => {
-      const db = adapter.ensureReadonly(request.params.id);
-      return getMessageLengthDistribution(db, parseTimeFilter(request.query));
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached(
+        "message-length-distribution",
+        id,
+        { ...filter },
+        () => getMessageLengthDistribution(adapter.ensureReadonly(id), filter)
+      );
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/text-stats",
+    async (request) => {
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("text-stats", id, { ...filter }, () => getTextStats(adapter.ensureReadonly(id), filter));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/long-message-count",
+    async (request) => {
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      const minLength = request.query.minLength ? parseInt(request.query.minLength, 10) : void 0;
+      return cached(
+        "long-message-count",
+        id,
+        { ...filter, minLength },
+        () => getLongMessageCount(adapter.ensureReadonly(id), filter, minLength)
+      );
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/member-monthly-trend",
+    async (request) => {
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached(
+        "member-monthly-trend",
+        id,
+        { ...filter },
+        () => getMemberMonthlyTrend(adapter.ensureReadonly(id), filter)
+      );
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/text-length-percentiles",
+    async (request) => {
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached(
+        "text-length-percentiles",
+        id,
+        { ...filter },
+        () => getTextLengthPercentiles(adapter.ensureReadonly(id), filter)
+      );
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/dragon-king",
+    async (request) => {
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("dragon-king", id, { ...filter }, () => getDragonKingAnalysis(adapter.ensureReadonly(id), filter));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/diving",
+    async (request) => {
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("diving", id, { ...filter }, () => getDivingAnalysis(adapter.ensureReadonly(id), filter), {
+        dailyInvalidate: true
+      });
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/check-in",
+    async (request) => {
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("check-in", id, { ...filter }, () => getCheckInAnalysis(adapter.ensureReadonly(id), filter));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/meme-battle",
+    async (request) => {
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("meme-battle", id, { ...filter }, () => getMemeBattleAnalysis(adapter.ensureReadonly(id), filter));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/night-owl",
+    async (request) => {
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("night-owl", id, { ...filter }, () => getNightOwlAnalysis(adapter.ensureReadonly(id), filter), {
+        dailyInvalidate: true
+      });
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/repeat",
+    async (request) => {
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("repeat", id, { ...filter }, () => getRepeatAnalysis(adapter.ensureReadonly(id), filter));
     }
   );
 }
@@ -799,9 +1009,10 @@ function registerExportRoutes(server2, ctx) {
 }
 
 // ../../packages/http-routes/src/routes/web/nlp.ts
-import * as path from "path";
+import * as fs2 from "fs";
+import * as path3 from "path";
 function registerNlpRoutes(server2, ctx) {
-  const nlpDir = path.join(ctx.pathProvider.getSystemDir(), "nlp");
+  const nlpDir = path3.join(ctx.pathProvider.getSystemDir(), "nlp");
   initNlpDir(nlpDir);
   ensureDefaultDict(nlpDir).catch((err) => console.warn("[NLP] Auto-download zh-CN dict failed:", err));
   server2.get("/_web/nlp/pos-tags", async () => {
@@ -825,7 +1036,19 @@ function registerNlpRoutes(server2, ctx) {
     if (!db) {
       throw Object.assign(new Error(`Session not found: ${params.sessionId}`), { statusCode: 404 });
     }
-    return computeWordFrequency(db, params);
+    const { sessionId, ...keyParams } = params;
+    const effectiveDictId = !params.dictType || params.dictType === "default" ? "zh-CN" : String(params.dictType);
+    const dictFilePath = path3.join(nlpDir, `${effectiveDictId}.dict`);
+    let dictVersion;
+    try {
+      const st = fs2.statSync(dictFilePath);
+      dictVersion = `${Math.floor(st.mtimeMs)}:${st.size}`;
+    } catch {
+      dictVersion = "-";
+    }
+    return withAnalyticsCache(ctx, sessionId, "nlp.word-frequency", keyParams, () => computeWordFrequency(db, params), {
+      extraVersion: `dict:${dictVersion}`
+    });
   });
   server2.post(
     "/_web/nlp/segment",
@@ -1390,9 +1613,9 @@ function registerAiSummaryRoutes(server2, ctx) {
 }
 
 // ../../packages/http-routes/src/routes/web/merge.ts
-import * as fs from "fs";
+import * as fs3 from "fs";
 import * as os from "os";
-import * as path2 from "path";
+import * as path4 from "path";
 function ensureDb2(ctx, sessionId) {
   const db = ctx.dbManager.open(sessionId);
   if (!db) throw sessionNotFound(sessionId);
@@ -1409,31 +1632,31 @@ function registerMergeRoutes(server2, ctx) {
     if (contentType.includes("multipart/form-data")) {
       const data = await request.file();
       if (!data) return reply.code(400).send({ error: "No file uploaded" });
-      const tmpDir = fs.mkdtempSync(path2.join(os.tmpdir(), "chatlab-merge-"));
-      const tmpPath = path2.join(tmpDir, data.filename || "upload");
+      const tmpDir = fs3.mkdtempSync(path4.join(os.tmpdir(), "chatlab-merge-"));
+      const tmpPath = path4.join(tmpDir, data.filename || "upload");
       const chunks = [];
       for await (const chunk of data.file) {
         chunks.push(chunk);
       }
-      fs.writeFileSync(tmpPath, Buffer.concat(chunks));
+      fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
       filePath = tmpPath;
       cleanupFile = true;
       cleanupDir = tmpDir;
     } else {
       const body = request.body;
       if (!body?.filePath) return reply.code(400).send({ error: "Missing filePath in body" });
-      if (!fs.existsSync(body.filePath)) return reply.code(400).send({ error: "File not found" });
+      if (!fs3.existsSync(body.filePath)) return reply.code(400).send({ error: "File not found" });
       filePath = body.filePath;
     }
     try {
       const result = await streamParseFileInfo(filePath, {
         createTempDatabase(sourceFilePath) {
-          return mergeCache.createTempDatabase(path2.basename(sourceFilePath));
+          return mergeCache.createTempDatabase(path4.basename(sourceFilePath));
         },
         onProgress() {
         }
       });
-      const filename = path2.basename(filePath);
+      const filename = path4.basename(filePath);
       const handle = mergeCache.store(filename, result.tempDbPath);
       return {
         handle,
@@ -1447,13 +1670,13 @@ function registerMergeRoutes(server2, ctx) {
     } finally {
       if (cleanupFile) {
         try {
-          fs.unlinkSync(filePath);
+          fs3.unlinkSync(filePath);
         } catch {
         }
       }
       if (cleanupDir) {
         try {
-          fs.rmdirSync(cleanupDir);
+          fs3.rmdirSync(cleanupDir);
         } catch {
         }
       }
@@ -1502,20 +1725,20 @@ function registerMergeRoutes(server2, ctx) {
           return reply.code(501).send({ error: "Import not available on this server" });
         }
         const jsonData = JSON.stringify(merged.chatLabData);
-        const tmpDir = fs.mkdtempSync(path2.join(os.tmpdir(), "chatlab-merged-"));
-        const safeName = path2.basename(outputName).replace(/[/\\?%*:|"<>]/g, "_") || "merged";
-        const tmpPath = path2.join(tmpDir, `${safeName}.json`);
-        fs.writeFileSync(tmpPath, jsonData, "utf-8");
+        const tmpDir = fs3.mkdtempSync(path4.join(os.tmpdir(), "chatlab-merged-"));
+        const safeName = path4.basename(outputName).replace(/[/\\?%*:|"<>]/g, "_") || "merged";
+        const tmpPath = path4.join(tmpDir, `${safeName}.json`);
+        fs3.writeFileSync(tmpPath, jsonData, "utf-8");
         try {
           const importResult = await streamImport2(dbManager2, tmpPath);
           sessionId = importResult.sessionId;
         } finally {
           try {
-            fs.unlinkSync(tmpPath);
+            fs3.unlinkSync(tmpPath);
           } catch {
           }
           try {
-            fs.rmdirSync(tmpDir);
+            fs3.rmdirSync(tmpDir);
           } catch {
           }
         }
@@ -1589,16 +1812,16 @@ function registerMergeRoutes(server2, ctx) {
 }
 
 // ../../packages/http-routes/src/routes/web/cache.ts
-import * as fs2 from "fs";
+import * as fs4 from "fs";
 import * as fsp from "fs/promises";
-import * as path3 from "path";
+import * as path5 from "path";
 async function getDirSize(dirPath) {
   let totalSize = 0;
   try {
-    if (!fs2.existsSync(dirPath)) return 0;
+    if (!fs4.existsSync(dirPath)) return 0;
     const files = await fsp.readdir(dirPath, { withFileTypes: true });
     for (const file of files) {
-      const filePath = path3.join(dirPath, file.name);
+      const filePath = path5.join(dirPath, file.name);
       if (file.isDirectory()) {
         totalSize += await getDirSize(filePath);
       } else {
@@ -1613,10 +1836,10 @@ async function getDirSize(dirPath) {
 async function getFileCount(dirPath) {
   let count = 0;
   try {
-    if (!fs2.existsSync(dirPath)) return 0;
+    if (!fs4.existsSync(dirPath)) return 0;
     const files = await fsp.readdir(dirPath, { withFileTypes: true });
     for (const file of files) {
-      const filePath = path3.join(dirPath, file.name);
+      const filePath = path5.join(dirPath, file.name);
       if (file.isDirectory()) {
         count += await getFileCount(filePath);
       } else {
@@ -1629,10 +1852,10 @@ async function getFileCount(dirPath) {
 }
 function hasChatLabDatabases(dirPath) {
   try {
-    const markerPath = path3.join(dirPath, ".chatlab");
-    const dbDir = path3.join(dirPath, "databases");
-    if (!fs2.existsSync(markerPath) || !fs2.existsSync(dbDir)) return false;
-    return fs2.readdirSync(dbDir).some((file) => file.endsWith(".db"));
+    const markerPath = path5.join(dirPath, ".chatlab");
+    const dbDir = path5.join(dirPath, "databases");
+    if (!fs4.existsSync(markerPath) || !fs4.existsSync(dbDir)) return false;
+    return fs4.readdirSync(dbDir).some((file) => file.endsWith(".db"));
   } catch {
     return false;
   }
@@ -1678,7 +1901,7 @@ function registerCacheRoutes(server2, ctx) {
     const results = await Promise.all(
       directories.map(async (dir) => {
         const [size, fileCount] = await Promise.all([getDirSize(dir.path), getFileCount(dir.path)]);
-        return { ...dir, size, fileCount, exists: fs2.existsSync(dir.path) };
+        return { ...dir, size, fileCount, exists: fs4.existsSync(dir.path) };
       })
     );
     return {
@@ -1695,10 +1918,10 @@ function registerCacheRoutes(server2, ctx) {
     };
     const dirPath = allowedDirs[cacheId];
     if (!dirPath) return { success: false, error: "Not allowed to clear this directory" };
-    if (!fs2.existsSync(dirPath)) return { success: true };
+    if (!fs4.existsSync(dirPath)) return { success: true };
     const files = await fsp.readdir(dirPath);
     for (const file of files) {
-      const filePath = path3.join(dirPath, file);
+      const filePath = path5.join(dirPath, file);
       const stat2 = await fsp.stat(filePath);
       if (stat2.isDirectory()) {
         await fsp.rm(filePath, { recursive: true });
@@ -1715,7 +1938,7 @@ function registerCacheRoutes(server2, ctx) {
       defaultPath: ctx.defaultUserDataDir,
       isCustom: ctx.isCustomDataDir ?? false,
       canSetDataDir: ctx.canSetDataDir ?? Boolean(ctx.setDataDir),
-      hasLegacyDataAtDefaultDir: Boolean(ctx.defaultUserDataDir) && path3.resolve(pp.getUserDataDir()) !== path3.resolve(ctx.defaultUserDataDir ?? "") && hasChatLabDatabases(ctx.defaultUserDataDir ?? ""),
+      hasLegacyDataAtDefaultDir: Boolean(ctx.defaultUserDataDir) && path5.resolve(pp.getUserDataDir()) !== path5.resolve(ctx.defaultUserDataDir ?? "") && hasChatLabDatabases(ctx.defaultUserDataDir ?? ""),
       pendingMigration: pending ? {
         from: pending.from,
         to: pending.to,
@@ -1732,8 +1955,8 @@ function registerCacheRoutes(server2, ctx) {
     return ctx.setDataDir(targetPath, migrate);
   });
   server2.get("/_web/cache/latest-import-log", async () => {
-    const importLogDir = path3.join(pp.getLogsDir(), "import");
-    if (!fs2.existsSync(importLogDir)) {
+    const importLogDir = path5.join(pp.getLogsDir(), "import");
+    if (!fs4.existsSync(importLogDir)) {
       return { success: false, error: "Log directory not found" };
     }
     const files = await fsp.readdir(importLogDir);
@@ -1743,7 +1966,7 @@ function registerCacheRoutes(server2, ctx) {
     }
     const fileStats = await Promise.all(
       logFiles.map(async (f) => {
-        const filePath = path3.join(importLogDir, f);
+        const filePath = path5.join(importLogDir, f);
         const stat2 = await fsp.stat(filePath);
         return { name: f, path: filePath, mtime: stat2.mtime.getTime() };
       })
@@ -1767,11 +1990,11 @@ function registerCacheRoutes(server2, ctx) {
       const base64Data = dataUrl.replace(/^data:[^,]+,/, "");
       buffer = Buffer.from(base64Data, "base64");
     }
-    if (!fs2.existsSync(downloadsDir)) {
-      fs2.mkdirSync(downloadsDir, { recursive: true });
+    if (!fs4.existsSync(downloadsDir)) {
+      fs4.mkdirSync(downloadsDir, { recursive: true });
     }
-    const filePath = path3.join(downloadsDir, filename);
-    fs2.writeFileSync(filePath, buffer);
+    const filePath = path5.join(downloadsDir, filename);
+    fs4.writeFileSync(filePath, buffer);
     return { success: true, filePath };
   });
   server2.post("/_web/cache/open-dir", async (request, reply) => {
@@ -1787,7 +2010,7 @@ function registerCacheRoutes(server2, ctx) {
     };
     const dirPath = dirPaths[cacheId];
     if (!dirPath) return { success: false, error: "Unknown directory" };
-    if (!fs2.existsSync(dirPath)) {
+    if (!fs4.existsSync(dirPath)) {
       await fsp.mkdir(dirPath, { recursive: true });
     }
     try {
@@ -1812,40 +2035,41 @@ function registerCacheRoutes(server2, ctx) {
 
 // ../../packages/http-routes/src/register.ts
 function registerSharedRoutes(server2, ctx, options) {
-  registerSystemRoutes(server2, ctx);
-  registerRestSessionRoutes(server2, ctx);
-  registerSessionRoutes(server2, ctx);
-  registerMemberRoutes(server2, ctx);
-  registerPreferencesRoutes(server2, ctx);
-  registerAnalyticsRoutes(server2, ctx);
-  registerSqlRoutes(server2, ctx);
-  registerSessionIndexRoutes(server2, ctx);
-  registerExportRoutes(server2, ctx);
-  registerNlpRoutes(server2, ctx);
+  const resolvedCtx = ctx.preferencesManager ? ctx : { ...ctx, preferencesManager: new PreferencesManager(ctx.pathProvider.getSystemDir()) };
+  registerSystemRoutes(server2, resolvedCtx);
+  registerRestSessionRoutes(server2, resolvedCtx);
+  registerSessionRoutes(server2, resolvedCtx);
+  registerMemberRoutes(server2, resolvedCtx);
+  registerPreferencesRoutes(server2, resolvedCtx);
+  registerAnalyticsRoutes(server2, resolvedCtx);
+  registerSqlRoutes(server2, resolvedCtx);
+  registerSessionIndexRoutes(server2, resolvedCtx);
+  registerExportRoutes(server2, resolvedCtx);
+  registerNlpRoutes(server2, resolvedCtx);
   if (options?.requireAi) {
     const missing = [];
-    if (!ctx.aiDataDir) missing.push("aiDataDir");
-    if (!ctx.aiChatManager) missing.push("aiChatManager");
-    if (!ctx.assistantManager) missing.push("assistantManager");
-    if (!ctx.skillManagerCore) missing.push("skillManagerCore");
-    if (!ctx.llmConfigStore) missing.push("llmConfigStore");
-    if (!ctx.customProviderStore) missing.push("customProviderStore");
-    if (!ctx.customModelStore) missing.push("customModelStore");
-    if (!ctx.runAgentStream) missing.push("runAgentStream");
+    if (!resolvedCtx.aiDataDir) missing.push("aiDataDir");
+    if (!resolvedCtx.aiChatManager) missing.push("aiChatManager");
+    if (!resolvedCtx.assistantManager) missing.push("assistantManager");
+    if (!resolvedCtx.skillManagerCore) missing.push("skillManagerCore");
+    if (!resolvedCtx.llmConfigStore) missing.push("llmConfigStore");
+    if (!resolvedCtx.customProviderStore) missing.push("customProviderStore");
+    if (!resolvedCtx.customModelStore) missing.push("customModelStore");
+    if (!resolvedCtx.runAgentStream) missing.push("runAgentStream");
     if (missing.length > 0) {
       throw new Error(`[http-routes] requireAi is set but missing AI dependencies: ${missing.join(", ")}`);
     }
   }
-  registerAiAssistantRoutes(server2, ctx);
-  registerAiSkillRoutes(server2, ctx);
-  registerAiLlmRoutes(server2, ctx);
-  registerAiLlmStreamRoutes(server2, ctx);
-  registerAiAgentStreamRoutes(server2, ctx);
-  registerAiToolRoutes(server2, ctx);
-  registerAiChatRoutes(server2, ctx);
-  registerAiSummaryRoutes(server2, ctx);
-  registerMergeRoutes(server2, ctx);
-  registerCacheRoutes(server2, ctx);
+  registerAiAssistantRoutes(server2, resolvedCtx);
+  registerAiSkillRoutes(server2, resolvedCtx);
+  registerAiLlmRoutes(server2, resolvedCtx);
+  registerAiLlmStreamRoutes(server2, resolvedCtx);
+  registerAiAgentStreamRoutes(server2, resolvedCtx);
+  registerAiToolRoutes(server2, resolvedCtx);
+  registerAiChatRoutes(server2, resolvedCtx);
+  registerAiSummaryRoutes(server2, resolvedCtx);
+  registerMergeRoutes(server2, resolvedCtx);
+  registerCacheRoutes(server2, resolvedCtx);
 }
 
 // ../../packages/http-routes/src/auth.ts
@@ -1923,19 +2147,19 @@ function createServer() {
 
 // src/http/routes/web/index.ts
 import * as os3 from "os";
-import * as path6 from "path";
+import * as path8 from "path";
 
 // src/http/routes/web/import.ts
-import * as fs4 from "fs";
+import * as fs6 from "fs";
 import * as os2 from "os";
-import * as path4 from "path";
+import * as path6 from "path";
 
 // src/http/routes/web/helpers.ts
-import * as fs3 from "fs";
+import * as fs5 from "fs";
 function resolveNativeBinding() {
   if (process.versions.electron) return void 0;
   const nativePath = resolveCliPath("native/better_sqlite3.node");
-  if (fs3.existsSync(nativePath)) return nativePath;
+  if (fs5.existsSync(nativePath)) return nativePath;
   return void 0;
 }
 
@@ -1944,11 +2168,11 @@ var DEMO_BASE_URL = "https://chatlab.fun/assets/demo";
 function cleanupTemp(...paths) {
   for (const p of paths) {
     try {
-      const stat2 = fs4.statSync(p);
+      const stat2 = fs6.statSync(p);
       if (stat2.isDirectory()) {
-        fs4.rmSync(p, { recursive: true, force: true });
+        fs6.rmSync(p, { recursive: true, force: true });
       } else {
-        fs4.unlinkSync(p);
+        fs6.unlinkSync(p);
       }
     } catch {
     }
@@ -1961,14 +2185,14 @@ function registerImportRoutes(server2, dbManager2) {
   server2.post("/_web/detect-format", async (request, reply) => {
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs4.mkdtempSync(path4.join(os2.tmpdir(), "chatlab-detect-"));
-    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-detect-"));
+    const tmpPath = path6.join(tmpDir, data.filename || "upload");
     try {
       const chunks = [];
       for await (const chunk of data.file) {
         chunks.push(chunk);
       }
-      fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
+      fs6.writeFileSync(tmpPath, Buffer.concat(chunks));
       const format = detectFormat(tmpPath);
       const allFormats = detectAllFormats(tmpPath);
       return { format, allFormats };
@@ -1979,14 +2203,14 @@ function registerImportRoutes(server2, dbManager2) {
   server2.post("/_web/scan-multi-chat", async (request, reply) => {
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs4.mkdtempSync(path4.join(os2.tmpdir(), "chatlab-scan-"));
-    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-scan-"));
+    const tmpPath = path6.join(tmpDir, data.filename || "upload");
     try {
       const chunks = [];
       for await (const chunk of data.file) {
         chunks.push(chunk);
       }
-      fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
+      fs6.writeFileSync(tmpPath, Buffer.concat(chunks));
       const chats = await scanMultiChatFile(tmpPath);
       return { chats };
     } finally {
@@ -1996,13 +2220,13 @@ function registerImportRoutes(server2, dbManager2) {
   server2.post("/_web/import", async (request, reply) => {
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs4.mkdtempSync(path4.join(os2.tmpdir(), "chatlab-import-"));
-    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-import-"));
+    const tmpPath = path6.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
     }
-    fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
+    fs6.writeFileSync(tmpPath, Buffer.concat(chunks));
     const formatId = data.fields?.formatId?.value;
     const chatIndexStr = data.fields?.chatIndex?.value;
     const chatIndex = chatIndexStr !== void 0 ? parseInt(chatIndexStr, 10) : void 0;
@@ -2045,7 +2269,7 @@ data: ${JSON.stringify(eventData)}
   server2.post("/_web/import-directory", async (request, reply) => {
     const parts = request.parts();
     if (!parts) return reply.code(400).send({ error: "No files uploaded" });
-    const tmpDir = fs4.mkdtempSync(path4.join(os2.tmpdir(), "chatlab-dir-import-"));
+    const tmpDir = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-dir-import-"));
     const relativePaths = [];
     const fileBuffers = [];
     try {
@@ -2073,10 +2297,10 @@ data: ${JSON.stringify(eventData)}
         if (segments.length > 1) {
           relPath = segments.slice(1).join("/");
         }
-        const targetPath = path4.resolve(tmpDir, relPath);
-        if (!targetPath.startsWith(tmpDir + path4.sep)) continue;
-        fs4.mkdirSync(path4.dirname(targetPath), { recursive: true });
-        fs4.writeFileSync(targetPath, fileBuffers[i].data);
+        const targetPath = path6.resolve(tmpDir, relPath);
+        if (!targetPath.startsWith(tmpDir + path6.sep)) continue;
+        fs6.mkdirSync(path6.dirname(targetPath), { recursive: true });
+        fs6.writeFileSync(targetPath, fileBuffers[i].data);
       }
       const entryPath = findEntryFileInDirectory(tmpDir);
       if (!entryPath) {
@@ -2121,13 +2345,13 @@ data: ${JSON.stringify({ success: false, error: err instanceof Error ? err.messa
     const sessionId = request.params.id;
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs4.mkdtempSync(path4.join(os2.tmpdir(), "chatlab-inc-"));
-    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-inc-"));
+    const tmpPath = path6.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
     }
-    fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
+    fs6.writeFileSync(tmpPath, Buffer.concat(chunks));
     reply.raw.writeHead(200, {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
@@ -2159,13 +2383,13 @@ data: ${JSON.stringify(eventData)}
     const sessionId = request.params.id;
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs4.mkdtempSync(path4.join(os2.tmpdir(), "chatlab-analyze-"));
-    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-analyze-"));
+    const tmpPath = path6.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
     }
-    fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
+    fs6.writeFileSync(tmpPath, Buffer.concat(chunks));
     try {
       return await analyzeIncrementalImport(dbManager2, sessionId, tmpPath);
     } catch (err) {
@@ -2177,13 +2401,13 @@ data: ${JSON.stringify(eventData)}
   server2.post("/_web/import/analyze", async (request, reply) => {
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs4.mkdtempSync(path4.join(os2.tmpdir(), "chatlab-analyze-"));
-    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-analyze-"));
+    const tmpPath = path6.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
     }
-    fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
+    fs6.writeFileSync(tmpPath, Buffer.concat(chunks));
     try {
       return await analyzeNewImport(tmpPath);
     } catch (err) {
@@ -2213,17 +2437,17 @@ data: ${JSON.stringify(eventData)}
 
 `);
     }
-    const tmpDir = fs4.mkdtempSync(path4.join(os2.tmpdir(), "chatlab-demo-"));
+    const tmpDir = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-demo-"));
     try {
       const localPaths = [];
       for (let i = 0; i < total; i++) {
         sendEvent("progress", { stage: "downloading", current: i + 1, total });
-        const localPath = path4.join(tmpDir, DEMO_FILES[i]);
+        const localPath = path6.join(tmpDir, DEMO_FILES[i]);
         const resp = await fetch(`${DEMO_BASE_URL}/${locale}/${DEMO_FILES[i]}`, {
           signal: AbortSignal.timeout(6e4)
         });
         if (!resp.ok) throw new Error(`Download demo failed (${DEMO_FILES[i]}): ${resp.status}`);
-        fs4.writeFileSync(localPath, Buffer.from(await resp.arrayBuffer()));
+        fs6.writeFileSync(localPath, Buffer.from(await resp.arrayBuffer()));
         localPaths.push(localPath);
       }
       sendEvent("progress", { stage: "importing", current: 1, total });
@@ -2254,7 +2478,7 @@ data: ${JSON.stringify(eventData)}
 }
 
 // src/http/routes/web/cache.ts
-import * as path5 from "path";
+import * as path7 from "path";
 import { execFile } from "child_process";
 function runExecFile(file, args, runner = execFile) {
   return new Promise((resolve4, reject) => {
@@ -2282,7 +2506,7 @@ async function showPathInFolder(filePath, platform = process.platform, runner) {
   } else if (platform === "win32") {
     await runExecFile("explorer.exe", [`/select,${filePath}`], runner);
   } else {
-    await runExecFile("xdg-open", [path5.dirname(filePath)], runner);
+    await runExecFile("xdg-open", [path7.dirname(filePath)], runner);
   }
 }
 
@@ -2305,26 +2529,26 @@ function registerWebRoutes(server2, dbManager2, options) {
   const mergeCache = options?.pathProvider ? new MergeSessionCache(options.pathProvider, { nativeBinding: options.nativeBinding }) : null;
   mergeCache?.cleanupOrphans();
   const fallbackPathProvider = {
-    getSystemDir: () => path6.join(os3.homedir(), ".chatlab"),
-    getUserDataDir: () => path6.join(os3.homedir(), ".chatlab", "data"),
-    getDatabaseDir: () => path6.join(os3.homedir(), ".chatlab", "data", "databases"),
-    getAiDataDir: () => path6.join(os3.homedir(), ".chatlab", "ai"),
-    getSettingsDir: () => path6.join(os3.homedir(), ".chatlab", "settings"),
-    getCacheDir: () => path6.join(os3.homedir(), ".chatlab", "cache"),
-    getTempDir: () => path6.join(os3.homedir(), ".chatlab", "temp"),
-    getLogsDir: () => path6.join(os3.homedir(), ".chatlab", "logs"),
-    getDownloadsDir: () => path6.join(os3.homedir(), "Downloads")
+    getSystemDir: () => path8.join(os3.homedir(), ".chatlab"),
+    getUserDataDir: () => path8.join(os3.homedir(), ".chatlab", "data"),
+    getDatabaseDir: () => path8.join(os3.homedir(), ".chatlab", "data", "databases"),
+    getAiDataDir: () => path8.join(os3.homedir(), ".chatlab", "ai"),
+    getSettingsDir: () => path8.join(os3.homedir(), ".chatlab", "settings"),
+    getCacheDir: () => path8.join(os3.homedir(), ".chatlab", "cache"),
+    getTempDir: () => path8.join(os3.homedir(), ".chatlab", "temp"),
+    getLogsDir: () => path8.join(os3.homedir(), ".chatlab", "logs"),
+    getDownloadsDir: () => path8.join(os3.homedir(), "Downloads")
   };
   const resolvedPathProvider = options?.pathProvider ?? fallbackPathProvider;
   const ai = options?.aiContext;
   const cliStreamImport = async (dm, filePath) => {
-    const { streamImport: streamImport2 } = await import("./stream-import-FHFBCEDV.mjs");
+    const { streamImport: streamImport2 } = await import("./stream-import-KZFC3XT2.mjs");
     const result = await streamImport2(dm, filePath);
     if (!result.sessionId) throw new Error("Import succeeded but no sessionId returned");
     return { sessionId: result.sessionId };
   };
   const defaultUserDataDir = getDefaultNodeUserDataDir();
-  const isCustom = path6.resolve(resolvedPathProvider.getUserDataDir()) !== path6.resolve(defaultUserDataDir);
+  const isCustom = path8.resolve(resolvedPathProvider.getUserDataDir()) !== path8.resolve(defaultUserDataDir);
   registerSharedRoutes(
     server2,
     {
@@ -2415,31 +2639,31 @@ function registerProxyRoutes(server2) {
 }
 
 // src/ai/manager-factory.ts
-import * as fs5 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path9 from "path";
 import { createHash, randomUUID } from "crypto";
 var nodeFs = {
   ensureDir(dir) {
-    if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+    if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
   },
   listFiles(dir, ext) {
-    if (!fs5.existsSync(dir)) return [];
-    return fs5.readdirSync(dir).filter((f) => f.endsWith(ext));
+    if (!fs7.existsSync(dir)) return [];
+    return fs7.readdirSync(dir).filter((f) => f.endsWith(ext));
   },
   readFile(filePath) {
-    return fs5.readFileSync(filePath, "utf-8");
+    return fs7.readFileSync(filePath, "utf-8");
   },
   writeFile(filePath, content) {
-    fs5.writeFileSync(filePath, content, "utf-8");
+    fs7.writeFileSync(filePath, content, "utf-8");
   },
   deleteFile(filePath) {
-    if (fs5.existsSync(filePath)) fs5.unlinkSync(filePath);
+    if (fs7.existsSync(filePath)) fs7.unlinkSync(filePath);
   },
   fileExists(filePath) {
-    return fs5.existsSync(filePath);
+    return fs7.existsSync(filePath);
   },
   joinPath(...parts) {
-    return path7.join(...parts);
+    return path9.join(...parts);
   }
 };
 var managerCache = /* @__PURE__ */ new Map();
@@ -2449,13 +2673,13 @@ function getAssistantManager(aiDataDir) {
     cached = {
       assistant: new AssistantManager({
         fs: nodeFs,
-        assistantsDir: path7.join(aiDataDir, "assistants"),
+        assistantsDir: path9.join(aiDataDir, "assistants"),
         builtinRawConfigs: [],
         generateId: () => `custom_${randomUUID().replace(/-/g, "").slice(0, 12)}`
       }),
       skill: new SkillManagerCore({
         fs: nodeFs,
-        skillsDir: path7.join(aiDataDir, "skills"),
+        skillsDir: path9.join(aiDataDir, "skills"),
         builtinRawSkills: [],
         contentHash: (content) => createHash("md5").update(content).digest("hex")
       })
@@ -2479,8 +2703,8 @@ var noop = () => {
 var NOOP_LOGGER = { info: noop, warn: noop, error: noop };
 
 // ../../packages/sync/src/data-source-manager.ts
-import * as fs6 from "fs";
-import * as path8 from "path";
+import * as fs8 from "fs";
+import * as path10 from "path";
 import * as crypto from "crypto";
 var CONFIG_FILE = "data-sources.json";
 function generateId(prefix = "ds") {
@@ -2508,17 +2732,17 @@ var DataSourceManager = class {
     this.logger = logger ?? NOOP_LOGGER;
   }
   getConfigPath() {
-    return path8.join(this.configDir, CONFIG_FILE);
+    return path10.join(this.configDir, CONFIG_FILE);
   }
   ensureDir() {
-    fs6.mkdirSync(this.configDir, { recursive: true });
+    fs8.mkdirSync(this.configDir, { recursive: true });
   }
   // ==================== Load / Save ====================
   loadAll() {
     try {
       const filePath = this.getConfigPath();
-      if (fs6.existsSync(filePath)) {
-        const raw = fs6.readFileSync(filePath, "utf-8");
+      if (fs8.existsSync(filePath)) {
+        const raw = fs8.readFileSync(filePath, "utf-8");
         const parsed = JSON.parse(raw);
         if (!isValidDataSourceArray(parsed)) {
           this.logger.warn("[DataSource] Incompatible config format detected, returning empty.");
@@ -2537,7 +2761,7 @@ var DataSourceManager = class {
   saveAll(sources) {
     try {
       this.ensureDir();
-      fs6.writeFileSync(this.getConfigPath(), JSON.stringify(sources, null, 2), "utf-8");
+      fs8.writeFileSync(this.getConfigPath(), JSON.stringify(sources, null, 2), "utf-8");
     } catch (err) {
       this.logger.error("[DataSource] Failed to save config", err);
     }
@@ -2662,7 +2886,7 @@ function parseRemoteSessionsResponse(body) {
 }
 
 // ../../packages/sync/src/pull-engine.ts
-import * as fs7 from "fs";
+import * as fs9 from "fs";
 import * as crypto2 from "crypto";
 var MAX_PAGES_PER_PULL = 5e3;
 var PULL_OVERLAP_SECONDS = 60;
@@ -2682,7 +2906,7 @@ function parseSyncFromFile(filePath) {
   try {
     const isJsonl = filePath.endsWith(".jsonl");
     if (isJsonl) {
-      const content = fs7.readFileSync(filePath, "utf-8");
+      const content = fs9.readFileSync(filePath, "utf-8");
       const lines = content.trimEnd().split("\n");
       for (let i = lines.length - 1; i >= Math.max(0, lines.length - 5); i--) {
         try {
@@ -2701,7 +2925,7 @@ function parseSyncFromFile(filePath) {
       }
       return null;
     }
-    const raw = fs7.readFileSync(filePath, "utf-8");
+    const raw = fs9.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.sync && typeof parsed.sync === "object") {
       const s = parsed.sync;
@@ -2715,7 +2939,7 @@ function parseSyncFromFile(filePath) {
 function fileContainsMessages(filePath) {
   try {
     if (filePath.endsWith(".jsonl")) {
-      const content = fs7.readFileSync(filePath, "utf-8");
+      const content = fs9.readFileSync(filePath, "utf-8");
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed) continue;
@@ -2728,7 +2952,7 @@ function fileContainsMessages(filePath) {
       }
       return false;
     }
-    const raw = fs7.readFileSync(filePath, "utf-8");
+    const raw = fs9.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed.messages) && parsed.messages.length > 0;
   } catch {
@@ -2737,7 +2961,7 @@ function fileContainsMessages(filePath) {
 }
 function cleanupTempFile(filePath) {
   try {
-    if (fs7.existsSync(filePath)) fs7.unlinkSync(filePath);
+    if (fs9.existsSync(filePath)) fs9.unlinkSync(filePath);
   } catch {
   }
 }
@@ -2748,6 +2972,7 @@ var PullEngine = class {
   dsManager;
   logger;
   isImporting;
+  onSessionImported;
   pullingSourceIds = /* @__PURE__ */ new Set();
   progressMap = /* @__PURE__ */ new Map();
   constructor(options) {
@@ -2757,6 +2982,7 @@ var PullEngine = class {
     this.dsManager = options.dsManager;
     this.logger = options.logger ?? NOOP_LOGGER;
     this.isImporting = options.isImporting ?? (() => false);
+    this.onSessionImported = options.onSessionImported;
   }
   getProgress() {
     return Array.from(this.progressMap.values());
@@ -2797,7 +3023,7 @@ var PullEngine = class {
           limit: ds.pullLimit
         });
         try {
-          const stat2 = fs7.statSync(tempFile);
+          const stat2 = fs9.statSync(tempFile);
           this.logger.info(`[Pull] "${sess.name}" page ${pageCount}: fetched ${stat2.size} bytes`);
           const sync0 = parseSyncFromFile(tempFile);
           if (stat2.size < 1024) {
@@ -2815,7 +3041,7 @@ var PullEngine = class {
                   since,
                   limit: ds.pullLimit
                 });
-                const retryStat = fs7.statSync(retryFile);
+                const retryStat = fs9.statSync(retryFile);
                 this.logger.info(`[Pull] "${sess.name}" retry ${ri + 1}: fetched ${retryStat.size} bytes`);
                 const retrySync = parseSyncFromFile(retryFile);
                 if (retryStat.size < 1024 && !fileContainsMessages(retryFile) && retrySync?.hasMore === false) {
@@ -2954,6 +3180,13 @@ var PullEngine = class {
       if (totalNewMessages > 0) this.notifier.onSessionListChanged();
       this.notifier.onPullResult(sourceId, sess.id, "success", `+${totalNewMessages} messages`);
       this.markProgressDone(sess.id);
+      if (this.onSessionImported && sess.targetSessionId) {
+        try {
+          this.onSessionImported(sess.targetSessionId);
+        } catch (hookErr) {
+          this.logger.warn(`[Pull] onSessionImported hook failed for "${sess.name}": ${hookErr}`);
+        }
+      }
       return { success: true, newMessageCount: totalNewMessages };
     } catch (error) {
       const errMsg = error.message || "Pull failed";
@@ -3089,13 +3322,13 @@ function reloadTimer(dsId, skipInitialPull = false) {
 }
 
 // src/sync/adapters.ts
-import * as fs8 from "fs";
+import * as fs10 from "fs";
 import * as os4 from "os";
-import * as path9 from "path";
+import * as path11 from "path";
 import * as crypto3 from "crypto";
 function getTempFilePath(ext) {
   const id = crypto3.randomBytes(8).toString("hex");
-  return path9.join(os4.tmpdir(), `chatlab-pull-${id}${ext}`);
+  return path11.join(os4.tmpdir(), `chatlab-pull-${id}${ext}`);
 }
 var NodeFetcher = class {
   async fetchToTempFile(baseUrl, remoteSessionId, token, params) {
@@ -3112,7 +3345,7 @@ var NodeFetcher = class {
     const isJsonl = contentType.includes("ndjson") || contentType.includes("jsonl");
     const tempFile = getTempFilePath(isJsonl ? ".jsonl" : ".json");
     const buffer = Buffer.from(await response.arrayBuffer());
-    fs8.writeFileSync(tempFile, buffer);
+    fs10.writeFileSync(tempFile, buffer);
     return tempFile;
   }
 };
@@ -3125,7 +3358,7 @@ var DirectImporter = class {
   }
   sessionExists(sessionId) {
     const dbPath = this.dbManager.getDbPath(sessionId);
-    if (!fs8.existsSync(dbPath)) return false;
+    if (!fs10.existsSync(dbPath)) return false;
     try {
       const db = this.dbManager.openRawSessionDatabase(sessionId, { readonly: true });
       const row = db.prepare("SELECT COUNT(*) as cnt FROM sqlite_master WHERE type='table' AND name='message'").get();
@@ -3133,7 +3366,7 @@ var DirectImporter = class {
       if (row.cnt === 0) {
         this.logger.warn(`[DirectImporter] DB file exists but has no message table: ${sessionId}, removing`);
         try {
-          fs8.unlinkSync(dbPath);
+          fs10.unlinkSync(dbPath);
         } catch {
         }
         return false;
@@ -3143,7 +3376,7 @@ var DirectImporter = class {
       if (error instanceof DataDirCompatibilityError) throw error;
       this.logger.warn(`[DirectImporter] Cannot validate DB file: ${sessionId}, removing`);
       try {
-        fs8.unlinkSync(dbPath);
+        fs10.unlinkSync(dbPath);
       } catch {
       }
       return false;
@@ -3259,10 +3492,7 @@ function registerAutomationRoutes(server2, ctx) {
     if (!removed) return reply.code(404).send({ error: "Session not found" });
     reloadTimer(request.params.id);
     if (request.query.deleteData === "true" && removed.targetSessionId) {
-      dbManager2.close(removed.targetSessionId);
-      const dbPath = dbManager2.getDbPath(removed.targetSessionId);
-      const fs10 = await import("fs");
-      if (fs10.existsSync(dbPath)) fs10.unlinkSync(dbPath);
+      dbManager2.deleteSessionDatabaseFiles(removed.targetSessionId);
     }
     return { success: true };
   });
@@ -3314,12 +3544,21 @@ function initSync(server2, dbManager2, pathProvider, serverInfo) {
   const fetcher = new NodeFetcher();
   const importer = new DirectImporter(dbManager2, syncLogger);
   const notifier = new NoopNotifier();
+  const sessionAdapter = createDatabaseManagerAdapter(dbManager2);
+  const preferences = new PreferencesManager(pathProvider.getSystemDir());
   pullEngine = new PullEngine({
     fetcher,
     importer,
     notifier,
     dsManager,
-    logger: syncLogger
+    logger: syncLogger,
+    onSessionImported: (localSessionId) => {
+      preferences.invalidateCache();
+      const result = owner_profile_service_exports.tryApplyOwnerProfile(sessionAdapter, preferences, localSessionId);
+      if (result.applied) {
+        syncLogger.info(`[Pull] Applied owner profile to session ${localSessionId} (owner: ${result.ownerId})`);
+      }
+    }
   });
   registerAutomationRoutes(server2, { dsManager, pullEngine, dbManager: dbManager2, serverInfo });
   initScheduler({
@@ -3342,21 +3581,21 @@ function createFileConfigStorage(aiDataDir) {
   return {
     readJson(key) {
       try {
-        return JSON.parse(fs9.readFileSync(`${aiDataDir}/${key}.json`, "utf-8"));
+        return JSON.parse(fs11.readFileSync(`${aiDataDir}/${key}.json`, "utf-8"));
       } catch {
         return null;
       }
     },
     writeJson(key, data) {
-      if (!fs9.existsSync(aiDataDir)) fs9.mkdirSync(aiDataDir, { recursive: true });
-      fs9.writeFileSync(`${aiDataDir}/${key}.json`, JSON.stringify(data, null, 2), "utf-8");
+      if (!fs11.existsSync(aiDataDir)) fs11.mkdirSync(aiDataDir, { recursive: true });
+      fs11.writeFileSync(`${aiDataDir}/${key}.json`, JSON.stringify(data, null, 2), "utf-8");
     }
   };
 }
 function resolveNativeBinding2() {
   if (process.versions.electron) return void 0;
   const nativePath = resolveCliPath("native/better_sqlite3.node");
-  if (fs9.existsSync(nativePath)) return nativePath;
+  if (fs11.existsSync(nativePath)) return nativePath;
   return void 0;
 }
 function ensureToken(config) {
@@ -3442,7 +3681,7 @@ async function startHttpServer(options) {
     }
   });
   initSync(server, dbManager, pathProvider, { port, host, token });
-  if (options?.webRoot && fs9.existsSync(options.webRoot)) {
+  if (options?.webRoot && fs11.existsSync(options.webRoot)) {
     registerProxyRoutes(server);
     const fastifyStatic = await import("@fastify/static");
     await server.register(fastifyStatic.default, {
@@ -3483,4 +3722,4 @@ export {
   startHttpServer,
   stopHttpServer
 };
-//# sourceMappingURL=chunk-AZZYKUBR.mjs.map
+//# sourceMappingURL=chunk-QMXNJRTT.mjs.map