chatlab-cli 0.26.2 → 0.27.0

package/dist/{chunk-GBQQJJKK.mjs → chunk-3HOTLLFC.mjs}

@@ -4,34 +4,34 @@ import { fileURLToPath as __fileURLToPath } from 'url';
 const require = __createRequire(import.meta.url);
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
+import {
+  closeServerAiLogger,
+  createCliRunAgentStream,
+  initServerAiLogger
+} from "./chunk-7LPVQR77.mjs";
 import {
   importData,
   parseFile
-} from "./chunk-3XFHIQIW.mjs";
+} from "./chunk-UBJHT3BU.mjs";
 import {
   analyzeIncrementalImport,
   analyzeNewImport,
   incrementalImport,
   streamImport
-} from "./chunk-QKQRV7RV.mjs";
+} from "./chunk-6FXGC6HE.mjs";
+import {
+  AGENT_TOOL_REGISTRY,
+  CoreDataProvider
+} from "./chunk-M6ABWESL.mjs";
 import {
   assertCliDataDirCompatible
-} from "./chunk-6AOEMUCM.mjs";
+} from "./chunk-FHLPXRDL.mjs";
 import {
   getVersion
 } from "./chunk-5ADKYYNA.mjs";
 import {
   resolveCliPath
 } from "./chunk-FJ35V3TE.mjs";
-import {
-  closeServerAiLogger,
-  createCliRunAgentStream,
-  initServerAiLogger
-} from "./chunk-JFSTXSX2.mjs";
-import {
-  AGENT_TOOL_REGISTRY,
-  CoreDataProvider
-} from "./chunk-SCE4YL3M.mjs";
 import {
   AIChatManager,
   ALL_MIGRATIONS,
@@ -60,6 +60,7 @@ import {
   createDatabaseManagerAdapter,
   createJiebaNlpProvider,
   createNodeDataDirSwitch,
+  createSemanticIndexService,
   deleteDict,
   detectAllFormats,
   detectFormat,
@@ -74,29 +75,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,
@@ -123,10 +136,10 @@ import {
   verifyCliDataPath,
   writeAuthProfile,
   writeConfigField
-} from "./chunk-TMZC3SNX.mjs";
+} from "./chunk-KCFVHVO4.mjs";
 
 // src/http/index.ts
-import * as fs9 from "fs";
+import * as fs11 from "fs";
 import * as crypto4 from "crypto";
 
 // src/http/server.ts
@@ -451,13 +464,19 @@ function registerSessionRoutes(server2, ctx) {
     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) => {
@@ -589,6 +608,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;
@@ -600,9 +623,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);
@@ -614,111 +660,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));
     }
   );
 }
@@ -823,9 +1010,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 () => {
@@ -849,7 +1037,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",
@@ -1202,17 +1402,21 @@ function registerAiToolRoutes(server2, ctx) {
     if (!entry) {
       return reply.code(404).send({ success: false, error: `Tool not found: ${toolName}` });
     }
-    const db = ctx.dbManager.open(sessionId);
-    if (!db) {
-      return reply.code(404).send({ success: false, error: `Session not found: ${sessionId}` });
-    }
     const abortController = new AbortController();
     activeToolTests.set(testId, abortController);
     try {
+      if (ctx.executeAiTool) {
+        return await ctx.executeAiTool({ testId, toolName, params, sessionId, abortSignal: abortController.signal });
+      }
+      const db = ctx.dbManager.open(sessionId);
+      if (!db) {
+        return reply.code(404).send({ success: false, error: `Session not found: ${sessionId}` });
+      }
       const execCtx = {
         sessionId,
         db,
-        dataProvider: new CoreDataProvider(db)
+        dataProvider: new CoreDataProvider(db),
+        abortSignal: abortController.signal
       };
       const startTime = Date.now();
       const result = await entry.handler(params, execCtx);
@@ -1413,10 +1617,64 @@ function registerAiSummaryRoutes(server2, ctx) {
   });
 }
 
+// ../../packages/http-routes/src/routes/web/ai-semantic-index.ts
+function registerSemanticIndexRoutes(server2, ctx) {
+  const service = ctx.semanticIndexService;
+  if (!service) return;
+  server2.get("/_web/ai/semantic-index/config", async () => {
+    return { config: service.getConfig(), apiKeySet: service.hasApiKey(), configured: service.isConfigured() };
+  });
+  server2.put(
+    "/_web/ai/semantic-index/config",
+    async (request) => {
+      const config = service.setConfig(request.body.config, { apiKey: request.body.apiKey });
+      return { config, apiKeySet: service.hasApiKey(), configured: service.isConfigured() };
+    }
+  );
+  server2.get("/_web/ai/semantic-index/enabled", async () => {
+    return { sessions: service.listEnabledStatuses() };
+  });
+  server2.get("/_web/ai/semantic-index/status", async (request) => {
+    return { status: service.status(request.query.sessionId) };
+  });
+  server2.post("/_web/ai/semantic-index/status", async (request) => {
+    return { sessions: service.statusForSessions(request.body.sessionIds ?? []) };
+  });
+  const sessionAction = (path12, action) => {
+    server2.post(path12, async (request, reply) => {
+      const { sessionId } = request.body;
+      if (!sessionId) return reply.code(400).send({ error: "sessionId is required" });
+      await action(sessionId);
+      return { status: service.status(sessionId) };
+    });
+  };
+  sessionAction("/_web/ai/semantic-index/enable", (id) => service.enable(id));
+  sessionAction("/_web/ai/semantic-index/disable", (id) => service.disable(id));
+  sessionAction("/_web/ai/semantic-index/build", (id) => service.build(id));
+  sessionAction("/_web/ai/semantic-index/pause", (id) => service.pause(id));
+  sessionAction("/_web/ai/semantic-index/cancel", (id) => service.cancel(id));
+  sessionAction("/_web/ai/semantic-index/rebuild", (id) => service.rebuild(id));
+  server2.post("/_web/ai/semantic-index/build-pending", async () => {
+    service.buildAllPending();
+    return { sessions: service.listEnabledStatuses() };
+  });
+  server2.post("/_web/ai/semantic-index/cleanup", async () => {
+    return service.cleanupUnused();
+  });
+  server2.post(
+    "/_web/ai/semantic-index/search",
+    async (request, reply) => {
+      const { sessionId, query, finalTopK } = request.body;
+      if (!sessionId || !query) return reply.code(400).send({ error: "sessionId and query are required" });
+      return service.search(sessionId, query, { finalTopK });
+    }
+  );
+}
+
 // ../../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);
@@ -1433,31 +1691,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,
@@ -1471,13 +1729,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 {
         }
       }
@@ -1526,20 +1784,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 {
           }
         }
@@ -1613,16 +1871,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 {
@@ -1637,10 +1895,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 {
@@ -1653,10 +1911,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;
   }
@@ -1702,7 +1960,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 {
@@ -1719,10 +1977,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 });
@@ -1739,7 +1997,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,
@@ -1756,8 +2014,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);
@@ -1767,7 +2025,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() };
       })
@@ -1791,11 +2049,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) => {
@@ -1811,7 +2069,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 {
@@ -1869,6 +2127,7 @@ function registerSharedRoutes(server2, ctx, options) {
   registerAiToolRoutes(server2, resolvedCtx);
   registerAiChatRoutes(server2, resolvedCtx);
   registerAiSummaryRoutes(server2, resolvedCtx);
+  registerSemanticIndexRoutes(server2, resolvedCtx);
   registerMergeRoutes(server2, resolvedCtx);
   registerCacheRoutes(server2, resolvedCtx);
 }
@@ -1948,19 +2207,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;
 }
 
@@ -1969,11 +2228,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 {
     }
@@ -1986,14 +2245,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 };
@@ -2004,14 +2263,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 {
@@ -2021,13 +2280,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;
@@ -2070,7 +2329,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 {
@@ -2098,10 +2357,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) {
@@ -2146,13 +2405,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",
@@ -2184,13 +2443,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) {
@@ -2202,13 +2461,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) {
@@ -2238,17 +2497,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 });
@@ -2279,7 +2538,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) => {
@@ -2307,7 +2566,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);
   }
 }
 
@@ -2330,26 +2589,42 @@ 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"),
+    getVectorDir: () => path8.join(os3.homedir(), ".chatlab", "data", "vector"),
+    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-F5QI2HTO.mjs");
+    const { streamImport: streamImport2 } = await import("./stream-import-4VDJZHMY.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);
+  let semanticIndexService = options?.semanticIndexService;
+  if (!semanticIndexService) {
+    try {
+      semanticIndexService = createSemanticIndexService({
+        pathProvider: resolvedPathProvider,
+        sessionAdapter: adapter,
+        nativeBinding: options?.nativeBinding
+      });
+      semanticIndexService.recover();
+      server2.addHook("onClose", async () => semanticIndexService?.close());
+    } catch (err) {
+      console.warn("[semantic-index] service unavailable:", err instanceof Error ? err.message : String(err));
+      semanticIndexService = void 0;
+    }
+  }
   registerSharedRoutes(
     server2,
     {
@@ -2358,6 +2633,7 @@ function registerWebRoutes(server2, dbManager2, options) {
       pathProvider: resolvedPathProvider,
       getVersion,
       nativeBinding: options?.nativeBinding,
+      semanticIndexService,
       openDirectory: openDirectoryPath,
       showInFolder: showPathInFolder,
       downloadsDir: resolvedPathProvider.getDownloadsDir(),
@@ -2440,31 +2716,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();
@@ -2474,13 +2750,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")
       })
@@ -2504,8 +2780,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") {
@@ -2533,17 +2809,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.");
@@ -2562,7 +2838,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);
     }
@@ -2687,7 +2963,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;
@@ -2707,7 +2983,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 {
@@ -2726,7 +3002,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;
@@ -2740,7 +3016,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;
@@ -2753,7 +3029,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 {
@@ -2762,7 +3038,7 @@ function fileContainsMessages(filePath) {
 }
 function cleanupTempFile(filePath) {
   try {
-    if (fs7.existsSync(filePath)) fs7.unlinkSync(filePath);
+    if (fs9.existsSync(filePath)) fs9.unlinkSync(filePath);
   } catch {
   }
 }
@@ -2824,7 +3100,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) {
@@ -2842,7 +3118,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) {
@@ -3123,13 +3399,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) {
@@ -3146,7 +3422,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;
   }
 };
@@ -3159,7 +3435,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();
@@ -3167,7 +3443,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;
@@ -3177,7 +3453,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;
@@ -3382,21 +3658,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) {
@@ -3467,9 +3743,23 @@ async function startHttpServer(options) {
     limits: { fileSize: 1024 * 1024 * 1024 }
     // 1GB
   });
+  let semanticIndexService;
+  try {
+    semanticIndexService = createSemanticIndexService({
+      pathProvider,
+      sessionAdapter: createDatabaseManagerAdapter(dbManager),
+      nativeBinding
+    });
+    semanticIndexService.recover();
+    server.addHook("onClose", async () => semanticIndexService?.close());
+  } catch (err) {
+    console.warn("[semantic-index] service unavailable:", err instanceof Error ? err.message : String(err));
+    semanticIndexService = void 0;
+  }
   registerWebRoutes(server, dbManager, {
     pathProvider,
     nativeBinding,
+    semanticIndexService,
     aiContext: {
       aiDataDir,
       aiChatManager,
@@ -3478,11 +3768,11 @@ async function startHttpServer(options) {
       llmConfigStore,
       customProviderStore: new CustomProviderStore(createFileConfigStorage(aiDataDir)),
       customModelStore: new CustomModelStore(createFileConfigStorage(aiDataDir)),
-      runAgentStream: createCliRunAgentStream(dbManager, aiChatManager)
+      runAgentStream: createCliRunAgentStream(dbManager, aiChatManager, semanticIndexService)
     }
   });
   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, {
@@ -3523,4 +3813,4 @@ export {
   startHttpServer,
   stopHttpServer
 };
-//# sourceMappingURL=chunk-GBQQJJKK.mjs.map
+//# sourceMappingURL=chunk-3HOTLLFC.mjs.map