chatlab-cli 0.31.2 → 0.31.3

package/dist/{chunk-BSSR4ZYW.mjs → chunk-GZO3NAHC.mjs}

@@ -7,23 +7,25 @@ const __dirname = __pathDirname(__filename);
 import {
   closeServerAiLogger,
   createCliRunAgentStream,
+  getAssistantManager,
   getServerAiLogger,
+  getSkillManagerCore,
   initServerAiLogger
-} from "./chunk-3SZWD7UM.mjs";
+} from "./chunk-FDLLEDNW.mjs";
 import {
   AGENT_TOOL_REGISTRY,
   CoreDataProvider
-} from "./chunk-6JKKHPXY.mjs";
+} from "./chunk-DV4U34MR.mjs";
 import {
   analyzeIncrementalImport,
   analyzeNewImport,
   autoImport,
   incrementalImport,
   streamImport
-} from "./chunk-ZCXCHKQV.mjs";
+} from "./chunk-EINCXXWY.mjs";
 import {
   assertCliDataDirCompatible
-} from "./chunk-OQ6N4PDD.mjs";
+} from "./chunk-BLOBEOCG.mjs";
 import {
   getVersion
 } from "./chunk-5ADKYYNA.mjs";
@@ -41,27 +43,27 @@ import {
   getPendingNodeDataDirMigration,
   hasPendingElectronDataWarning,
   serializeChatLabToJsonl
-} from "./chunk-S5PQM5J4.mjs";
+} from "./chunk-MFOCDGCC.mjs";
 import {
   AIChatManager,
   ArchiveImportError,
   ArchiveImportSourceManager,
-  AssistantManager,
   CustomModelStore,
   CustomProviderStore,
   IMPORT_IN_PROGRESS_ERROR_KEY,
   ImportIdempotencyCache,
   ImportInProgressError,
-  LLMConfigStore,
   MergeSessionCache,
   SEMANTIC_INDEX_CONFIG_FILE,
   SemanticIndexConfigStore,
-  SkillManagerCore,
   TempDbWriter,
   buildPiModel,
   computeWordFrequency,
   countMessagesTokens,
+  createAuthProfileLlmConfigStore,
+  createChatLabTempDir,
   createContactsService,
+  createFileConfigStorage,
   createGlobalInsightService,
   createPeopleRelationshipsService,
   deleteDict,
@@ -73,12 +75,14 @@ import {
   export_service_exports,
   fetchRemoteModels,
   findEntryFileInDirectory,
+  getChatLabTempScopeDir,
   getDefaultRulesForLocale,
   getDictList,
   getSupportedFormats,
   hashImportBody,
   isDictDownloaded,
   isSemanticIndexConfigured,
+  isValidImportSessionId,
   logNativeParserStatus,
   member_service_exports,
   mergeRulesForLocale,
@@ -94,7 +98,7 @@ import {
   streamParseFileInfo,
   summary_service_exports,
   validateApiKey
-} from "./chunk-GYPBWKAU.mjs";
+} from "./chunk-75FZ26HM.mjs";
 import {
   resolveCliPath
 } from "./chunk-FJ35V3TE.mjs";
@@ -110,7 +114,6 @@ import {
   POS_TAG_DEFINITIONS,
   appLogger,
   createDatabaseManagerAdapter,
-  deleteAuthProfile,
   executeReadonlySql,
   executeSql,
   getAvailableYears,
@@ -129,8 +132,7 @@ import {
   getLongMessageCount,
   getMemberActivity,
   getMemberMonthlyTrend,
-  getMembers,
-  getMembersDetailed,
+  getMembersWithAliases,
   getMemeBattleAnalysis,
   getMentionAnalysis,
   getMentionGraph,
@@ -155,18 +157,16 @@ import {
   isNewerStableVersion,
   loadConfig,
   queryMessages,
-  resolveApiKey,
   stripAvatarFields,
   verifyCliDataPath,
-  writeAuthProfile,
   writeConfigField
-} from "./chunk-IK7GJTGY.mjs";
+} from "./chunk-YVNZ73O5.mjs";
 
 // src/http/index.ts
-import * as fs12 from "fs";
+import * as fs11 from "fs";
 import * as crypto4 from "crypto";
 
-// src/http/server.ts
+// ../../packages/http-routes/src/server.ts
 import Fastify from "fastify";
 
 // ../../packages/http-routes/src/errors.ts
@@ -217,8 +217,8 @@ function exportTooLarge(count, limit) {
 function serverError(message = "Internal server error") {
   return new ApiError("SERVER_ERROR" /* SERVER_ERROR */, message);
 }
-function importInProgress() {
-  return new ApiError("IMPORT_IN_PROGRESS" /* IMPORT_IN_PROGRESS */, "Another import is already in progress");
+function importInProgress(message = "Another import is already in progress") {
+  return new ApiError("IMPORT_IN_PROGRESS" /* IMPORT_IN_PROGRESS */, message);
 }
 function idempotencyConflict() {
   return new ApiError("IDEMPOTENCY_CONFLICT" /* IDEMPOTENCY_CONFLICT */, "Same Idempotency-Key with different request body hash");
@@ -238,7 +238,18 @@ function dataDirIncompatible(message) {
 function apiErrorFromUnknown(error) {
   if (error instanceof ApiError) return error;
   if (error instanceof ImportInProgressError) return importInProgress();
-  if (error instanceof DataDirCompatibilityError) return dataDirIncompatible(error.message);
+  const compatibilityError = findDataDirCompatibilityError(error);
+  if (compatibilityError) return dataDirIncompatible(compatibilityError.message);
+  return null;
+}
+function findDataDirCompatibilityError(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current instanceof Error && !seen.has(current)) {
+    if (current instanceof DataDirCompatibilityError) return current;
+    seen.add(current);
+    current = current.cause;
+  }
   return null;
 }
 function successResponse(data, meta) {
@@ -262,195 +273,378 @@ function errorResponse(error) {
   };
 }
 
-// ../../packages/http-routes/src/routes/system.ts
-function registerSystemRoutes(server2, ctx) {
-  server2.get("/api/v1/status", async () => {
-    let sessionCount = 0;
-    try {
-      sessionCount = ctx.dbManager.listSessionIds().length;
-    } catch {
+// ../../packages/http-routes/src/server.ts
+var DEFAULT_JSON_BODY_LIMIT = 50 * 1024 * 1024;
+function configureApiErrorHandler(server2, options = {}) {
+  server2.setErrorHandler((error, request, reply) => {
+    const apiError = apiErrorFromUnknown(error);
+    if (apiError) {
+      reply.code(apiError.statusCode).send(errorResponse(apiError));
+      return;
     }
-    return successResponse({
-      name: "ChatLab API",
-      version: ctx.getVersion(),
-      uptime: Math.floor(process.uptime()),
-      sessionCount
-    });
+    if (error.statusCode === 413) {
+      const bodyError = new ApiError("BODY_TOO_LARGE" /* BODY_TOO_LARGE */, "Request body exceeds 50MB limit");
+      reply.code(bodyError.statusCode).send(errorResponse(bodyError));
+      return;
+    }
+    const statusCode = error.statusCode;
+    if (statusCode && statusCode >= 400 && statusCode < 600) {
+      reply.code(statusCode).send({ success: false, error: { code: "CLIENT_ERROR", message: error.message } });
+      return;
+    }
+    options.onUnhandledError?.(request, error);
+    const internalError = serverError(error.message);
+    reply.code(internalError.statusCode).send(errorResponse(internalError));
   });
-  server2.get("/api/v1/schema", async () => {
-    return successResponse({
-      format: "ChatLab Format",
-      version: "0.0.2",
-      spec: {
-        chatlab: {
-          type: "object",
-          required: ["version"],
-          properties: {
-            version: { type: "string" },
-            exportedAt: { type: "number" },
-            generator: { type: "string" }
-          }
-        },
-        meta: {
-          type: "object",
-          required: ["name", "platform", "type"],
-          properties: {
-            name: { type: "string" },
-            platform: {
-              type: "string",
-              enum: ["qq", "wechat", "telegram", "discord", "line", "whatsapp", "instagram", "unknown"]
-            },
-            type: { type: "string", enum: ["group", "private"] },
-            groupId: { type: "string" }
-          }
-        },
-        members: {
-          type: "array",
-          items: {
-            type: "object",
-            required: ["platformId", "accountName"],
-            properties: {
-              platformId: { type: "string" },
-              accountName: { type: "string" },
-              groupNickname: { type: "string" },
-              avatar: { type: "string" }
-            }
-          }
-        },
-        messages: {
-          type: "array",
-          items: {
-            type: "object",
-            required: ["sender", "timestamp", "type"],
-            properties: {
-              platformMessageId: { type: "string" },
-              sender: { type: "string" },
-              accountName: { type: "string" },
-              groupNickname: { type: "string" },
-              timestamp: { type: "number" },
-              type: { type: "number" },
-              content: { type: ["string", "null"] },
-              replyToMessageId: { type: "string" }
-            }
-          }
+}
+function createApiServer(options = {}) {
+  const server2 = Fastify({
+    logger: false,
+    bodyLimit: options.bodyLimit ?? DEFAULT_JSON_BODY_LIMIT
+  });
+  if (options.authHook) server2.addHook("onRequest", options.authHook);
+  configureApiErrorHandler(server2, options);
+  return server2;
+}
+
+// ../../packages/http-routes/src/auth.ts
+import { timingSafeEqual, createHmac, randomBytes } from "crypto";
+function createBearerAuthHook(options) {
+  const hmacKey = randomBytes(32);
+  const safeTokenCompare = (provided, expected) => {
+    const providedHash = createHmac("sha256", hmacKey).update(provided).digest();
+    const expectedHash = createHmac("sha256", hmacKey).update(expected).digest();
+    return timingSafeEqual(providedHash, expectedHash);
+  };
+  return async function bearerAuthHook(request, reply) {
+    if (options.shouldAuthenticate && !options.shouldAuthenticate(request)) return;
+    const expectedToken = options.getToken();
+    if (!expectedToken && options.allowMissingToken !== false) return;
+    const authHeader = request.headers.authorization;
+    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+      const err = unauthorized(options.missingTokenMessage);
+      reply.code(err.statusCode).send(errorResponse(err));
+      return;
+    }
+    const providedToken = authHeader.slice(7);
+    if (!expectedToken || !safeTokenCompare(providedToken, expectedToken)) {
+      const err = unauthorized(options.invalidTokenMessage);
+      reply.code(err.statusCode).send(errorResponse(err));
+    }
+  };
+}
+
+// src/http/auth.ts
+var cachedToken = null;
+var requireAuthEnabled = false;
+function setAuthToken(token) {
+  cachedToken = token;
+}
+function setRequireAuth(enabled) {
+  requireAuthEnabled = enabled;
+}
+var authHook = createBearerAuthHook({
+  getToken: () => cachedToken,
+  shouldAuthenticate: (request) => request.url.startsWith("/api/") || requireAuthEnabled && request.url.startsWith("/_web/")
+});
+
+// src/http/server.ts
+function createServer() {
+  return createApiServer({
+    authHook,
+    onUnhandledError: (request, error) => {
+      appLogger.error("http", `${request.method} ${request.url} -> 500`, error);
+    }
+  });
+}
+
+// src/http/routes/web/index.ts
+import * as os from "os";
+import * as path10 from "path";
+
+// ../../packages/http-routes/src/import/json-push-handler.ts
+var INVALID_SESSION_ID_MESSAGE = "sessionId must be 1-128 safe characters, start with [A-Za-z0-9_@-], and not contain '..'";
+function buildImportIdempotencyCacheKey(idempotencyKey, sessionId, dryRun, includeDryRun) {
+  if (!idempotencyKey) return null;
+  return includeDryRun ? `${idempotencyKey}:${sessionId}:${dryRun}` : `${idempotencyKey}:${sessionId}`;
+}
+function errorResult(error) {
+  return { statusCode: error.statusCode, response: errorResponse(error) };
+}
+function analysisResponse(sessionId, outcome) {
+  const analysis = {
+    totalInFile: outcome.result.totalInFile,
+    newMessageCount: outcome.result.newMessageCount,
+    duplicateCount: outcome.result.duplicateCount
+  };
+  return successResponse({
+    sessionId,
+    created: outcome.result.created,
+    dryRun: true,
+    analysis: outcome.result.created ? { ...analysis, newMemberCount: outcome.result.newMemberCount } : analysis
+  });
+}
+function createJsonPushImportHandler(options) {
+  const idempotencyCache = options.idempotencyCache ?? new ImportIdempotencyCache();
+  return async (request) => {
+    const contentType = request.contentType.toLowerCase();
+    if (!contentType.includes("application/json")) {
+      return errorResult(invalidPayload("Content-Type must be application/json (JSONL is not yet supported)"));
+    }
+    if (!isValidImportSessionId(request.sessionId)) {
+      return errorResult(invalidPayload(INVALID_SESSION_ID_MESSAGE));
+    }
+    const dryRun = request.dryRun === true;
+    if (dryRun && !options.analyze) {
+      return errorResult(invalidPayload("X-Dry-Run is not yet supported"));
+    }
+    const cacheKey = buildImportIdempotencyCacheKey(
+      request.idempotencyKey,
+      request.sessionId,
+      dryRun,
+      options.includeDryRunInIdempotencyKey === true
+    );
+    if (cacheKey) {
+      const start = idempotencyCache.start(cacheKey, hashImportBody(request.body));
+      if (start.status === "conflict") return errorResult(idempotencyConflict());
+      if (start.status === "pending") return errorResult(idempotencyPending());
+      if (start.status === "success") return { statusCode: 200, response: start.response };
+    }
+    let acquired = false;
+    try {
+      if (options.acquire) {
+        acquired = await options.acquire(request.sessionId);
+        if (!acquired) {
+          if (cacheKey) idempotencyCache.fail(cacheKey);
+          return errorResult(importInProgress(options.importInProgressMessage));
         }
       }
-    });
+      const payload = request.body ?? {};
+      if (dryRun) {
+        const outcome2 = await options.analyze(request.sessionId, payload);
+        if (!outcome2.ok) {
+          if (cacheKey) idempotencyCache.fail(cacheKey);
+          const error = outcome2.reason === "invalid_payload" ? invalidPayload(outcome2.message) : importFailed(outcome2.message);
+          return errorResult(error);
+        }
+        const response2 = analysisResponse(request.sessionId, outcome2);
+        if (cacheKey) idempotencyCache.success(cacheKey, response2);
+        return { statusCode: 200, response: response2 };
+      }
+      const outcome = await options.execute(request.sessionId, payload);
+      if (!outcome.ok) {
+        if (cacheKey) idempotencyCache.fail(cacheKey);
+        const error = outcome.reason === "import_in_progress" ? importInProgress(options.importInProgressMessage) : outcome.reason === "invalid_payload" ? invalidPayload(outcome.message) : importFailed(outcome.message);
+        return errorResult(error);
+      }
+      const response = successResponse(outcome.result);
+      if (cacheKey) idempotencyCache.success(cacheKey, response);
+      try {
+        await options.onSuccess?.(outcome.result);
+      } catch (error) {
+        options.onError?.(error);
+      }
+      return { statusCode: 200, response };
+    } catch (error) {
+      if (cacheKey) idempotencyCache.fail(cacheKey);
+      options.onError?.(error);
+      const apiError = apiErrorFromUnknown(error);
+      if (apiError) return errorResult(apiError);
+      return errorResult(importFailed(error instanceof Error ? error.message : "Import process error"));
+    } finally {
+      if (acquired) {
+        try {
+          await options.release?.(request.sessionId);
+        } catch (error) {
+          options.onError?.(error);
+        }
+      }
+    }
+  };
+}
+
+// ../../packages/http-routes/src/routes/rest/imports.ts
+function registerImportRoutes(server2, ctx) {
+  const handleJsonPushImport = createJsonPushImportHandler({
+    execute: (sessionId, payload) => pushImport(ctx.dbManager, sessionId, payload),
+    onError: (error) => appLogger.error("http-import", "Push import request failed", error)
   });
+  server2.post(
+    "/api/v1/imports/:sessionId",
+    async (request, reply) => {
+      const idempotencyKey = request.headers["idempotency-key"];
+      const result = await handleJsonPushImport({
+        sessionId: request.params.sessionId,
+        body: request.body,
+        contentType: request.headers["content-type"] || "",
+        idempotencyKey: typeof idempotencyKey === "string" ? idempotencyKey : void 0,
+        dryRun: request.headers["x-dry-run"] === "true"
+      });
+      return reply.code(result.statusCode).send(result.response);
+    }
+  );
 }
 
-// ../../packages/http-routes/src/routes/sessions.ts
-var EXPORT_MESSAGE_LIMIT = 1e5;
-function ensureDb(ctx, sessionId) {
-  const db = ctx.dbManager.open(sessionId);
-  if (!db) throw sessionNotFound(sessionId);
-  return db;
+// ../../packages/http-routes/src/routes/rest/session-provider.ts
+function normalizeRestSessionMember(member) {
+  return {
+    ...member,
+    name: member.name || member.groupNickname || member.accountName || member.platformId
+  };
 }
-function registerRestSessionRoutes(server2, ctx) {
-  server2.get("/api/v1/sessions", async () => {
-    const sessionIds = ctx.dbManager.listSessionIds();
-    const sessions = sessionIds.map((id) => {
-      const db = ctx.dbManager.open(id);
+function getSummary(dbManager2, sessionId) {
+  const db = dbManager2.open(sessionId);
+  if (!db) return null;
+  const info = getSessionInfo(db);
+  if (!info) return null;
+  return {
+    id: sessionId,
+    name: info.name,
+    platform: info.platform,
+    type: info.type,
+    groupId: info.groupId || void 0,
+    messageCount: info.messageCount,
+    memberCount: info.memberCount,
+    firstTimestamp: info.firstMessageTs,
+    lastTimestamp: info.lastMessageTs,
+    importedAt: info.importedAt
+  };
+}
+function getDetail(dbManager2, sessionId) {
+  const summary = getSummary(dbManager2, sessionId);
+  if (!summary) return null;
+  const db = dbManager2.open(sessionId);
+  if (!db) return null;
+  return {
+    ...summary,
+    lastPlatformMessageId: getLastPlatformMessageId(db),
+    importedAt: summary.importedAt ?? 0
+  };
+}
+function createDatabaseRestSessionProvider(dbManager2) {
+  return {
+    countSessions: () => dbManager2.listSessionIds().length,
+    listSessions: () => dbManager2.listSessionIds().map((sessionId) => getSummary(dbManager2, sessionId)).filter((session) => session !== null),
+    getSession: (sessionId) => getDetail(dbManager2, sessionId),
+    queryMessages: (sessionId, query) => {
+      const db = dbManager2.open(sessionId);
+      if (!db) return null;
+      return queryMessages(db, {
+        keyword: query.keyword,
+        startTs: query.startTime,
+        endTs: query.endTime,
+        senderId: query.senderId,
+        limit: query.limit,
+        offset: query.offset
+      });
+    },
+    getMembers: (sessionId) => {
+      const db = dbManager2.open(sessionId);
+      return db ? getMembersWithAliases(db).map(normalizeRestSessionMember) : null;
+    },
+    getOverview: (sessionId) => {
+      const db = dbManager2.open(sessionId);
+      if (!db) return null;
+      const overview = getSessionOverview(db);
+      const memberActivity = getMemberActivity(db);
+      const typeDistribution = getMessageTypeStats(db);
+      const messageTypeDistribution = {};
+      for (const item of typeDistribution) {
+        messageTypeDistribution[String(item.type)] = item.count;
+      }
+      return {
+        messageCount: overview.totalMessages,
+        memberCount: overview.totalMembers,
+        timeRange: {
+          start: overview.firstMessageTs ?? 0,
+          end: overview.lastMessageTs ?? 0
+        },
+        messageTypeDistribution,
+        topMembers: memberActivity.slice(0, 10).map((member) => ({
+          platformId: member.platformId,
+          name: member.name,
+          messageCount: member.messageCount,
+          percentage: member.percentage
+        }))
+      };
+    },
+    executeReadonlySql: (sessionId, sql) => {
+      const db = dbManager2.open(sessionId);
+      return db ? executeReadonlySql(db, sql) : null;
+    },
+    getExportData: (sessionId, limit) => {
+      const db = dbManager2.open(sessionId);
       if (!db) return null;
-      const info = getSessionInfo(db);
-      if (!info) return null;
+      const session = getDetail(dbManager2, sessionId);
+      const meta = getSessionMeta(db);
+      if (!session || !meta) return null;
+      const members = getMembersWithAliases(db);
+      const messages = queryMessages(db, { limit, offset: 0 }).messages;
       return {
-        id,
-        name: info.name,
-        platform: info.platform,
-        type: info.type,
-        groupId: info.groupId || void 0,
-        messageCount: info.messageCount,
-        memberCount: info.memberCount,
-        firstTimestamp: info.firstMessageTs,
-        lastTimestamp: info.lastMessageTs
+        members,
+        messages
       };
-    }).filter(Boolean);
-    return successResponse(sessions);
+    }
+  };
+}
+
+// ../../packages/http-routes/src/routes/rest/sessions.ts
+var EXPORT_MESSAGE_LIMIT = 1e5;
+function registerRestSessionRoutes(server2, provider) {
+  server2.get("/api/v1/sessions", async () => {
+    return successResponse(await provider.listSessions());
   });
   server2.get("/api/v1/sessions/:id", async (request) => {
-    const db = ensureDb(ctx, request.params.id);
-    const info = getSessionInfo(db);
-    if (!info) throw sessionNotFound(request.params.id);
-    return successResponse({
-      id: request.params.id,
-      name: info.name,
-      platform: info.platform,
-      type: info.type,
-      groupId: info.groupId || void 0,
-      messageCount: info.messageCount,
-      memberCount: info.memberCount,
-      firstTimestamp: info.firstMessageTs,
-      lastTimestamp: info.lastMessageTs,
-      lastPlatformMessageId: getLastPlatformMessageId(db),
-      importedAt: info.importedAt
-    });
+    const session = await provider.getSession(request.params.id);
+    if (!session) throw sessionNotFound(request.params.id);
+    return successResponse(session);
   });
   server2.get("/api/v1/sessions/:id/messages", async (request) => {
     const { id } = request.params;
-    const db = ensureDb(ctx, id);
     const page = Math.max(1, parseInt(request.query.page || "1", 10) || 1);
     const limit = Math.min(1e3, Math.max(1, parseInt(request.query.limit || "100", 10) || 100));
     const offset = (page - 1) * limit;
     const { startTime, endTime, keyword, senderId } = request.query;
-    const result = queryMessages(db, {
+    const result = await provider.queryMessages(id, {
       keyword: keyword || void 0,
-      startTs: startTime ? parseInt(startTime, 10) : void 0,
-      endTs: endTime ? parseInt(endTime, 10) : void 0,
+      startTime: startTime ? parseInt(startTime, 10) : void 0,
+      endTime: endTime ? parseInt(endTime, 10) : void 0,
       senderId: senderId ? parseInt(senderId, 10) : void 0,
       limit,
       offset
     });
+    if (!result) throw sessionNotFound(id);
     return successResponse({
       messages: result.messages,
       total: result.total,
       page,
       limit,
-      totalPages: result.totalPages
+      totalPages: result.totalPages ?? Math.ceil(result.total / limit)
     });
   });
   server2.get("/api/v1/sessions/:id/members", async (request) => {
-    const db = ensureDb(ctx, request.params.id);
-    const members = getMembers(db);
+    const members = await provider.getMembers(request.params.id);
+    if (!members) throw sessionNotFound(request.params.id);
     return successResponse(members);
   });
   server2.get("/api/v1/sessions/:id/stats/overview", async (request) => {
-    const { id } = request.params;
-    const db = ensureDb(ctx, id);
-    const overview = getSessionOverview(db);
-    const memberActivity = getMemberActivity(db);
-    const typeDistribution = getMessageTypeStats(db);
-    const typeMap = {};
-    for (const item of typeDistribution) {
-      typeMap[String(item.type)] = item.count;
-    }
-    const topMembers = memberActivity.slice(0, 10).map((m) => ({
-      platformId: m.platformId,
-      name: m.name,
-      messageCount: m.messageCount,
-      percentage: m.percentage
-    }));
-    return successResponse({
-      messageCount: overview.totalMessages,
-      memberCount: overview.totalMembers,
-      timeRange: {
-        start: overview.firstMessageTs ?? 0,
-        end: overview.lastMessageTs ?? 0
-      },
-      messageTypeDistribution: typeMap,
-      topMembers
-    });
+    const overview = await provider.getOverview(request.params.id);
+    if (!overview) throw sessionNotFound(request.params.id);
+    return successResponse(overview);
   });
   server2.post("/api/v1/sessions/:id/sql", async (request, reply) => {
     const { id } = request.params;
-    const db = ensureDb(ctx, id);
     const { sql } = request.body || {};
     if (!sql || typeof sql !== "string") {
       const err = sqlExecutionError("Missing sql parameter");
       return reply.code(err.statusCode).send(errorResponse(err));
     }
     try {
-      const result = executeReadonlySql(db, sql);
+      const result = await provider.executeReadonlySql(id, sql);
+      if (result === null) {
+        const err = sessionNotFound(id);
+        return reply.code(err.statusCode).send(errorResponse(err));
+      }
       return successResponse(result);
     } catch (err) {
       const message = err instanceof Error ? err.message : "SQL execution error";
@@ -465,16 +659,14 @@ function registerRestSessionRoutes(server2, ctx) {
   });
   server2.get("/api/v1/sessions/:id/export", async (request, reply) => {
     const { id } = request.params;
-    const db = ensureDb(ctx, id);
-    const meta = getSessionMeta(db);
-    if (!meta) throw sessionNotFound(id);
-    const overview = getSessionOverview(db);
-    if (overview.totalMessages > EXPORT_MESSAGE_LIMIT) {
-      const err = exportTooLarge(overview.totalMessages, EXPORT_MESSAGE_LIMIT);
+    const session = await provider.getSession(id);
+    if (!session) throw sessionNotFound(id);
+    if (session.messageCount > EXPORT_MESSAGE_LIMIT) {
+      const err = exportTooLarge(session.messageCount, EXPORT_MESSAGE_LIMIT);
       return reply.code(err.statusCode).send(errorResponse(err));
     }
-    const members = getMembersDetailed(db);
-    const allMessages = queryMessages(db, { limit: EXPORT_MESSAGE_LIMIT, offset: 0 });
+    const exportData = await provider.getExportData(id, EXPORT_MESSAGE_LIMIT);
+    if (!exportData) throw sessionNotFound(id);
     const chatLabFormat = {
       chatlab: {
         version: "0.0.2",
@@ -482,17 +674,18 @@ function registerRestSessionRoutes(server2, ctx) {
         generator: "ChatLab API"
       },
       meta: {
-        name: meta.name,
-        platform: meta.platform,
-        type: meta.type,
-        groupId: meta.groupId || void 0
+        name: session.name,
+        platform: session.platform,
+        type: session.type,
+        groupId: session.groupId || void 0
       },
-      members: members.map((m) => ({
+      members: exportData.members.map((m) => ({
         platformId: m.platformId,
         accountName: m.accountName || m.platformId,
-        groupNickname: m.groupNickname || void 0
+        groupNickname: m.groupNickname || void 0,
+        aliases: Array.isArray(m.aliases) && m.aliases.length > 0 ? m.aliases : void 0
       })),
-      messages: allMessages.messages.map((msg) => ({
+      messages: exportData.messages.map((msg) => ({
         sender: msg.senderPlatformId,
         accountName: msg.senderName || void 0,
         timestamp: msg.timestamp,
@@ -504,1549 +697,1613 @@ function registerRestSessionRoutes(server2, ctx) {
   });
 }
 
-// ../../packages/http-routes/src/routes/imports.ts
-function registerImportRoutes(server2, ctx) {
-  const idempotencyCache = new ImportIdempotencyCache();
-  server2.post(
-    "/api/v1/imports/:sessionId",
-    async (request, reply) => {
-      const { sessionId } = request.params;
-      const contentType = request.headers["content-type"] || "";
-      if (!contentType.includes("application/json")) {
-        const err = invalidPayload("Content-Type must be application/json (JSONL is not yet supported)");
-        return reply.code(err.statusCode).send(errorResponse(err));
-      }
-      if (request.headers["x-dry-run"] === "true") {
-        const err = invalidPayload("X-Dry-Run is not yet supported");
-        return reply.code(err.statusCode).send(errorResponse(err));
-      }
-      const idempotencyKey = request.headers["idempotency-key"];
-      const cacheKey = typeof idempotencyKey === "string" && idempotencyKey ? `${idempotencyKey}:${sessionId}` : null;
-      if (cacheKey) {
-        const start = idempotencyCache.start(cacheKey, hashImportBody(request.body));
-        if (start.status === "conflict") {
-          const err = idempotencyConflict();
-          return reply.code(err.statusCode).send(errorResponse(err));
-        }
-        if (start.status === "pending") {
-          const err = idempotencyPending();
-          return reply.code(err.statusCode).send(errorResponse(err));
-        }
-        if (start.status === "success") return start.response;
-      }
-      try {
-        const outcome = await pushImport(ctx.dbManager, sessionId, request.body ?? {});
-        if (!outcome.ok) {
-          if (cacheKey) idempotencyCache.fail(cacheKey);
-          if (outcome.reason === "import_in_progress") {
-            const err2 = importInProgress();
-            return reply.code(err2.statusCode).send(errorResponse(err2));
-          }
-          if (outcome.reason === "invalid_payload") {
-            const err2 = invalidPayload(outcome.message);
-            return reply.code(err2.statusCode).send(errorResponse(err2));
-          }
-          const err = importFailed(outcome.message);
-          return reply.code(err.statusCode).send(errorResponse(err));
-        }
-        const response = successResponse(outcome.result);
-        if (cacheKey) idempotencyCache.success(cacheKey, response);
-        return response;
-      } catch (error) {
-        if (cacheKey) idempotencyCache.fail(cacheKey);
-        throw error;
-      }
+// ../../packages/http-routes/src/routes/rest/system.ts
+function registerSystemRoutes(server2, ctx) {
+  server2.get("/api/v1/status", async () => {
+    let sessionCount = 0;
+    try {
+      sessionCount = await ctx.countSessions();
+    } catch {
     }
-  );
-}
-
-// ../../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 () => {
-    const aiChatCounts = ctx.aiChatManager?.getAIChatCountsBySession();
-    return session_service_exports.listAnalysisSessions(adapter, {
-      enrichSession: aiChatCounts?.size ? (dto) => ({ ...dto, aiConversationCount: aiChatCounts.get(dto.id) ?? 0 }) : void 0
+    return successResponse({
+      name: "ChatLab API",
+      version: ctx.getVersion(),
+      uptime: Math.floor(process.uptime()),
+      sessionCount
     });
   });
-  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) => {
-    const { id } = request.params;
-    try {
-      const deleted = session_service_exports.deleteSession(adapter, id);
-      if (!deleted) {
-        return reply.code(404).send({ success: false, error: "File not found" });
+  server2.get("/api/v1/schema", async () => {
+    return successResponse({
+      format: "ChatLab Format",
+      version: "0.0.2",
+      spec: {
+        chatlab: {
+          type: "object",
+          required: ["version"],
+          properties: {
+            version: { type: "string" },
+            exportedAt: { type: "number" },
+            generator: { type: "string" }
+          }
+        },
+        meta: {
+          type: "object",
+          required: ["name", "platform", "type"],
+          properties: {
+            name: { type: "string" },
+            platform: {
+              type: "string",
+              enum: ["qq", "wechat", "telegram", "discord", "line", "whatsapp", "instagram", "unknown"]
+            },
+            type: { type: "string", enum: ["group", "private"] },
+            groupId: { type: "string" }
+          }
+        },
+        members: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["platformId", "accountName"],
+            properties: {
+              platformId: { type: "string" },
+              accountName: { type: "string" },
+              groupNickname: { type: "string" },
+              avatar: { type: "string" }
+            }
+          }
+        },
+        messages: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["sender", "timestamp", "type"],
+            properties: {
+              platformMessageId: { type: "string" },
+              sender: { type: "string" },
+              accountName: { type: "string" },
+              groupNickname: { type: "string" },
+              timestamp: { type: "number" },
+              type: { type: "number" },
+              content: { type: ["string", "null"] },
+              replyToMessageId: { type: "string" }
+            }
+          }
+        }
       }
-      return { success: true };
-    } catch (err) {
-      return reply.code(500).send({ success: false, error: String(err) });
-    }
-  });
-  server2.patch("/_web/sessions/:id/name", async (request) => {
-    session_service_exports.renameSession(adapter, request.params.id, request.body.name);
-    return { success: true };
-  });
-  server2.patch(
-    "/_web/sessions/:id/owner",
-    async (request) => {
-      session_service_exports.updateSessionOwnerId(adapter, request.params.id, request.body.ownerId ?? null);
-      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
-function registerMemberRoutes(server2, ctx) {
-  const { sessionAdapter: adapter } = ctx;
-  server2.get("/_web/sessions/:id/members", async (request) => {
-    return member_service_exports.getMembers(adapter, request.params.id);
-  });
-  server2.get("/_web/sessions/:id/members/paginated", async (request) => {
-    return member_service_exports.getMembersPaginated(adapter, request.params.id, {
-      page: parseInt(request.query.page || "1", 10),
-      pageSize: parseInt(request.query.pageSize || "20", 10),
-      search: request.query.search,
-      sortOrder: request.query.sortOrder === "asc" ? "asc" : "desc"
+// ../../packages/http-routes/src/routes/rest/register.ts
+function registerRestRoutes(server2, ctx) {
+  const sessionProvider = ctx.restSessionProvider ?? createDatabaseRestSessionProvider(ctx.dbManager);
+  registerSystemRoutes(server2, {
+    getVersion: ctx.getVersion,
+    countSessions: sessionProvider.countSessions
+  });
+  registerRestSessionRoutes(server2, sessionProvider);
+  registerImportRoutes(server2, ctx);
+}
+
+// ../../packages/http-routes/src/routes/web/ai-agent-stream.ts
+var activeAgentAborts = /* @__PURE__ */ new Map();
+function registerAiAgentStreamRoutes(server2, ctx) {
+  if (!ctx.runAgentStream) return;
+  const runAgentStream = ctx.runAgentStream;
+  server2.post("/_web/ai/agent/stream", async (request, reply) => {
+    const requestId = `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const abortController = new AbortController();
+    activeAgentAborts.set(requestId, abortController);
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "X-Request-Id": requestId
     });
-  });
-  server2.patch(
-    "/_web/sessions/:id/members/:memberId/aliases",
-    async (request) => {
-      const memberId = parseInt(request.params.memberId, 10);
-      member_service_exports.updateMemberAliases(adapter, request.params.id, memberId, request.body.aliases);
-      return { success: true };
-    }
-  );
-  server2.delete(
-    "/_web/sessions/:id/members/:memberId",
-    async (request) => {
-      const memberId = parseInt(request.params.memberId, 10);
-      member_service_exports.deleteMember(adapter, request.params.id, memberId);
-      return { success: true };
+    let emittedDone = false;
+    const safeSendSSE = (event, data) => {
+      if (reply.raw.writableEnded || reply.raw.destroyed) return;
+      reply.raw.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+    };
+    const safeEnd = () => {
+      if (reply.raw.writableEnded || reply.raw.destroyed) return;
+      reply.raw.end();
+    };
+    safeSendSSE("meta", { requestId });
+    reply.raw.on("close", () => {
+      if (!abortController.signal.aborted) {
+        abortController.abort();
+      }
+      activeAgentAborts.delete(requestId);
+    });
+    try {
+      await runAgentStream(
+        request.body,
+        (chunk) => {
+          if (chunk.type === "done") emittedDone = true;
+          safeSendSSE(chunk.type, chunk);
+        },
+        abortController.signal
+      );
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      safeSendSSE("error", { type: "error", error: { name: "ServerError", message: msg } });
+    } finally {
+      if (!emittedDone) safeSendSSE("done", { type: "done", isFinished: true });
+      activeAgentAborts.delete(requestId);
+      safeEnd();
     }
-  );
-  server2.post(
-    "/_web/sessions/:id/members/merge",
-    async (request) => {
-      const { memberId1, memberId2 } = request.body;
-      member_service_exports.mergeMembers(adapter, request.params.id, memberId1, memberId2);
+  });
+  server2.post("/_web/ai/agent/abort", async (request) => {
+    const { requestId } = request.body;
+    const controller = activeAgentAborts.get(requestId);
+    if (controller) {
+      controller.abort();
+      activeAgentAborts.delete(requestId);
       return { success: true };
     }
-  );
-  server2.get(
-    "/_web/sessions/:id/members/:memberId/history",
-    async (request) => {
-      const memberId = parseInt(request.params.memberId, 10);
-      return member_service_exports.getMemberNameHistory(adapter, request.params.id, memberId);
-    }
-  );
+    return { success: false };
+  });
 }
 
-// ../../packages/http-routes/src/routes/web/contacts.ts
-function registerContactsRoutes(server2, ctx) {
-  const service = ctx.contactsService ?? createContactsService({
-    adapter: ctx.sessionAdapter,
-    pathProvider: ctx.pathProvider,
-    runtimeIdentity: ctx.runtimeIdentity,
-    nativeBinding: ctx.nativeBinding
+// ../../packages/http-routes/src/routes/web/ai-assistants.ts
+function registerAiAssistantRoutes(server2, ctx) {
+  server2.get("/_web/ai/tools/catalog", async () => {
+    return BUILTIN_TOOL_CATALOG;
   });
-  server2.addHook("onClose", async () => {
-    await service.close();
+  const mgr = ctx.assistantManager;
+  if (!mgr) return;
+  server2.get("/_web/ai/assistants", async () => {
+    return mgr.getAllAssistants();
   });
-  server2.get("/_web/contacts", async (request) => {
-    return service.getContactsPage({
-      acceptStale: isTruthy(request.query.acceptStale),
-      timeRangePreset: parseContactsTimeRangePreset(request.query.timeRange),
-      pool: parseContactPool(request.query.pool),
-      page: parsePositiveInteger(request.query.page),
-      pageSize: parsePositiveInteger(request.query.pageSize),
-      query: request.query.q
-    });
+  server2.get("/_web/ai/assistants/:id/upgrade-status", async (request) => {
+    return mgr.getAssistantUpgradeInfo(request.params.id);
   });
-  server2.post("/_web/contacts/recompute", async (request) => {
-    return service.startRecompute({
-      timeRangePreset: parseContactsTimeRangePreset(request.query.timeRange),
-      pool: parseContactPool(request.query.pool),
-      page: parsePositiveInteger(request.query.page),
-      pageSize: parsePositiveInteger(request.query.pageSize),
-      query: request.query.q
-    });
+  server2.get("/_web/ai/assistants/:id", async (request, reply) => {
+    const config = mgr.getAssistantConfig(request.params.id);
+    if (!config) return reply.code(404).send({ error: "Not found" });
+    return config;
   });
-  server2.get("/_web/contacts/:key/detail", async (request) => {
-    return service.getContactDetail(request.params.key, {
-      acceptStale: isTruthy(request.query.acceptStale),
-      timeRangePreset: parseContactsTimeRangePreset(request.query.timeRange)
-    });
+  server2.post("/_web/ai/assistants", async (request) => {
+    return mgr.createAssistant(request.body);
   });
-  server2.put(
-    "/_web/contacts/:key/mark-friend",
-    async (request) => {
-      return service.markContactAsFriend(request.params.key, {
-        timeRangePreset: parseContactsTimeRangePreset(request.query.timeRange)
-      });
-    }
-  );
-  server2.delete(
-    "/_web/contacts/:key/mark-friend",
-    async (request) => {
-      return service.unmarkContactAsFriend(request.params.key, {
-        timeRangePreset: parseContactsTimeRangePreset(request.query.timeRange)
-      });
-    }
-  );
-}
-function isTruthy(value) {
-  return value === "1" || value === "true" || value === "yes";
-}
-function parseContactsTimeRangePreset(value) {
-  return CONTACTS_TIME_RANGE_PRESETS.includes(value) ? value : "1y";
-}
-function parseContactPool(value) {
-  return value === "friend" || value === "non_friend" ? value : void 0;
-}
-function parsePositiveInteger(value) {
-  if (!value) return void 0;
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed)) return void 0;
-  return Math.max(1, Math.trunc(parsed));
-}
-
-// ../../packages/http-routes/src/routes/web/people-relationships.ts
-function registerPeopleRelationshipsRoutes(server2, ctx) {
-  const service = ctx.peopleRelationshipsService ?? createPeopleRelationshipsService({
-    adapter: ctx.sessionAdapter,
-    pathProvider: ctx.pathProvider,
-    runtimeIdentity: ctx.runtimeIdentity,
-    nativeBinding: ctx.nativeBinding
-  });
-  server2.addHook("onClose", async () => {
-    await service.close();
+  server2.put("/_web/ai/assistants/:id", async (request, reply) => {
+    const result = mgr.updateAssistant(request.params.id, request.body);
+    if (!result.success) return reply.code(404).send(result);
+    return result;
   });
-  server2.get("/_web/people/relationships", async (request) => {
-    return service.getGraph({
-      acceptStale: isTruthy2(request.query.acceptStale),
-      timeRangePreset: parseContactsTimeRangePreset2(request.query.timeRange),
-      graphScope: parsePeopleRelationshipsGraphScope(request.query.scope),
-      query: request.query.q
-    });
+  server2.delete("/_web/ai/assistants/:id", async (request, reply) => {
+    const result = mgr.deleteAssistant(request.params.id);
+    if (!result.success) return reply.code(400).send(result);
+    return result;
   });
-  server2.post("/_web/people/relationships/recompute", async (request) => {
-    return service.startRecompute({
-      timeRangePreset: parseContactsTimeRangePreset2(request.query.timeRange),
-      graphScope: parsePeopleRelationshipsGraphScope(request.query.scope),
-      query: request.query.q
-    });
+  server2.post("/_web/ai/assistants/:id/reset", async (request, reply) => {
+    const result = mgr.resetAssistant(request.params.id);
+    if (!result.success) return reply.code(400).send(result);
+    return result;
   });
-  server2.get(
-    "/_web/people/relationships/:key/neighborhood",
-    async (request) => {
-      return service.getNeighborhood(request.params.key, {
-        acceptStale: isTruthy2(request.query.acceptStale),
-        timeRangePreset: parseContactsTimeRangePreset2(request.query.timeRange)
-      });
+  server2.post("/_web/ai/assistants/:id/upgrade", async (request, reply) => {
+    if (typeof request.body?.backupName !== "string") {
+      return reply.code(400).send({ success: false, error: "backupName must be a string" });
     }
-  );
-}
-function isTruthy2(value) {
-  return value === "1" || value === "true" || value === "yes";
-}
-function parseContactsTimeRangePreset2(value) {
-  return CONTACTS_TIME_RANGE_PRESETS.includes(value) ? value : "1y";
-}
-function parsePeopleRelationshipsGraphScope(value) {
-  return value === "close" || value === "friends" ? value : "panorama";
-}
-
-// ../../packages/http-routes/src/routes/web/global-insight.ts
-function registerGlobalInsightRoutes(server2, ctx) {
-  const service = ctx.globalInsightService ?? createGlobalInsightService({
-    adapter: ctx.sessionAdapter,
-    pathProvider: ctx.pathProvider,
-    runtimeIdentity: ctx.runtimeIdentity,
-    nativeBinding: ctx.nativeBinding
+    const result = mgr.upgradeAssistantWithBackup(request.params.id, request.body.backupName);
+    if (!result.success) return reply.code(400).send(result);
+    return result;
   });
-  server2.addHook("onClose", async () => service.close());
-  server2.get("/_web/global-insight/annual-summary", async (request) => {
-    return service.getAnnualSummary({
-      ...parseRange(request.query),
-      acceptStale: isTruthy3(request.query.acceptStale)
-    });
+  server2.post("/_web/ai/assistants/import", async (request) => {
+    return mgr.importAssistantFromMd(request.body.rawMd);
+  });
+  server2.post("/_web/ai/assistants/import-builtin", async (request, reply) => {
+    const result = mgr.importAssistant(request.body.builtinId);
+    if (!result.success) return reply.code(400).send(result);
+    return result;
+  });
+  server2.post("/_web/ai/assistants/:id/reimport", async (request, reply) => {
+    const result = mgr.reimportAssistant(request.params.id);
+    if (!result.success) return reply.code(400).send(result);
+    return result;
   });
-  server2.post(
-    "/_web/global-insight/annual-summary/recompute",
-    async (request) => service.startRecompute(parseRange(request.query))
-  );
-}
-function parseRange(query) {
-  const mode = query.mode === "recent" ? "recent" : "year";
-  return {
-    mode,
-    year: parseInteger(query.year),
-    days: query.days === "365" ? 365 : void 0
-  };
-}
-function parseInteger(value) {
-  if (!value) return void 0;
-  const parsed = Number(value);
-  return Number.isInteger(parsed) ? parsed : void 0;
-}
-function isTruthy3(value) {
-  return value === "1" || value === "true" || value === "yes";
 }
 
-// ../../packages/http-routes/src/routes/web/preferences.ts
-function registerPreferencesRoutes(server2, ctx) {
-  const prefManager = ctx.preferencesManager ?? new PreferencesManager(ctx.pathProvider.getSystemDir());
-  server2.get("/_web/preferences", async () => {
-    return prefManager.load();
+// ../../packages/http-routes/src/routes/web/ai-chats.ts
+function registerAiChatRoutes(server2, ctx) {
+  const cm = ctx.aiChatManager;
+  if (!cm) return;
+  server2.post("/_web/ai/chats", async (request) => {
+    const { sessionId, title, assistantId } = request.body;
+    return cm.createAIChat(sessionId, title, assistantId);
   });
-  server2.patch("/_web/preferences", async (request) => {
-    return prefManager.save(request.body);
+  server2.get("/_web/ai/chats", async (request) => {
+    const { sessionId } = request.query;
+    if (!sessionId) return [];
+    return cm.getAIChats(sessionId);
   });
-  server2.get("/_web/preferences/ui-config", async () => {
-    const config = loadConfig();
-    return config.ui;
+  server2.get("/_web/ai/chats/:id", async (request, reply) => {
+    const conv = cm.getAIChat(request.params.id);
+    if (!conv) return reply.code(404).send({ error: "AI chat not found" });
+    return conv;
   });
-  server2.patch("/_web/preferences/ui-config", async (request) => {
-    try {
-      for (const [key, value] of Object.entries(request.body)) {
-        if (value !== void 0) {
-          writeConfigField("ui", key, value);
-        }
-      }
-      return { success: true };
-    } catch (err) {
-      return { success: false, error: err instanceof Error ? err.message : String(err) };
+  server2.put("/_web/ai/chats/:id/title", async (request) => {
+    return cm.updateAIChatTitle(request.params.id, request.body.title);
+  });
+  server2.delete("/_web/ai/chats/:id", async (request) => {
+    return cm.deleteAIChat(request.params.id);
+  });
+  server2.post("/_web/ai/chats/:id/messages", async (request) => {
+    const { role, content, dataKeywords, dataMessageCount, contentBlocks, tokenUsage } = request.body;
+    return cm.addMessage(
+      request.params.id,
+      role,
+      content,
+      dataKeywords,
+      dataMessageCount,
+      contentBlocks,
+      tokenUsage
+    );
+  });
+  server2.get("/_web/ai/chats/:id/messages", async (request) => {
+    return cm.getMessages(request.params.id);
+  });
+  server2.post("/_web/ai/chats/:id/messages/:messageId/delete-from", async (request, reply) => {
+    const { id, messageId } = request.params;
+    if (!id || typeof id !== "string" || !messageId || typeof messageId !== "string") {
+      return reply.code(400).send({ error: "aiChatId and messageId are required" });
     }
+    cm.deleteMessagesFrom(id, messageId);
+    return { success: true };
   });
-  server2.get("/_web/preferences/locale", async () => {
-    const config = loadConfig();
-    return { lang: config.locale.lang };
+  server2.post("/_web/ai/chats/:id/fork", async (request, reply) => {
+    const { upToMessageId, title } = request.body;
+    if (!upToMessageId || typeof upToMessageId !== "string") {
+      return reply.code(400).send({ error: "upToMessageId is required" });
+    }
+    return cm.forkAIChat(request.params.id, upToMessageId, title);
   });
-  server2.patch("/_web/preferences/locale", async (request) => {
+  server2.put("/_web/ai/messages/:messageId/content", async (request, reply) => {
+    const { content } = request.body;
+    if (!content || typeof content !== "string") {
+      return reply.code(400).send({ error: "content is required" });
+    }
+    cm.updateMessageContent(request.params.messageId, content);
+    return { success: true };
+  });
+  server2.post("/_web/ai/chats/:id/messages/:messageId/delete-relink", async (request, reply) => {
+    const { id, messageId } = request.params;
+    if (!id || !messageId) {
+      return reply.code(400).send({ error: "aiChatId and messageId are required" });
+    }
+    cm.deleteAndRelinkMessage(id, messageId);
+    return { success: true };
+  });
+  server2.post("/_web/ai/chats/:id/messages/insert-after", async (request, reply) => {
+    const { afterMessageId, role, content, contentBlocks, tokenUsage } = request.body;
+    if (!afterMessageId || typeof afterMessageId !== "string") {
+      return reply.code(400).send({ error: "afterMessageId is required" });
+    }
+    return cm.insertMessageAfter(request.params.id, afterMessageId, role, content, contentBlocks, tokenUsage);
+  });
+  server2.get("/_web/ai/chats/:id/token-usage", async (request) => {
+    return cm.getAIChatTokenUsage(request.params.id);
+  });
+  server2.get("/_web/ai/debug/schema", async () => {
+    return cm.getAiSchema();
+  });
+  server2.post("/_web/ai/debug/execute-sql", async (request, reply) => {
+    const { sql } = request.body;
+    if (!sql || typeof sql !== "string") {
+      return reply.code(400).send({ error: "sql is required" });
+    }
     try {
-      writeConfigField("locale", "lang", request.body.lang);
-      return { success: true };
-    } catch (err) {
-      return { success: false, error: err instanceof Error ? err.message : String(err) };
+      return cm.executeAiSQL(sql);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return reply.code(400).send({ error: msg });
     }
   });
+  server2.post("/_web/ai/debug/clear-debug-context", async () => {
+    const cleared = cm.clearAllDebugContext();
+    return { success: true, cleared };
+  });
+  server2.get("/_web/ai/chats/:id/estimate-tokens", async (request) => {
+    const history = cm.getHistoryForAgent(request.params.id);
+    const tokens = countMessagesTokens(history.map((m) => ({ role: m.role, content: m.content })));
+    return { success: true, tokens, messageCount: history.length };
+  });
 }
 
-// ../../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;
-  if (!startTs && !endTs && !memberId) return void 0;
-  const filter = {};
-  if (startTs) filter.startTs = parseInt(startTs, 10);
-  if (endTs) filter.endTs = parseInt(endTs, 10);
-  if (memberId) filter.memberId = parseInt(memberId, 10);
-  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(",")}}`;
+// ../../packages/http-routes/src/routes/web/ai-llm-stream.ts
+function registerAiLlmStreamRoutes(server2, ctx) {
+  const store = ctx.llmConfigStore;
+  if (!store) return;
+  server2.post("/_web/ai/llm/chat-stream", async (request, reply) => {
+    const { messages, options } = request.body;
+    const llmConfig = store.getDefaultAssistantConfig();
+    if (!llmConfig) {
+      return reply.code(400).send({ success: false, error: "LLM service not configured" });
+    }
+    const piModel = buildPiModel(llmConfig);
+    const abortController = new AbortController();
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    reply.raw.on("close", () => {
+      if (!abortController.signal.aborted) abortController.abort();
+    });
+    const sendChunk = (data) => {
+      if (reply.raw.writableEnded || reply.raw.destroyed) return;
+      reply.raw.write(`event: chunk
+data: ${JSON.stringify(data)}
+
+`);
+    };
+    try {
+      await runSimpleLlmStream({
+        messages,
+        apiKey: llmConfig.apiKey,
+        piModel,
+        temperature: options?.temperature,
+        maxTokens: options?.maxTokens,
+        onChunk: sendChunk,
+        abortSignal: abortController.signal
+      });
+    } catch (error) {
+      if (abortController.signal.aborted) return;
+      const msg = error instanceof Error ? error.message : String(error);
+      sendChunk({ content: "", isFinished: true, finishReason: "error", error: msg });
+    } finally {
+      if (!reply.raw.writableEnded && !reply.raw.destroyed) reply.raw.end();
+    }
+  });
 }
-function buildAnalyticsCacheKey(namespace, params) {
-  return `${namespace}:${canonical(params)}`;
+
+// ../../packages/http-routes/src/routes/web/ai-llm.ts
+function hasRealApiKey(apiKey) {
+  return !!apiKey && apiKey !== "sk-no-key-required";
 }
-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);
+function toConfigDisplay(config) {
+  const { apiKey: _raw, ...rest } = config;
+  return { ...rest, apiKey: "", apiKeySet: hasRealApiKey(String(_raw || "")) };
 }
-
-// ../../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);
+function registerAiLlmRoutes(server2, ctx) {
+  const store = ctx.llmConfigStore;
+  const aiDataDir = ctx.aiDataDir;
+  if (!store || !aiDataDir) return;
+  server2.get("/_web/ai/llm/has-config", async () => {
+    return store.hasActiveConfig();
   });
-  server2.get("/_web/sessions/:id/time-range", async (request) => {
-    const db = adapter.ensureReadonly(request.params.id);
-    return getTimeRange(db);
+  server2.get("/_web/ai/llm/configs", async () => {
+    const data = store.loadStore();
+    return {
+      configs: data.configs.map((c) => toConfigDisplay(c)),
+      defaultAssistant: data.defaultAssistant,
+      fastModel: data.fastModel
+    };
   });
-  server2.get(
-    "/_web/sessions/:id/stats/member-activity",
-    async (request) => {
-      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 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 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 id = request.params.id;
-      const filter = parseTimeFilter(request.query);
-      return cached("weekday", id, { ...filter }, () => getWeekdayActivity(adapter.ensureReadonly(id), filter));
+  server2.post("/_web/ai/llm/configs", async (request) => {
+    const result = store.addConfig(request.body);
+    if (result.success && result.config) {
+      return { ...result, config: toConfigDisplay(result.config) };
     }
-  );
-  server2.get(
-    "/_web/sessions/:id/stats/message-types",
-    async (request) => {
-      const id = request.params.id;
-      const filter = parseTimeFilter(request.query);
-      return cached("message-types", id, { ...filter }, () => getMessageTypeStats(adapter.ensureReadonly(id), filter));
+    return result;
+  });
+  server2.put("/_web/ai/llm/configs/:id", async (request) => {
+    return store.updateConfig(request.params.id, request.body);
+  });
+  server2.delete("/_web/ai/llm/configs/:id", async (request) => {
+    return store.deleteConfig(request.params.id);
+  });
+  server2.get("/_web/ai/llm/default-assistant-slot", async () => {
+    return store.getDefaultAssistantSlot();
+  });
+  server2.put("/_web/ai/llm/default-assistant-slot", async (request) => {
+    return store.setDefaultAssistantModel(request.body.configId, request.body.modelId);
+  });
+  server2.get("/_web/ai/llm/fast-model-slot", async () => {
+    return store.getFastModelSlot();
+  });
+  server2.put("/_web/ai/llm/fast-model-slot", async (request) => {
+    return store.setFastModel(request.body);
+  });
+  server2.get("/_web/ai/llm/providers", async () => {
+    return BUILTIN_PROVIDERS.map((p) => {
+      const models = getBuiltinModelsByProvider(p.id);
+      return {
+        id: p.id,
+        name: p.name,
+        defaultBaseUrl: p.defaultBaseUrl,
+        models: models.filter((m) => !m.capabilities.includes("embedding") && !m.capabilities.includes("ranking")).map((m) => ({ id: m.id, name: m.name, description: m.description }))
+      };
+    });
+  });
+  server2.get("/_web/ai/llm/provider-registry", async () => {
+    const custom = ctx.customProviderStore?.getAll() ?? [];
+    return [...BUILTIN_PROVIDERS, ...custom];
+  });
+  server2.get("/_web/ai/llm/model-catalog", async () => {
+    const custom = ctx.customModelStore?.getAll() ?? [];
+    return [...BUILTIN_MODELS, ...custom];
+  });
+  server2.post("/_web/ai/llm/custom-providers", async (request, reply) => {
+    if (!ctx.customProviderStore)
+      return reply.code(501).send({ success: false, error: "Custom providers not available" });
+    return ctx.customProviderStore.add(request.body);
+  });
+  server2.put("/_web/ai/llm/custom-providers/:id", async (request, reply) => {
+    if (!ctx.customProviderStore)
+      return reply.code(501).send({ success: false, error: "Custom providers not available" });
+    const result = ctx.customProviderStore.update(request.params.id, request.body);
+    if (!result.success) return reply.code(404).send(result);
+    return result;
+  });
+  server2.delete("/_web/ai/llm/custom-providers/:id", async (request, reply) => {
+    if (!ctx.customProviderStore)
+      return reply.code(501).send({ success: false, error: "Custom providers not available" });
+    const result = ctx.customProviderStore.delete(request.params.id);
+    if (!result.success) return reply.code(404).send(result);
+    return result;
+  });
+  server2.post("/_web/ai/llm/custom-models", async (request, reply) => {
+    if (!ctx.customModelStore) return reply.code(501).send({ success: false, error: "Custom models not available" });
+    const result = ctx.customModelStore.add(request.body);
+    if (!result.success) return reply.code(409).send(result);
+    return result;
+  });
+  server2.put("/_web/ai/llm/custom-models/:providerId/:modelId", async (request, reply) => {
+    if (!ctx.customModelStore) return reply.code(501).send({ success: false, error: "Custom models not available" });
+    const result = ctx.customModelStore.update(request.params.providerId, request.params.modelId, request.body);
+    if (!result.success) return reply.code(404).send(result);
+    return result;
+  });
+  server2.delete("/_web/ai/llm/custom-models/:providerId/:modelId", async (request, reply) => {
+    if (!ctx.customModelStore) return reply.code(501).send({ success: false, error: "Custom models not available" });
+    const result = ctx.customModelStore.delete(request.params.providerId, request.params.modelId);
+    if (!result.success) return reply.code(404).send(result);
+    return result;
+  });
+  server2.post("/_web/ai/llm/validate-key", async (request) => {
+    const { provider, apiKey, baseUrl, model, apiFormat, configId } = request.body;
+    const resolvedKey = apiKey?.trim() ? apiKey : configId ? store.getConfigById(configId)?.apiKey || "" : "";
+    return validateApiKey(provider, resolvedKey, baseUrl, model, apiFormat);
+  });
+  server2.post("/_web/ai/llm/remote-models", async (request) => {
+    const { provider, apiKey, baseUrl, apiFormat, configId } = request.body;
+    const resolvedKey = apiKey?.trim() ? apiKey : configId ? store.getConfigById(configId)?.apiKey || "" : "";
+    return fetchRemoteModels(provider, resolvedKey, baseUrl, apiFormat);
+  });
+  server2.get("/_web/ai/desensitize-rules/defaults", async (request) => {
+    return getDefaultRulesForLocale(request.query.locale ?? "zh-CN");
+  });
+  server2.post("/_web/ai/desensitize-rules/merge", async (request) => {
+    return mergeRulesForLocale(request.body.existingRules, request.body.locale, request.body.overrides ?? {});
+  });
+}
+
+// ../../packages/http-routes/src/routes/web/ai-logs.ts
+import fs from "fs";
+import path from "path";
+function findLatestAiLogPath(logsDir) {
+  const aiLogDir = path.join(logsDir, "ai");
+  if (!fs.existsSync(aiLogDir)) return null;
+  const latest = fs.readdirSync(aiLogDir).filter((name) => name.startsWith("ai_") && name.endsWith(".log")).map((name) => {
+    const filePath = path.join(aiLogDir, name);
+    const stat2 = fs.statSync(filePath);
+    return { path: filePath, mtimeMs: stat2.mtimeMs };
+  }).sort((a, b) => b.mtimeMs - a.mtimeMs)[0];
+  return latest?.path ?? null;
+}
+function resolveAiLogPath(ctx) {
+  const currentPath = ctx.getCurrentAiLogPath?.();
+  if (currentPath && fs.existsSync(currentPath)) return currentPath;
+  return findLatestAiLogPath(ctx.pathProvider.getLogsDir());
+}
+function isLoopbackAddress(address) {
+  if (!address) return true;
+  const normalized = address.replace(/^::ffff:/, "");
+  return normalized === "localhost" || normalized === "::1" || normalized === "0:0:0:0:0:0:0:1" || normalized.startsWith("127.");
+}
+function registerAiLogRoutes(server2, ctx) {
+  server2.post("/_web/ai/logs/show", async (request, reply) => {
+    if (!ctx.showInFolder) return reply.code(501).send({ success: false, error: "Not supported" });
+    if (!isLoopbackAddress(request.ip)) {
+      return { success: false, error: "Opening AI logs is only supported on this device" };
     }
-  );
-  server2.get(
-    "/_web/sessions/:id/analytics/relationship",
-    async (request) => {
-      const id = request.params.id;
-      const filter = parseTimeFilter(request.query);
-      return cached("relationship", id, { ...filter }, () => getRelationshipStats(adapter.ensureReadonly(id), filter));
+    const logPath = resolveAiLogPath(ctx);
+    if (!logPath) return { success: false, error: "No AI log files found" };
+    try {
+      await ctx.showInFolder(logPath);
+      return { success: true, path: logPath };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
     }
-  );
-  server2.get(
-    "/_web/sessions/:id/analytics/catchphrase",
-    async (request) => {
-      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 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 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 id = request.params.id;
-      const filter = parseTimeFilter(request.query);
-      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 id = request.params.id;
-      const filter = parseTimeFilter(request.query);
-      const locale = request.query.locale || "zh-CN";
-      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}` }
+}
+
+// ../../packages/http-routes/src/routes/web/ai-semantic-index.ts
+import path2 from "path";
+function registerSemanticIndexRoutes(server2, ctx) {
+  const service = ctx.semanticIndexService;
+  if (!service) {
+    if (ctx.aiDataDir) {
+      const configStore = new SemanticIndexConfigStore(path2.join(ctx.aiDataDir, SEMANTIC_INDEX_CONFIG_FILE));
+      const configResponse = (config) => ({
+        config,
+        apiKeySet: resolveSemanticIndexApiKeySet(config, ctx.resolveApiKey),
+        configured: isSemanticIndexConfigured(config)
+      });
+      server2.get("/_web/ai/semantic-index/config", async () => ({
+        ...configResponse(configStore.get()),
+        modelStatus: "idle"
+      }));
+      server2.put(
+        "/_web/ai/semantic-index/config",
+        async (request) => {
+          const config = persistSemanticIndexConfig(configStore, request.body.config, {
+            apiKey: request.body.apiKey,
+            writeAuthProfile: ctx.writeAuthProfile
+          });
+          return { ...configResponse(config), modelStatus: "idle" };
+        }
       );
     }
-  );
-  server2.get(
-    "/_web/sessions/:id/analytics/monthly-activity",
+    server2.get("/_web/ai/semantic-index/enabled", async () => ({ sessions: [] }));
+    server2.get("/_web/ai/semantic-index/status", async () => ({ status: null }));
+    server2.post("/_web/ai/semantic-index/status", async () => ({ sessions: [] }));
+    return;
+  }
+  server2.get("/_web/ai/semantic-index/config", async () => {
+    return {
+      config: await service.getConfig(),
+      apiKeySet: await service.hasApiKey(),
+      configured: await service.isConfigured(),
+      modelStatus: await service.getModelStatus()
+    };
+  });
+  server2.put(
+    "/_web/ai/semantic-index/config",
     async (request) => {
-      const id = request.params.id;
-      const filter = parseTimeFilter(request.query);
-      return cached("monthly-activity", id, { ...filter }, () => getMonthlyActivity(adapter.ensureReadonly(id), filter));
+      const config = await service.setConfig(request.body.config, { apiKey: request.body.apiKey });
+      return {
+        config,
+        apiKeySet: await service.hasApiKey(),
+        configured: await service.isConfigured(),
+        modelStatus: await service.getModelStatus()
+      };
     }
   );
-  server2.get(
-    "/_web/sessions/:id/analytics/yearly-activity",
-    async (request) => {
-      const id = request.params.id;
-      const filter = parseTimeFilter(request.query);
-      return cached("yearly-activity", id, { ...filter }, () => getYearlyActivity(adapter.ensureReadonly(id), filter));
+  server2.get("/_web/ai/semantic-index/enabled", async () => {
+    return { sessions: await service.listEnabledStatuses() };
+  });
+  server2.get("/_web/ai/semantic-index/status", async (request) => {
+    return { status: await service.status(request.query.sessionId) };
+  });
+  server2.post("/_web/ai/semantic-index/status", async (request) => {
+    return { sessions: await service.statusForSessions(request.body.sessionIds ?? []) };
+  });
+  const sessionAction = (path13, action) => {
+    server2.post(path13, async (request, reply) => {
+      const { sessionId } = request.body;
+      if (!sessionId) return reply.code(400).send({ error: "sessionId is required" });
+      await action(sessionId);
+      return { status: await service.status(sessionId) };
+    });
+  };
+  sessionAction("/_web/ai/semantic-index/enable", (id) => service.enable(id));
+  sessionAction("/_web/ai/semantic-index/remove", (id) => service.remove(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 () => {
+    await service.buildAllPending();
+    return { sessions: await service.listEnabledStatuses() };
+  });
+  server2.post("/_web/ai/semantic-index/cleanup", async () => {
+    return await 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 });
     }
   );
-  server2.get(
-    "/_web/sessions/:id/analytics/message-length-distribution",
-    async (request) => {
-      const id = request.params.id;
-      const filter = parseTimeFilter(request.query);
-      return cached(
-        "message-length-distribution",
-        id,
-        { ...filter },
-        () => getMessageLengthDistribution(adapter.ensureReadonly(id), filter)
-      );
+}
+
+// ../../packages/http-routes/src/routes/web/ai-skills.ts
+function registerAiSkillRoutes(server2, ctx) {
+  const mgr = ctx.skillManagerCore;
+  if (!mgr) return;
+  server2.get("/_web/ai/skills", async () => {
+    return mgr.getAllSkills();
+  });
+  server2.get("/_web/ai/skills/:id", async (request, reply) => {
+    const config = mgr.getSkillConfig(request.params.id);
+    if (!config) return reply.code(404).send({ error: "Not found" });
+    return config;
+  });
+  server2.post("/_web/ai/skills", async (request) => {
+    return mgr.createSkill(request.body.rawMd);
+  });
+  server2.put("/_web/ai/skills/:id", async (request, reply) => {
+    const result = mgr.updateSkill(request.params.id, request.body.rawMd);
+    if (!result.success) return reply.code(404).send(result);
+    return result;
+  });
+  server2.delete("/_web/ai/skills/:id", async (request, reply) => {
+    const result = mgr.deleteSkill(request.params.id);
+    if (!result.success) return reply.code(400).send(result);
+    return result;
+  });
+  server2.post("/_web/ai/skills/import", async (request) => {
+    return mgr.importSkillFromMd(request.body.rawMd);
+  });
+  server2.get("/_web/ai/skills/builtin-catalog", async () => {
+    return mgr.getBuiltinCatalog();
+  });
+  server2.post("/_web/ai/skills/import-builtin", async (request, reply) => {
+    const result = mgr.importSkill(request.body.builtinId);
+    if (!result.success) return reply.code(400).send(result);
+    return result;
+  });
+  server2.post("/_web/ai/skills/:id/reimport", async (request, reply) => {
+    const result = mgr.reimportSkill(request.params.id);
+    if (!result.success) return reply.code(400).send(result);
+    return result;
+  });
+}
+
+// ../../packages/http-routes/src/routes/web/ai-summaries.ts
+function createSummaryDeps(ctx) {
+  const store = ctx.llmConfigStore;
+  if (!store) return null;
+  return {
+    getLlmConfig() {
+      const config = store.getDefaultAssistantConfig();
+      if (!config) return null;
+      return config;
+    },
+    buildPiModel(config) {
+      return buildPiModel(config);
     }
-  );
-  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));
+  };
+}
+function registerAiSummaryRoutes(server2, ctx) {
+  const deps = createSummaryDeps(ctx);
+  if (!deps) return;
+  const { sessionAdapter: adapter } = ctx;
+  server2.post("/_web/sessions/:id/summaries/generate", async (request, reply) => {
+    const { segmentId, locale, forceRegenerate, strategy } = request.body;
+    const result = await summary_service_exports.generateSummary(adapter, request.params.id, segmentId, deps, {
+      locale,
+      forceRegenerate,
+      strategy
+    });
+    if ("error" in result && !result.success) {
+      return reply.code(400).send({ error: result.error });
     }
-  );
-  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)
+    return result;
+  });
+  server2.post("/_web/sessions/:id/summaries/generate-all", async (request, reply) => {
+    const { locale, forceRegenerate } = request.body;
+    const result = await summary_service_exports.generateAllSummaries(adapter, request.params.id, deps, {
+      locale,
+      forceRegenerate
+    });
+    if (result.error) {
+      return reply.code(400).send({ error: result.error });
+    }
+    return result;
+  });
+  server2.post("/_web/sessions/:id/summaries/check-can-generate", async (request) => {
+    const { segmentIds } = request.body;
+    return summary_service_exports.checkCanGenerate(adapter, request.params.id, segmentIds);
+  });
+}
+
+// ../../packages/http-routes/src/ai/tool-executor.ts
+var MAX_RESULT_CHARS = 5e5;
+async function executeRegistryTool(params, deps) {
+  const { toolName, params: toolParams, abortSignal } = params;
+  const entry = AGENT_TOOL_REGISTRY.find((tool) => tool.name === toolName);
+  if (!entry) {
+    return { success: false, error: `Tool not found: ${toolName}` };
+  }
+  try {
+    if (abortSignal.aborted) return { success: false, error: "cancelled" };
+    const execCtx = {
+      sessionId: params.sessionId,
+      abortSignal,
+      db: deps.db,
+      dataProvider: deps.dataProvider,
+      semanticIndexService: deps.semanticIndexService,
+      segmentText: deps.segmentText,
+      translateTemplate: deps.translateTemplate
+    };
+    const startTime = Date.now();
+    const result = await entry.handler(toolParams, execCtx);
+    const elapsed = Date.now() - startTime;
+    if (abortSignal.aborted) return { success: false, error: "cancelled" };
+    let details = result.data ?? void 0;
+    let truncated = false;
+    if (details) {
+      stripAvatarFields(details);
+      const raw = JSON.stringify(details);
+      if (raw.length > MAX_RESULT_CHARS) {
+        truncated = true;
+        details = { _truncated: true, _originalSize: raw.length, _preview: raw.slice(0, MAX_RESULT_CHARS) };
+      }
+    }
+    return {
+      success: true,
+      elapsed,
+      content: [{ type: "text", text: result.content }],
+      details,
+      truncated
+    };
+  } catch (error) {
+    if (abortSignal.aborted) {
+      return { success: false, error: "cancelled" };
+    }
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// ../../packages/http-routes/src/routes/web/ai-tools.ts
+var activeToolTests = /* @__PURE__ */ new Map();
+function registerAiToolRoutes(server2, ctx) {
+  server2.get("/_web/ai/tools/full-catalog", async () => {
+    return AGENT_TOOL_REGISTRY.map((tool) => ({
+      name: tool.name,
+      category: tool.category ?? "core",
+      description: tool.description,
+      parameters: tool.inputSchema ?? {}
+    }));
+  });
+  server2.post("/_web/ai/tools/execute", async (request, reply) => {
+    const { testId, toolName, params, sessionId } = request.body;
+    const entry = AGENT_TOOL_REGISTRY.find((t) => t.name === toolName);
+    if (!entry) {
+      return reply.code(404).send({ success: false, error: `Tool not found: ${toolName}` });
+    }
+    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 result = await executeRegistryTool(
+        { testId, toolName, params, sessionId, abortSignal: abortController.signal },
+        {
+          db,
+          dataProvider: new CoreDataProvider(db)
+        }
       );
+      if (!result.success && result.error !== "cancelled") {
+        appLogger.error("ai-tools", `Failed to execute tool ${toolName}`, { error: result.error });
+      }
+      return result;
+    } catch (error) {
+      if (abortController.signal.aborted) {
+        return { success: false, error: "cancelled" };
+      }
+      appLogger.error("ai-tools", `Failed to execute tool ${toolName}`, error);
+      return { success: false, error: String(error) };
+    } finally {
+      activeToolTests.delete(testId);
+    }
+  });
+  server2.post("/_web/ai/tools/cancel", async (request) => {
+    const { testId } = request.body;
+    const controller = activeToolTests.get(testId);
+    if (controller) {
+      controller.abort();
+      activeToolTests.delete(testId);
+      return { success: true };
+    }
+    return { success: false };
+  });
+}
+
+// ../../packages/http-routes/src/routes/web/register-ai.ts
+var REQUIRED_AI_DEPENDENCIES = [
+  "aiDataDir",
+  "aiChatManager",
+  "assistantManager",
+  "skillManagerCore",
+  "llmConfigStore",
+  "customProviderStore",
+  "customModelStore",
+  "runAgentStream"
+];
+function assertRequiredAiContext(ctx) {
+  const missing = REQUIRED_AI_DEPENDENCIES.filter((key) => !ctx[key]);
+  if (missing.length > 0) {
+    throw new Error(`[http-routes] requireAi is set but missing AI dependencies: ${missing.join(", ")}`);
+  }
+}
+function registerAiRoutes(server2, ctx, options) {
+  if (options?.requireAi) assertRequiredAiContext(ctx);
+  registerAiAssistantRoutes(server2, ctx);
+  registerAiSkillRoutes(server2, ctx);
+  registerAiLlmRoutes(server2, ctx);
+  registerAiLlmStreamRoutes(server2, ctx);
+  registerAiAgentStreamRoutes(server2, ctx);
+  registerAiToolRoutes(server2, ctx);
+  registerAiChatRoutes(server2, ctx);
+  registerAiSummaryRoutes(server2, ctx);
+  registerAiLogRoutes(server2, ctx);
+  registerSemanticIndexRoutes(server2, ctx);
+}
+
+// ../../packages/http-routes/src/routes/web/analytics.ts
+import * as fs2 from "fs";
+import * as path4 from "path";
+
+// ../../packages/http-routes/src/routes/web/time-filter.ts
+function parseTimeFilter(query) {
+  const { startTs, endTs, memberId } = query;
+  if (!startTs && !endTs && !memberId) return void 0;
+  const filter = {};
+  if (startTs) filter.startTs = parseInt(startTs, 10);
+  if (endTs) filter.endTs = parseInt(endTs, 10);
+  if (memberId) filter.memberId = parseInt(memberId, 10);
+  return filter;
+}
+
+// ../../packages/http-routes/src/routes/web/analytics-cache.ts
+import * as path3 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 = path3.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);
+  });
+  server2.get("/_web/sessions/:id/time-range", async (request) => {
+    const db = adapter.ensureReadonly(request.params.id);
+    return getTimeRange(db);
+  });
+  server2.get(
+    "/_web/sessions/:id/stats/member-activity",
+    async (request) => {
+      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/analytics/member-monthly-trend",
+    "/_web/sessions/:id/stats/hourly",
     async (request) => {
       const id = request.params.id;
       const filter = parseTimeFilter(request.query);
-      return cached(
-        "member-monthly-trend",
-        id,
-        { ...filter },
-        () => getMemberMonthlyTrend(adapter.ensureReadonly(id), filter)
-      );
+      return cached("hourly", id, { ...filter }, () => getHourlyActivity(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
-    "/_web/sessions/:id/analytics/text-length-percentiles",
+    "/_web/sessions/:id/stats/daily",
     async (request) => {
       const id = request.params.id;
       const filter = parseTimeFilter(request.query);
-      return cached(
-        "text-length-percentiles",
-        id,
-        { ...filter },
-        () => getTextLengthPercentiles(adapter.ensureReadonly(id), filter)
-      );
+      return cached("daily", id, { ...filter }, () => getDailyActivity(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
-    "/_web/sessions/:id/analytics/dragon-king",
+    "/_web/sessions/:id/stats/weekday",
     async (request) => {
       const id = request.params.id;
       const filter = parseTimeFilter(request.query);
-      return cached("dragon-king", id, { ...filter }, () => getDragonKingAnalysis(adapter.ensureReadonly(id), filter));
+      return cached("weekday", id, { ...filter }, () => getWeekdayActivity(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
-    "/_web/sessions/:id/analytics/diving",
+    "/_web/sessions/:id/stats/message-types",
     async (request) => {
       const id = request.params.id;
       const filter = parseTimeFilter(request.query);
-      return cached("diving", id, { ...filter }, () => getDivingAnalysis(adapter.ensureReadonly(id), filter), {
-        dailyInvalidate: true
-      });
+      return cached("message-types", id, { ...filter }, () => getMessageTypeStats(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
-    "/_web/sessions/:id/analytics/check-in",
+    "/_web/sessions/:id/analytics/relationship",
     async (request) => {
       const id = request.params.id;
       const filter = parseTimeFilter(request.query);
-      return cached("check-in", id, { ...filter }, () => getCheckInAnalysis(adapter.ensureReadonly(id), filter));
+      return cached("relationship", id, { ...filter }, () => getRelationshipStats(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
-    "/_web/sessions/:id/analytics/meme-battle",
+    "/_web/sessions/:id/analytics/catchphrase",
     async (request) => {
       const id = request.params.id;
       const filter = parseTimeFilter(request.query);
-      return cached("meme-battle", id, { ...filter }, () => getMemeBattleAnalysis(adapter.ensureReadonly(id), filter));
+      return cached("catchphrase", id, { ...filter }, () => getCatchphraseAnalysis(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
-    "/_web/sessions/:id/analytics/night-owl",
+    "/_web/sessions/:id/analytics/mention",
     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
-      });
+      return cached("mention", id, { ...filter }, () => getMentionAnalysis(adapter.ensureReadonly(id), filter));
     }
   );
   server2.get(
-    "/_web/sessions/:id/analytics/repeat",
+    "/_web/sessions/:id/analytics/mention-graph",
     async (request) => {
       const id = request.params.id;
       const filter = parseTimeFilter(request.query);
-      return cached("repeat", id, { ...filter }, () => getRepeatAnalysis(adapter.ensureReadonly(id), filter));
+      return cached("mention-graph", id, { ...filter }, () => getMentionGraph(adapter.ensureReadonly(id), filter));
     }
   );
-}
-
-// ../../packages/http-routes/src/routes/web/sql.ts
-function registerSqlRoutes(server2, ctx) {
-  const { sessionAdapter: adapter } = ctx;
-  server2.post("/_web/sessions/:id/sql", async (request, reply) => {
-    const db = adapter.ensureReadonly(request.params.id);
-    const { sql } = request.body || {};
-    if (!sql || typeof sql !== "string") {
-      return reply.code(400).send({ error: "Missing sql parameter" });
+  server2.get(
+    "/_web/sessions/:id/analytics/laugh",
+    async (request) => {
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("laugh", id, { ...filter }, () => getLaughAnalysis(adapter.ensureReadonly(id), filter));
     }
-    try {
-      const result = executeSql(db, sql, { columnar: true, timing: true, maxRows: 0 });
-      return {
-        columns: result.columns,
-        rows: result.rows,
-        rowCount: result.rowCount,
-        duration: result.duration ?? 0,
-        limited: result.truncated
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "SQL execution error";
-      return reply.code(400).send({ error: message });
-    }
-  });
-  server2.get("/_web/sessions/:id/schema", async (request) => {
-    const db = adapter.ensureReadonly(request.params.id);
-    return getSchemaDetailed(db);
+  );
+  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.post("/_web/sessions/:id/query", async (request) => {
-    const db = adapter.ensureReadonly(request.params.id);
-    const { sql, params = [] } = request.body;
-    if (!sql || typeof sql !== "string") {
-      throw Object.assign(new Error('Missing or invalid "sql" field'), { statusCode: 400 });
+  server2.get(
+    "/_web/sessions/:id/analytics/language-preference",
+    async (request) => {
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      const locale = request.query.locale || "zh-CN";
+      const zhDictPath = path4.join(ctx.pathProvider.getSystemDir(), "nlp", "zh-CN.dict");
+      let zhDictVersion;
+      try {
+        const st = fs2.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}` }
+      );
     }
-    const stmt = db.prepare(sql.trim());
-    if (!stmt.readonly) {
-      throw Object.assign(new Error("Only READ-ONLY statements are allowed"), { statusCode: 403 });
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/monthly-activity",
+    async (request) => {
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("monthly-activity", id, { ...filter }, () => getMonthlyActivity(adapter.ensureReadonly(id), filter));
     }
-    if (Array.isArray(params)) {
-      return stmt.all(...params);
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/yearly-activity",
+    async (request) => {
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached("yearly-activity", id, { ...filter }, () => getYearlyActivity(adapter.ensureReadonly(id), filter));
     }
-    return stmt.all(params);
-  });
-}
-
-// ../../packages/http-routes/src/routes/web/session-index.ts
-function registerSessionIndexRoutes(server2, ctx) {
-  const { sessionAdapter: adapter } = ctx;
-  server2.get("/_web/sessions/index-stats", async () => {
-    return session_index_service_exports.getAllIndexStats(adapter);
-  });
-  server2.post("/_web/sessions/:id/generate-index", async (request) => {
-    const gapThreshold = request.body?.gapThreshold ?? 1800;
-    const sessionCount = session_index_service_exports.generateIndex(adapter, request.params.id, gapThreshold);
-    return { sessionCount };
-  });
-  server2.post("/_web/sessions/:id/generate-incremental-index", async (request) => {
-    const gapThreshold = request.body?.gapThreshold ?? 1800;
-    const sessionCount = session_index_service_exports.generateIncrementalIndex(adapter, request.params.id, gapThreshold);
-    return { sessionCount };
-  });
-  server2.post("/_web/sessions/:id/clear-index", async (request) => {
-    session_index_service_exports.clearIndex(adapter, request.params.id);
-    return { success: true };
-  });
-  server2.get("/_web/sessions/:id/search/fts", async (request, reply) => {
-    if (!session_index_service_exports.getFtsStatus(adapter, request.params.id)) {
-      return reply.code(400).send({ error: "FTS index not built for this session" });
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/message-length-distribution",
+    async (request) => {
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached(
+        "message-length-distribution",
+        id,
+        { ...filter },
+        () => getMessageLengthDistribution(adapter.ensureReadonly(id), filter)
+      );
     }
-    const keywords = request.query.keywords.split(/\s+/).filter(Boolean);
-    if (keywords.length === 0) return { rowids: [], total: 0 };
-    const limit = parseInt(request.query.limit || "100", 10);
-    const offset = parseInt(request.query.offset || "0", 10);
-    return session_index_service_exports.searchFts(adapter, request.params.id, keywords, limit, offset);
-  });
-  server2.get("/_web/sessions/:id/fts/status", async (request) => {
-    return { hasFtsIndex: session_index_service_exports.getFtsStatus(adapter, request.params.id) };
-  });
-  server2.post("/_web/sessions/:id/fts/rebuild", async (request) => {
-    const result = session_index_service_exports.rebuildFts(adapter, request.params.id);
-    return { success: true, indexed: result.indexed };
-  });
-}
-
-// ../../packages/http-routes/src/routes/web/export.ts
-function registerExportRoutes(server2, ctx) {
-  const { sessionAdapter: adapter } = ctx;
-  server2.post("/_web/sessions/:id/export", async (request, reply) => {
-    const { id } = request.params;
-    const body = request.body;
-    const sessionName = body?.sessionName || id;
-    const format = body?.format || "txt";
-    const result = export_service_exports.exportFormatted(adapter, {
-      sessionId: id,
-      sessionName,
-      format,
-      timeFilter: body.timeFilter
-    });
-    if (!result.success) {
-      return reply.code(result.totalMessages === 0 ? 404 : 500).send({ error: result.error });
+  );
+  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));
     }
-    reply.header("Content-Type", result.mimeType);
-    reply.header("Content-Disposition", `attachment; filename="${encodeURIComponent(result.filename)}"`);
-    return reply.send(result.content);
-  });
-}
-
-// ../../packages/http-routes/src/routes/web/nlp.ts
-import * as fs2 from "fs";
-import * as path3 from "path";
-function registerNlpRoutes(server2, ctx) {
-  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 () => {
-    return POS_TAG_DEFINITIONS;
-  });
-  server2.get("/_web/nlp/dicts", async () => {
-    return getDictList(nlpDir);
-  });
-  server2.get("/_web/nlp/dicts/:id/status", async (request) => {
-    return isDictDownloaded(nlpDir, request.params.id);
-  });
-  server2.post("/_web/nlp/dicts/:id/download", async (request) => {
-    return downloadDict(nlpDir, request.params.id);
-  });
-  server2.delete("/_web/nlp/dicts/:id", async (request) => {
-    return deleteDict(nlpDir, request.params.id);
-  });
-  server2.post("/_web/nlp/word-frequency", async (request) => {
-    const params = request.body;
-    const db = ctx.dbManager.open(params.sessionId);
-    if (!db) {
-      throw Object.assign(new Error(`Session not found: ${params.sessionId}`), { statusCode: 404 });
+  );
+  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)
+      );
     }
-    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 = "-";
+  );
+  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)
+      );
     }
-    return withAnalyticsCache(ctx, sessionId, "nlp.word-frequency", keyParams, () => computeWordFrequency(db, params), {
-      extraVersion: `dict:${dictVersion}`
-    });
-  });
-  server2.post(
-    "/_web/nlp/segment",
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/text-length-percentiles",
     async (request) => {
-      const { text, locale, minLength } = request.body;
-      return segmentText(text, locale, minLength);
+      const id = request.params.id;
+      const filter = parseTimeFilter(request.query);
+      return cached(
+        "text-length-percentiles",
+        id,
+        { ...filter },
+        () => getTextLengthPercentiles(adapter.ensureReadonly(id), filter)
+      );
     }
   );
-}
-
-// ../../packages/http-routes/src/routes/web/ai-assistants.ts
-function registerAiAssistantRoutes(server2, ctx) {
-  server2.get("/_web/ai/tools/catalog", async () => {
-    return BUILTIN_TOOL_CATALOG;
-  });
-  const mgr = ctx.assistantManager;
-  if (!mgr) return;
-  server2.get("/_web/ai/assistants", async () => {
-    return mgr.getAllAssistants();
-  });
-  server2.get("/_web/ai/assistants/:id", async (request, reply) => {
-    const config = mgr.getAssistantConfig(request.params.id);
-    if (!config) return reply.code(404).send({ error: "Not found" });
-    return config;
-  });
-  server2.post("/_web/ai/assistants", async (request) => {
-    return mgr.createAssistant(request.body);
-  });
-  server2.put("/_web/ai/assistants/:id", async (request, reply) => {
-    const result = mgr.updateAssistant(request.params.id, request.body);
-    if (!result.success) return reply.code(404).send(result);
-    return result;
-  });
-  server2.delete("/_web/ai/assistants/:id", async (request, reply) => {
-    const result = mgr.deleteAssistant(request.params.id);
-    if (!result.success) return reply.code(400).send(result);
-    return result;
-  });
-  server2.post("/_web/ai/assistants/:id/reset", async (request, reply) => {
-    const result = mgr.resetAssistant(request.params.id);
-    if (!result.success) return reply.code(400).send(result);
-    return result;
-  });
-  server2.post("/_web/ai/assistants/import", async (request) => {
-    return mgr.importAssistantFromMd(request.body.rawMd);
-  });
-  server2.post("/_web/ai/assistants/import-builtin", async (request, reply) => {
-    const result = mgr.importAssistant(request.body.builtinId);
-    if (!result.success) return reply.code(400).send(result);
-    return result;
-  });
-  server2.post("/_web/ai/assistants/:id/reimport", async (request, reply) => {
-    const result = mgr.reimportAssistant(request.params.id);
-    if (!result.success) return reply.code(400).send(result);
-    return result;
-  });
-}
-
-// ../../packages/http-routes/src/routes/web/ai-skills.ts
-function registerAiSkillRoutes(server2, ctx) {
-  const mgr = ctx.skillManagerCore;
-  if (!mgr) return;
-  server2.get("/_web/ai/skills", async () => {
-    return mgr.getAllSkills();
-  });
-  server2.get("/_web/ai/skills/:id", async (request, reply) => {
-    const config = mgr.getSkillConfig(request.params.id);
-    if (!config) return reply.code(404).send({ error: "Not found" });
-    return config;
-  });
-  server2.post("/_web/ai/skills", async (request) => {
-    return mgr.createSkill(request.body.rawMd);
-  });
-  server2.put("/_web/ai/skills/:id", async (request, reply) => {
-    const result = mgr.updateSkill(request.params.id, request.body.rawMd);
-    if (!result.success) return reply.code(404).send(result);
-    return result;
-  });
-  server2.delete("/_web/ai/skills/:id", async (request, reply) => {
-    const result = mgr.deleteSkill(request.params.id);
-    if (!result.success) return reply.code(400).send(result);
-    return result;
-  });
-  server2.post("/_web/ai/skills/import", async (request) => {
-    return mgr.importSkillFromMd(request.body.rawMd);
-  });
-  server2.get("/_web/ai/skills/builtin-catalog", async () => {
-    return mgr.getBuiltinCatalog();
-  });
-  server2.post("/_web/ai/skills/import-builtin", async (request, reply) => {
-    const result = mgr.importSkill(request.body.builtinId);
-    if (!result.success) return reply.code(400).send(result);
-    return result;
-  });
-  server2.post("/_web/ai/skills/:id/reimport", async (request, reply) => {
-    const result = mgr.reimportSkill(request.params.id);
-    if (!result.success) return reply.code(400).send(result);
-    return result;
-  });
-}
-
-// ../../packages/http-routes/src/routes/web/ai-llm.ts
-function hasRealApiKey(apiKey) {
-  return !!apiKey && apiKey !== "sk-no-key-required";
-}
-function toConfigDisplay(config) {
-  const { apiKey: _raw, ...rest } = config;
-  return { ...rest, apiKey: "", apiKeySet: hasRealApiKey(String(_raw || "")) };
-}
-function registerAiLlmRoutes(server2, ctx) {
-  const store = ctx.llmConfigStore;
-  const aiDataDir = ctx.aiDataDir;
-  if (!store || !aiDataDir) return;
-  server2.get("/_web/ai/llm/has-config", async () => {
-    return store.hasActiveConfig();
-  });
-  server2.get("/_web/ai/llm/configs", async () => {
-    const data = store.loadStore();
-    return {
-      configs: data.configs.map((c) => toConfigDisplay(c)),
-      defaultAssistant: data.defaultAssistant,
-      fastModel: data.fastModel
-    };
-  });
-  server2.post("/_web/ai/llm/configs", async (request) => {
-    const result = store.addConfig(request.body);
-    if (result.success && result.config) {
-      return { ...result, config: toConfigDisplay(result.config) };
-    }
-    return result;
-  });
-  server2.put("/_web/ai/llm/configs/:id", async (request) => {
-    return store.updateConfig(request.params.id, request.body);
-  });
-  server2.delete("/_web/ai/llm/configs/:id", async (request) => {
-    return store.deleteConfig(request.params.id);
-  });
-  server2.get("/_web/ai/llm/default-assistant-slot", async () => {
-    return store.getDefaultAssistantSlot();
-  });
-  server2.put("/_web/ai/llm/default-assistant-slot", async (request) => {
-    return store.setDefaultAssistantModel(request.body.configId, request.body.modelId);
-  });
-  server2.get("/_web/ai/llm/fast-model-slot", async () => {
-    return store.getFastModelSlot();
-  });
-  server2.put("/_web/ai/llm/fast-model-slot", async (request) => {
-    return store.setFastModel(request.body);
-  });
-  server2.get("/_web/ai/llm/providers", async () => {
-    return BUILTIN_PROVIDERS.map((p) => {
-      const models = getBuiltinModelsByProvider(p.id);
-      return {
-        id: p.id,
-        name: p.name,
-        defaultBaseUrl: p.defaultBaseUrl,
-        models: models.filter((m) => !m.capabilities.includes("embedding") && !m.capabilities.includes("ranking")).map((m) => ({ id: m.id, name: m.name, description: m.description }))
-      };
-    });
-  });
-  server2.get("/_web/ai/llm/provider-registry", async () => {
-    const custom = ctx.customProviderStore?.getAll() ?? [];
-    return [...BUILTIN_PROVIDERS, ...custom];
-  });
-  server2.get("/_web/ai/llm/model-catalog", async () => {
-    const custom = ctx.customModelStore?.getAll() ?? [];
-    return [...BUILTIN_MODELS, ...custom];
-  });
-  server2.post("/_web/ai/llm/custom-providers", async (request, reply) => {
-    if (!ctx.customProviderStore)
-      return reply.code(501).send({ success: false, error: "Custom providers not available" });
-    return ctx.customProviderStore.add(request.body);
-  });
-  server2.put("/_web/ai/llm/custom-providers/:id", async (request, reply) => {
-    if (!ctx.customProviderStore)
-      return reply.code(501).send({ success: false, error: "Custom providers not available" });
-    const result = ctx.customProviderStore.update(request.params.id, request.body);
-    if (!result.success) return reply.code(404).send(result);
-    return result;
-  });
-  server2.delete("/_web/ai/llm/custom-providers/:id", async (request, reply) => {
-    if (!ctx.customProviderStore)
-      return reply.code(501).send({ success: false, error: "Custom providers not available" });
-    const result = ctx.customProviderStore.delete(request.params.id);
-    if (!result.success) return reply.code(404).send(result);
-    return result;
-  });
-  server2.post("/_web/ai/llm/custom-models", async (request, reply) => {
-    if (!ctx.customModelStore) return reply.code(501).send({ success: false, error: "Custom models not available" });
-    const result = ctx.customModelStore.add(request.body);
-    if (!result.success) return reply.code(409).send(result);
-    return result;
-  });
-  server2.put("/_web/ai/llm/custom-models/:providerId/:modelId", async (request, reply) => {
-    if (!ctx.customModelStore) return reply.code(501).send({ success: false, error: "Custom models not available" });
-    const result = ctx.customModelStore.update(request.params.providerId, request.params.modelId, request.body);
-    if (!result.success) return reply.code(404).send(result);
-    return result;
-  });
-  server2.delete("/_web/ai/llm/custom-models/:providerId/:modelId", async (request, reply) => {
-    if (!ctx.customModelStore) return reply.code(501).send({ success: false, error: "Custom models not available" });
-    const result = ctx.customModelStore.delete(request.params.providerId, request.params.modelId);
-    if (!result.success) return reply.code(404).send(result);
-    return result;
-  });
-  server2.post("/_web/ai/llm/validate-key", async (request) => {
-    const { provider, apiKey, baseUrl, model, apiFormat, configId } = request.body;
-    const resolvedKey = apiKey?.trim() ? apiKey : configId ? store.getConfigById(configId)?.apiKey || "" : "";
-    return validateApiKey(provider, resolvedKey, baseUrl, model, apiFormat);
-  });
-  server2.post("/_web/ai/llm/remote-models", async (request) => {
-    const { provider, apiKey, baseUrl, apiFormat, configId } = request.body;
-    const resolvedKey = apiKey?.trim() ? apiKey : configId ? store.getConfigById(configId)?.apiKey || "" : "";
-    return fetchRemoteModels(provider, resolvedKey, baseUrl, apiFormat);
-  });
-  server2.get("/_web/ai/desensitize-rules/defaults", async (request) => {
-    return getDefaultRulesForLocale(request.query.locale ?? "zh-CN");
-  });
-  server2.post("/_web/ai/desensitize-rules/merge", async (request) => {
-    return mergeRulesForLocale(request.body.existingRules, request.body.locale, request.body.overrides ?? {});
-  });
-}
-
-// ../../packages/http-routes/src/routes/web/ai-llm-stream.ts
-function registerAiLlmStreamRoutes(server2, ctx) {
-  const store = ctx.llmConfigStore;
-  if (!store) return;
-  server2.post("/_web/ai/llm/chat-stream", async (request, reply) => {
-    const { messages, options } = request.body;
-    const llmConfig = store.getDefaultAssistantConfig();
-    if (!llmConfig) {
-      return reply.code(400).send({ success: false, error: "LLM service not configured" });
-    }
-    const piModel = buildPiModel(llmConfig);
-    const abortController = new AbortController();
-    reply.raw.writeHead(200, {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive"
-    });
-    reply.raw.on("close", () => {
-      if (!abortController.signal.aborted) abortController.abort();
-    });
-    const sendChunk = (data) => {
-      if (reply.raw.writableEnded || reply.raw.destroyed) return;
-      reply.raw.write(`event: chunk
-data: ${JSON.stringify(data)}
-
-`);
-    };
-    try {
-      await runSimpleLlmStream({
-        messages,
-        apiKey: llmConfig.apiKey,
-        piModel,
-        temperature: options?.temperature,
-        maxTokens: options?.maxTokens,
-        onChunk: sendChunk,
-        abortSignal: abortController.signal
-      });
-    } catch (error) {
-      if (abortController.signal.aborted) return;
-      const msg = error instanceof Error ? error.message : String(error);
-      sendChunk({ content: "", isFinished: true, finishReason: "error", error: msg });
-    } finally {
-      if (!reply.raw.writableEnded && !reply.raw.destroyed) reply.raw.end();
+  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));
     }
-  });
-}
-
-// ../../packages/http-routes/src/routes/web/ai-agent-stream.ts
-var activeAgentAborts = /* @__PURE__ */ new Map();
-function registerAiAgentStreamRoutes(server2, ctx) {
-  if (!ctx.runAgentStream) return;
-  const runAgentStream = ctx.runAgentStream;
-  server2.post("/_web/ai/agent/stream", async (request, reply) => {
-    const requestId = `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    const abortController = new AbortController();
-    activeAgentAborts.set(requestId, abortController);
-    reply.raw.writeHead(200, {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-      "X-Request-Id": requestId
-    });
-    let emittedDone = false;
-    const safeSendSSE = (event, data) => {
-      if (reply.raw.writableEnded || reply.raw.destroyed) return;
-      reply.raw.write(`event: ${event}
-data: ${JSON.stringify(data)}
-
-`);
-    };
-    const safeEnd = () => {
-      if (reply.raw.writableEnded || reply.raw.destroyed) return;
-      reply.raw.end();
-    };
-    safeSendSSE("meta", { requestId });
-    reply.raw.on("close", () => {
-      if (!abortController.signal.aborted) {
-        abortController.abort();
-      }
-      activeAgentAborts.delete(requestId);
-    });
-    try {
-      await runAgentStream(
-        request.body,
-        (chunk) => {
-          if (chunk.type === "done") emittedDone = true;
-          safeSendSSE(chunk.type, chunk);
-        },
-        abortController.signal
-      );
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      safeSendSSE("error", { type: "error", error: { name: "ServerError", message: msg } });
-    } finally {
-      if (!emittedDone) safeSendSSE("done", { type: "done", isFinished: true });
-      activeAgentAborts.delete(requestId);
-      safeEnd();
+  );
+  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.post("/_web/ai/agent/abort", async (request) => {
-    const { requestId } = request.body;
-    const controller = activeAgentAborts.get(requestId);
-    if (controller) {
-      controller.abort();
-      activeAgentAborts.delete(requestId);
-      return { success: 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));
     }
-    return { success: false };
-  });
+  );
+  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));
+    }
+  );
 }
 
-// ../../packages/http-routes/src/ai/tool-executor.ts
-var MAX_RESULT_CHARS = 5e5;
-async function executeRegistryTool(params, deps) {
-  const { toolName, params: toolParams, abortSignal } = params;
-  const entry = AGENT_TOOL_REGISTRY.find((tool) => tool.name === toolName);
-  if (!entry) {
-    return { success: false, error: `Tool not found: ${toolName}` };
-  }
+// ../../packages/http-routes/src/routes/web/cache.ts
+import * as fs3 from "fs";
+import * as fsp from "fs/promises";
+import * as path5 from "path";
+async function getDirSize(dirPath) {
+  let totalSize = 0;
   try {
-    if (abortSignal.aborted) return { success: false, error: "cancelled" };
-    const execCtx = {
-      sessionId: params.sessionId,
-      abortSignal,
-      db: deps.db,
-      dataProvider: deps.dataProvider,
-      semanticIndexService: deps.semanticIndexService,
-      segmentText: deps.segmentText,
-      translateTemplate: deps.translateTemplate
-    };
-    const startTime = Date.now();
-    const result = await entry.handler(toolParams, execCtx);
-    const elapsed = Date.now() - startTime;
-    if (abortSignal.aborted) return { success: false, error: "cancelled" };
-    let details = result.data ?? void 0;
-    let truncated = false;
-    if (details) {
-      stripAvatarFields(details);
-      const raw = JSON.stringify(details);
-      if (raw.length > MAX_RESULT_CHARS) {
-        truncated = true;
-        details = { _truncated: true, _originalSize: raw.length, _preview: raw.slice(0, MAX_RESULT_CHARS) };
+    if (!fs3.existsSync(dirPath)) return 0;
+    const files = await fsp.readdir(dirPath, { withFileTypes: true });
+    for (const file of files) {
+      const filePath = path5.join(dirPath, file.name);
+      if (file.isDirectory()) {
+        totalSize += await getDirSize(filePath);
+      } else {
+        const stat2 = await fsp.stat(filePath);
+        totalSize += stat2.size;
       }
     }
-    return {
-      success: true,
-      elapsed,
-      content: [{ type: "text", text: result.content }],
-      details,
-      truncated
-    };
-  } catch (error) {
-    if (abortSignal.aborted) {
-      return { success: false, error: "cancelled" };
-    }
-    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  } catch {
   }
+  return totalSize;
 }
-
-// ../../packages/http-routes/src/routes/web/ai-tools.ts
-var activeToolTests = /* @__PURE__ */ new Map();
-function registerAiToolRoutes(server2, ctx) {
-  server2.get("/_web/ai/tools/full-catalog", async () => {
-    return AGENT_TOOL_REGISTRY.map((tool) => ({
-      name: tool.name,
-      category: tool.category ?? "core",
-      description: tool.description,
-      parameters: tool.inputSchema ?? {}
-    }));
-  });
-  server2.post("/_web/ai/tools/execute", async (request, reply) => {
-    const { testId, toolName, params, sessionId } = request.body;
-    const entry = AGENT_TOOL_REGISTRY.find((t) => t.name === toolName);
-    if (!entry) {
-      return reply.code(404).send({ success: false, error: `Tool not found: ${toolName}` });
-    }
-    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 result = await executeRegistryTool(
-        { testId, toolName, params, sessionId, abortSignal: abortController.signal },
-        {
-          db,
-          dataProvider: new CoreDataProvider(db)
-        }
-      );
-      if (!result.success && result.error !== "cancelled") {
-        appLogger.error("ai-tools", `Failed to execute tool ${toolName}`, { error: result.error });
-      }
-      return result;
-    } catch (error) {
-      if (abortController.signal.aborted) {
-        return { success: false, error: "cancelled" };
+async function getFileCount(dirPath) {
+  let count = 0;
+  try {
+    if (!fs3.existsSync(dirPath)) return 0;
+    const files = await fsp.readdir(dirPath, { withFileTypes: true });
+    for (const file of files) {
+      const filePath = path5.join(dirPath, file.name);
+      if (file.isDirectory()) {
+        count += await getFileCount(filePath);
+      } else {
+        count++;
       }
-      appLogger.error("ai-tools", `Failed to execute tool ${toolName}`, error);
-      return { success: false, error: String(error) };
-    } finally {
-      activeToolTests.delete(testId);
     }
-  });
-  server2.post("/_web/ai/tools/cancel", async (request) => {
-    const { testId } = request.body;
-    const controller = activeToolTests.get(testId);
-    if (controller) {
-      controller.abort();
-      activeToolTests.delete(testId);
-      return { success: true };
-    }
-    return { success: false };
-  });
+  } catch {
+  }
+  return count;
 }
-
-// ../../packages/http-routes/src/routes/web/ai-chats.ts
-function registerAiChatRoutes(server2, ctx) {
-  const cm = ctx.aiChatManager;
-  if (!cm) return;
-  server2.post("/_web/ai/chats", async (request) => {
-    const { sessionId, title, assistantId } = request.body;
-    return cm.createAIChat(sessionId, title, assistantId);
-  });
-  server2.get("/_web/ai/chats", async (request) => {
-    const { sessionId } = request.query;
-    if (!sessionId) return [];
-    return cm.getAIChats(sessionId);
-  });
-  server2.get("/_web/ai/chats/:id", async (request, reply) => {
-    const conv = cm.getAIChat(request.params.id);
-    if (!conv) return reply.code(404).send({ error: "AI chat not found" });
-    return conv;
-  });
-  server2.put("/_web/ai/chats/:id/title", async (request) => {
-    return cm.updateAIChatTitle(request.params.id, request.body.title);
-  });
-  server2.delete("/_web/ai/chats/:id", async (request) => {
-    return cm.deleteAIChat(request.params.id);
-  });
-  server2.post("/_web/ai/chats/:id/messages", async (request) => {
-    const { role, content, dataKeywords, dataMessageCount, contentBlocks, tokenUsage } = request.body;
-    return cm.addMessage(
-      request.params.id,
-      role,
-      content,
-      dataKeywords,
-      dataMessageCount,
-      contentBlocks,
-      tokenUsage
+function hasChatLabDatabases(dirPath) {
+  try {
+    const markerPath = path5.join(dirPath, ".chatlab");
+    const dbDir = path5.join(dirPath, "databases");
+    if (!fs3.existsSync(markerPath) || !fs3.existsSync(dbDir)) return false;
+    return fs3.readdirSync(dbDir).some((file) => file.endsWith(".db"));
+  } catch {
+    return false;
+  }
+}
+function registerCacheRoutes(server2, ctx) {
+  const pp = ctx.pathProvider;
+  const downloadsDir = ctx.downloadsDir ?? pp.getDownloadsDir();
+  server2.get("/_web/cache/info", async () => {
+    const directories = [
+      {
+        id: "databases",
+        name: "settings.storage.cache.databases.name",
+        description: "settings.storage.cache.databases.description",
+        path: pp.getDatabaseDir(),
+        scope: "user-data",
+        rootPath: pp.getUserDataDir(),
+        icon: "i-heroicons-circle-stack",
+        canClear: false
+      },
+      {
+        id: "ai",
+        name: "settings.storage.cache.ai.name",
+        description: "settings.storage.cache.ai.description",
+        path: pp.getAiDataDir(),
+        scope: "system-data",
+        rootPath: pp.getSystemDir(),
+        icon: "i-heroicons-sparkles",
+        canClear: false
+      },
+      {
+        id: "cache",
+        name: "settings.storage.cache.statsCache.name",
+        description: "settings.storage.cache.statsCache.description",
+        path: pp.getCacheDir(),
+        scope: "system-data",
+        rootPath: pp.getSystemDir(),
+        icon: "i-heroicons-bolt",
+        canClear: true
+      },
+      {
+        id: "logs",
+        name: "settings.storage.cache.logs.name",
+        description: "settings.storage.cache.logs.description",
+        path: pp.getLogsDir(),
+        scope: "system-data",
+        rootPath: pp.getSystemDir(),
+        icon: "i-heroicons-document-text",
+        canClear: true
+      }
+    ];
+    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: fs3.existsSync(dir.path) };
+      })
     );
+    return {
+      baseDir: pp.getSystemDir(),
+      directories: results,
+      totalSize: results.reduce((sum, d) => sum + d.size, 0)
+    };
   });
-  server2.get("/_web/ai/chats/:id/messages", async (request) => {
-    return cm.getMessages(request.params.id);
-  });
-  server2.post("/_web/ai/chats/:id/messages/:messageId/delete-from", async (request, reply) => {
-    const { id, messageId } = request.params;
-    if (!id || typeof id !== "string" || !messageId || typeof messageId !== "string") {
-      return reply.code(400).send({ error: "aiChatId and messageId are required" });
+  server2.post("/_web/cache/clear", async (request) => {
+    const { cacheId } = request.body;
+    const allowedDirs = {
+      cache: pp.getCacheDir(),
+      logs: pp.getLogsDir()
+    };
+    const dirPath = allowedDirs[cacheId];
+    if (!dirPath) return { success: false, error: "Not allowed to clear this directory" };
+    if (!fs3.existsSync(dirPath)) return { success: true };
+    const files = await fsp.readdir(dirPath);
+    for (const file of files) {
+      const filePath = path5.join(dirPath, file);
+      const stat2 = await fsp.stat(filePath);
+      if (stat2.isDirectory()) {
+        await fsp.rm(filePath, { recursive: true });
+      } else {
+        await fsp.unlink(filePath);
+      }
     }
-    cm.deleteMessagesFrom(id, messageId);
     return { success: true };
   });
-  server2.post("/_web/ai/chats/:id/fork", async (request, reply) => {
-    const { upToMessageId, title } = request.body;
-    if (!upToMessageId || typeof upToMessageId !== "string") {
-      return reply.code(400).send({ error: "upToMessageId is required" });
-    }
-    return cm.forkAIChat(request.params.id, upToMessageId, title);
+  server2.get("/_web/cache/data-dir", async () => {
+    const pending = ctx.getPendingDataDirMigration?.();
+    return {
+      path: pp.getUserDataDir(),
+      defaultPath: ctx.defaultUserDataDir,
+      isCustom: ctx.isCustomDataDir ?? false,
+      canSetDataDir: ctx.canSetDataDir ?? Boolean(ctx.setDataDir),
+      managedScope: "chat-databases",
+      managedDescription: "settings.storage.dataLocation.managedDescription",
+      hasLegacyDataAtDefaultDir: Boolean(ctx.defaultUserDataDir) && path5.resolve(pp.getUserDataDir()) !== path5.resolve(ctx.defaultUserDataDir ?? "") && hasChatLabDatabases(ctx.defaultUserDataDir ?? ""),
+      pendingMigration: pending ? {
+        from: pending.from,
+        to: pending.to,
+        createdAt: pending.createdAt
+      } : void 0
+    };
   });
-  server2.put("/_web/ai/messages/:messageId/content", async (request, reply) => {
-    const { content } = request.body;
-    if (!content || typeof content !== "string") {
-      return reply.code(400).send({ error: "content is required" });
+  server2.post("/_web/cache/data-dir", async (request, reply) => {
+    if (!ctx.setDataDir) {
+      return reply.code(501).send({ success: false, error: "Data directory changes are not supported" });
     }
-    cm.updateMessageContent(request.params.messageId, content);
-    return { success: true };
+    const targetPath = typeof request.body?.path === "string" ? request.body.path : null;
+    const migrate = request.body?.migrate !== false;
+    return ctx.setDataDir(targetPath, migrate);
   });
-  server2.post("/_web/ai/chats/:id/messages/:messageId/delete-relink", async (request, reply) => {
-    const { id, messageId } = request.params;
-    if (!id || !messageId) {
-      return reply.code(400).send({ error: "aiChatId and messageId are required" });
+  server2.get("/_web/cache/latest-import-log", async () => {
+    const importLogDir = path5.join(pp.getLogsDir(), "import");
+    if (!fs3.existsSync(importLogDir)) {
+      return { success: false, error: "Log directory not found" };
     }
-    cm.deleteAndRelinkMessage(id, messageId);
-    return { success: true };
-  });
-  server2.post("/_web/ai/chats/:id/messages/insert-after", async (request, reply) => {
-    const { afterMessageId, role, content, contentBlocks, tokenUsage } = request.body;
-    if (!afterMessageId || typeof afterMessageId !== "string") {
-      return reply.code(400).send({ error: "afterMessageId is required" });
+    const files = await fsp.readdir(importLogDir);
+    const logFiles = files.filter((f) => f.startsWith("import_") && f.endsWith(".log"));
+    if (logFiles.length === 0) {
+      return { success: false, error: "No import logs found" };
     }
-    return cm.insertMessageAfter(request.params.id, afterMessageId, role, content, contentBlocks, tokenUsage);
-  });
-  server2.get("/_web/ai/chats/:id/token-usage", async (request) => {
-    return cm.getAIChatTokenUsage(request.params.id);
+    const fileStats = await Promise.all(
+      logFiles.map(async (f) => {
+        const filePath = path5.join(importLogDir, f);
+        const stat2 = await fsp.stat(filePath);
+        return { name: f, path: filePath, mtime: stat2.mtime.getTime() };
+      })
+    );
+    fileStats.sort((a, b) => b.mtime - a.mtime);
+    return { success: true, path: fileStats[0].path, name: fileStats[0].name };
   });
-  server2.get("/_web/ai/debug/schema", async () => {
-    return cm.getAiSchema();
+  server2.post("/_web/cache/save-to-downloads", async (request) => {
+    const { filename, dataUrl } = request.body;
+    if (!filename || !dataUrl) {
+      return { success: false, error: "filename and dataUrl are required" };
+    }
+    let buffer;
+    if (dataUrl.includes(";base64,")) {
+      const base64Data = dataUrl.split(";base64,")[1];
+      buffer = Buffer.from(base64Data, "base64");
+    } else if (dataUrl.includes("charset=utf-8,")) {
+      const textData = dataUrl.split("charset=utf-8,")[1];
+      buffer = Buffer.from(decodeURIComponent(textData), "utf-8");
+    } else {
+      const base64Data = dataUrl.replace(/^data:[^,]+,/, "");
+      buffer = Buffer.from(base64Data, "base64");
+    }
+    if (!fs3.existsSync(downloadsDir)) {
+      fs3.mkdirSync(downloadsDir, { recursive: true });
+    }
+    const filePath = path5.join(downloadsDir, filename);
+    fs3.writeFileSync(filePath, buffer);
+    return { success: true, filePath };
   });
-  server2.post("/_web/ai/debug/execute-sql", async (request, reply) => {
-    const { sql } = request.body;
-    if (!sql || typeof sql !== "string") {
-      return reply.code(400).send({ error: "sql is required" });
+  server2.post("/_web/cache/open-dir", async (request, reply) => {
+    if (!ctx.openDirectory) return reply.code(501).send({ success: false, error: "Not supported" });
+    const { cacheId } = request.body;
+    const dirPaths = {
+      base: pp.getSystemDir(),
+      userData: pp.getUserDataDir(),
+      databases: pp.getDatabaseDir(),
+      cache: pp.getCacheDir(),
+      ai: pp.getAiDataDir(),
+      logs: pp.getLogsDir(),
+      downloads: downloadsDir
+    };
+    const dirPath = dirPaths[cacheId];
+    if (!dirPath) return { success: false, error: "Unknown directory" };
+    if (!fs3.existsSync(dirPath)) {
+      await fsp.mkdir(dirPath, { recursive: true });
     }
     try {
-      return cm.executeAiSQL(sql);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      return reply.code(400).send({ error: msg });
+      await ctx.openDirectory(dirPath);
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
     }
+    return { success: true };
   });
-  server2.post("/_web/ai/debug/clear-debug-context", async () => {
-    const cleared = cm.clearAllDebugContext();
-    return { success: true, cleared };
-  });
-  server2.get("/_web/ai/chats/:id/estimate-tokens", async (request) => {
-    const history = cm.getHistoryForAgent(request.params.id);
-    const tokens = countMessagesTokens(history.map((m) => ({ role: m.role, content: m.content })));
-    return { success: true, tokens, messageCount: history.length };
+  server2.post("/_web/cache/show-in-folder", async (request, reply) => {
+    if (!ctx.showInFolder) return reply.code(501).send({ success: false, error: "Not supported" });
+    const { filePath } = request.body;
+    if (!filePath) return { success: false, error: "filePath is required" };
+    try {
+      await ctx.showInFolder(filePath);
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    return { success: true };
   });
 }
 
-// ../../packages/http-routes/src/routes/web/ai-summaries.ts
-function createSummaryDeps(ctx) {
-  const store = ctx.llmConfigStore;
-  if (!store) return null;
-  return {
-    getLlmConfig() {
-      const config = store.getDefaultAssistantConfig();
-      if (!config) return null;
-      return config;
-    },
-    buildPiModel(config) {
-      return buildPiModel(config);
+// ../../packages/http-routes/src/routes/web/contacts.ts
+function registerContactsRoutes(server2, ctx) {
+  const service = ctx.contactsService ?? createContactsService({
+    adapter: ctx.sessionAdapter,
+    pathProvider: ctx.pathProvider,
+    runtimeIdentity: ctx.runtimeIdentity,
+    nativeBinding: ctx.nativeBinding
+  });
+  server2.addHook("onClose", async () => {
+    await service.close();
+  });
+  server2.get("/_web/contacts", async (request) => {
+    return service.getContactsPage({
+      acceptStale: isTruthy(request.query.acceptStale),
+      timeRangePreset: parseContactsTimeRangePreset(request.query.timeRange),
+      pool: parseContactPool(request.query.pool),
+      page: parsePositiveInteger(request.query.page),
+      pageSize: parsePositiveInteger(request.query.pageSize),
+      query: request.query.q
+    });
+  });
+  server2.post("/_web/contacts/recompute", async (request) => {
+    return service.startRecompute({
+      timeRangePreset: parseContactsTimeRangePreset(request.query.timeRange),
+      pool: parseContactPool(request.query.pool),
+      page: parsePositiveInteger(request.query.page),
+      pageSize: parsePositiveInteger(request.query.pageSize),
+      query: request.query.q
+    });
+  });
+  server2.get("/_web/contacts/:key/detail", async (request) => {
+    return service.getContactDetail(request.params.key, {
+      acceptStale: isTruthy(request.query.acceptStale),
+      timeRangePreset: parseContactsTimeRangePreset(request.query.timeRange)
+    });
+  });
+  server2.put(
+    "/_web/contacts/:key/mark-friend",
+    async (request) => {
+      return service.markContactAsFriend(request.params.key, {
+        timeRangePreset: parseContactsTimeRangePreset(request.query.timeRange)
+      });
     }
-  };
+  );
+  server2.delete(
+    "/_web/contacts/:key/mark-friend",
+    async (request) => {
+      return service.unmarkContactAsFriend(request.params.key, {
+        timeRangePreset: parseContactsTimeRangePreset(request.query.timeRange)
+      });
+    }
+  );
 }
-function registerAiSummaryRoutes(server2, ctx) {
-  const deps = createSummaryDeps(ctx);
-  if (!deps) return;
+function isTruthy(value) {
+  return value === "1" || value === "true" || value === "yes";
+}
+function parseContactsTimeRangePreset(value) {
+  return CONTACTS_TIME_RANGE_PRESETS.includes(value) ? value : "1y";
+}
+function parseContactPool(value) {
+  return value === "friend" || value === "non_friend" ? value : void 0;
+}
+function parsePositiveInteger(value) {
+  if (!value) return void 0;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return void 0;
+  return Math.max(1, Math.trunc(parsed));
+}
+
+// ../../packages/http-routes/src/routes/web/export.ts
+function registerExportRoutes(server2, ctx) {
   const { sessionAdapter: adapter } = ctx;
-  server2.post("/_web/sessions/:id/summaries/generate", async (request, reply) => {
-    const { segmentId, locale, forceRegenerate, strategy } = request.body;
-    const result = await summary_service_exports.generateSummary(adapter, request.params.id, segmentId, deps, {
-      locale,
-      forceRegenerate,
-      strategy
+  server2.post("/_web/sessions/:id/export", async (request, reply) => {
+    const { id } = request.params;
+    const body = request.body;
+    const sessionName = body?.sessionName || id;
+    const format = body?.format || "txt";
+    const result = export_service_exports.exportFormatted(adapter, {
+      sessionId: id,
+      sessionName,
+      format,
+      timeFilter: body.timeFilter
     });
-    if ("error" in result && !result.success) {
-      return reply.code(400).send({ error: result.error });
+    if (!result.success) {
+      return reply.code(result.totalMessages === 0 ? 404 : 500).send({ error: result.error });
     }
-    return result;
+    reply.header("Content-Type", result.mimeType);
+    reply.header("Content-Disposition", `attachment; filename="${encodeURIComponent(result.filename)}"`);
+    return reply.send(result.content);
   });
-  server2.post("/_web/sessions/:id/summaries/generate-all", async (request, reply) => {
-    const { locale, forceRegenerate } = request.body;
-    const result = await summary_service_exports.generateAllSummaries(adapter, request.params.id, deps, {
-      locale,
-      forceRegenerate
-    });
-    if (result.error) {
-      return reply.code(400).send({ error: result.error });
-    }
-    return result;
+}
+
+// ../../packages/http-routes/src/routes/web/global-insight.ts
+function registerGlobalInsightRoutes(server2, ctx) {
+  const service = ctx.globalInsightService ?? createGlobalInsightService({
+    adapter: ctx.sessionAdapter,
+    pathProvider: ctx.pathProvider,
+    runtimeIdentity: ctx.runtimeIdentity,
+    nativeBinding: ctx.nativeBinding
   });
-  server2.post("/_web/sessions/:id/summaries/check-can-generate", async (request) => {
-    const { segmentIds } = request.body;
-    return summary_service_exports.checkCanGenerate(adapter, request.params.id, segmentIds);
+  server2.addHook("onClose", async () => service.close());
+  server2.get("/_web/global-insight/annual-summary", async (request) => {
+    return service.getAnnualSummary({
+      ...parseRange(request.query),
+      acceptStale: isTruthy2(request.query.acceptStale)
+    });
   });
+  server2.post(
+    "/_web/global-insight/annual-summary/recompute",
+    async (request) => service.startRecompute(parseRange(request.query))
+  );
 }
-
-// ../../packages/http-routes/src/routes/web/ai-logs.ts
-import fs3 from "fs";
-import path4 from "path";
-function findLatestAiLogPath(logsDir) {
-  const aiLogDir = path4.join(logsDir, "ai");
-  if (!fs3.existsSync(aiLogDir)) return null;
-  const latest = fs3.readdirSync(aiLogDir).filter((name) => name.startsWith("ai_") && name.endsWith(".log")).map((name) => {
-    const filePath = path4.join(aiLogDir, name);
-    const stat2 = fs3.statSync(filePath);
-    return { path: filePath, mtimeMs: stat2.mtimeMs };
-  }).sort((a, b) => b.mtimeMs - a.mtimeMs)[0];
-  return latest?.path ?? null;
+function parseRange(query) {
+  const mode = query.mode === "recent" ? "recent" : "year";
+  return {
+    mode,
+    year: parseInteger(query.year),
+    days: query.days === "365" ? 365 : void 0
+  };
 }
-function resolveAiLogPath(ctx) {
-  const currentPath = ctx.getCurrentAiLogPath?.();
-  if (currentPath && fs3.existsSync(currentPath)) return currentPath;
-  return findLatestAiLogPath(ctx.pathProvider.getLogsDir());
+function parseInteger(value) {
+  if (!value) return void 0;
+  const parsed = Number(value);
+  return Number.isInteger(parsed) ? parsed : void 0;
 }
-function isLoopbackAddress(address) {
-  if (!address) return true;
-  const normalized = address.replace(/^::ffff:/, "");
-  return normalized === "localhost" || normalized === "::1" || normalized === "0:0:0:0:0:0:0:1" || normalized.startsWith("127.");
+function isTruthy2(value) {
+  return value === "1" || value === "true" || value === "yes";
 }
-function registerAiLogRoutes(server2, ctx) {
-  server2.post("/_web/ai/logs/show", async (request, reply) => {
-    if (!ctx.showInFolder) return reply.code(501).send({ success: false, error: "Not supported" });
-    if (!isLoopbackAddress(request.ip)) {
-      return { success: false, error: "Opening AI logs is only supported on this device" };
-    }
-    const logPath = resolveAiLogPath(ctx);
-    if (!logPath) return { success: false, error: "No AI log files found" };
-    try {
-      await ctx.showInFolder(logPath);
-      return { success: true, path: logPath };
-    } catch (error) {
-      return { success: false, error: error instanceof Error ? error.message : String(error) };
-    }
+
+// ../../packages/http-routes/src/routes/web/logs.ts
+function registerLogRoutes(server2) {
+  server2.post("/_web/logs/report", async (req, reply) => {
+    const { level, message, stack, url } = req.body ?? {};
+    if (!message) return reply.code(400).send({ error: "message required" });
+    const detail = [url ? `url=${url}` : null, stack ? `
+${stack}` : null].filter(Boolean).join(" ");
+    if (level === "warn") appLogger.warn("web", message, detail || void 0);
+    else appLogger.error("web", message, detail || void 0);
+    return { ok: true };
   });
 }
 
-// ../../packages/http-routes/src/routes/web/ai-semantic-index.ts
-import path5 from "path";
-function registerSemanticIndexRoutes(server2, ctx) {
-  const service = ctx.semanticIndexService;
-  if (!service) {
-    if (ctx.aiDataDir) {
-      const configStore = new SemanticIndexConfigStore(path5.join(ctx.aiDataDir, SEMANTIC_INDEX_CONFIG_FILE));
-      const configResponse = (config) => ({
-        config,
-        apiKeySet: resolveSemanticIndexApiKeySet(config, ctx.resolveApiKey),
-        configured: isSemanticIndexConfigured(config)
-      });
-      server2.get("/_web/ai/semantic-index/config", async () => ({
-        ...configResponse(configStore.get()),
-        modelStatus: "idle"
-      }));
-      server2.put(
-        "/_web/ai/semantic-index/config",
-        async (request) => {
-          const config = persistSemanticIndexConfig(configStore, request.body.config, {
-            apiKey: request.body.apiKey,
-            writeAuthProfile: ctx.writeAuthProfile
-          });
-          return { ...configResponse(config), modelStatus: "idle" };
-        }
-      );
-    }
-    server2.get("/_web/ai/semantic-index/enabled", async () => ({ sessions: [] }));
-    server2.get("/_web/ai/semantic-index/status", async () => ({ status: null }));
-    server2.post("/_web/ai/semantic-index/status", async () => ({ sessions: [] }));
-    return;
-  }
-  server2.get("/_web/ai/semantic-index/config", async () => {
-    return {
-      config: await service.getConfig(),
-      apiKeySet: await service.hasApiKey(),
-      configured: await service.isConfigured(),
-      modelStatus: await service.getModelStatus()
-    };
+// ../../packages/http-routes/src/routes/web/members.ts
+function registerMemberRoutes(server2, ctx) {
+  const { sessionAdapter: adapter } = ctx;
+  server2.get("/_web/sessions/:id/members", async (request) => {
+    return member_service_exports.getMembers(adapter, request.params.id);
   });
-  server2.put(
-    "/_web/ai/semantic-index/config",
+  server2.get("/_web/sessions/:id/members/paginated", async (request) => {
+    return member_service_exports.getMembersPaginated(adapter, request.params.id, {
+      page: parseInt(request.query.page || "1", 10),
+      pageSize: parseInt(request.query.pageSize || "20", 10),
+      search: request.query.search,
+      sortOrder: request.query.sortOrder === "asc" ? "asc" : "desc"
+    });
+  });
+  server2.patch(
+    "/_web/sessions/:id/members/:memberId/aliases",
     async (request) => {
-      const config = await service.setConfig(request.body.config, { apiKey: request.body.apiKey });
-      return {
-        config,
-        apiKeySet: await service.hasApiKey(),
-        configured: await service.isConfigured(),
-        modelStatus: await service.getModelStatus()
-      };
+      const memberId = parseInt(request.params.memberId, 10);
+      member_service_exports.updateMemberAliases(adapter, request.params.id, memberId, request.body.aliases);
+      return { success: true };
+    }
+  );
+  server2.delete(
+    "/_web/sessions/:id/members/:memberId",
+    async (request) => {
+      const memberId = parseInt(request.params.memberId, 10);
+      member_service_exports.deleteMember(adapter, request.params.id, memberId);
+      return { success: true };
     }
   );
-  server2.get("/_web/ai/semantic-index/enabled", async () => {
-    return { sessions: await service.listEnabledStatuses() };
-  });
-  server2.get("/_web/ai/semantic-index/status", async (request) => {
-    return { status: await service.status(request.query.sessionId) };
-  });
-  server2.post("/_web/ai/semantic-index/status", async (request) => {
-    return { sessions: await service.statusForSessions(request.body.sessionIds ?? []) };
-  });
-  const sessionAction = (path14, action) => {
-    server2.post(path14, async (request, reply) => {
-      const { sessionId } = request.body;
-      if (!sessionId) return reply.code(400).send({ error: "sessionId is required" });
-      await action(sessionId);
-      return { status: await service.status(sessionId) };
-    });
-  };
-  sessionAction("/_web/ai/semantic-index/enable", (id) => service.enable(id));
-  sessionAction("/_web/ai/semantic-index/remove", (id) => service.remove(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 () => {
-    await service.buildAllPending();
-    return { sessions: await service.listEnabledStatuses() };
-  });
-  server2.post("/_web/ai/semantic-index/cleanup", async () => {
-    return await service.cleanupUnused();
-  });
   server2.post(
-    "/_web/ai/semantic-index/search",
+    "/_web/sessions/:id/members/batch-delete",
     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 });
+      const memberIds = request.body?.memberIds;
+      if (!Array.isArray(memberIds) || memberIds.length === 0 || memberIds.some((memberId) => !Number.isSafeInteger(memberId) || Number(memberId) <= 0)) {
+        return reply.code(400).send({
+          success: false,
+          error: "memberIds must contain at least one positive integer"
+        });
+      }
+      const uniqueMemberIds = Array.from(new Set(memberIds));
+      try {
+        const success = member_service_exports.deleteMembers(adapter, request.params.id, uniqueMemberIds);
+        if (!success) {
+          throw new Error("Member deletion transaction returned no result");
+        }
+      } catch (error) {
+        if (apiErrorFromUnknown(error) || isHttpClientError(error)) throw error;
+        appLogger.error("members", "Batch member deletion failed", error);
+        return reply.code(500).send({ success: false, error: "Failed to delete selected members" });
+      }
+      appLogger.info("members", "Batch member deletion completed", {
+        sessionId: request.params.id,
+        memberCount: uniqueMemberIds.length
+      });
+      return { success: true, deletedCount: uniqueMemberIds.length };
+    }
+  );
+  server2.post(
+    "/_web/sessions/:id/members/merge",
+    async (request) => {
+      const { memberId1, memberId2 } = request.body;
+      member_service_exports.mergeMembers(adapter, request.params.id, memberId1, memberId2);
+      return { success: true };
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/members/:memberId/history",
+    async (request) => {
+      const memberId = parseInt(request.params.memberId, 10);
+      return member_service_exports.getMemberNameHistory(adapter, request.params.id, memberId);
     }
   );
 }
+function isHttpClientError(error) {
+  return error instanceof Error && "statusCode" in error && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500;
+}
 
 // ../../packages/http-routes/src/routes/web/merge.ts
 import * as fs4 from "fs";
-import * as os from "os";
 import * as path6 from "path";
-function ensureDb2(ctx, sessionId) {
+function ensureDb(ctx, sessionId) {
   const db = ctx.dbManager.open(sessionId);
   if (!db) throw sessionNotFound(sessionId);
   return db;
@@ -2062,7 +2319,7 @@ 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 = fs4.mkdtempSync(path6.join(os.tmpdir(), "chatlab-merge-"));
+      const tmpDir = createChatLabTempDir("merge", "upload-");
       const tmpPath = path6.join(tmpDir, data.filename || "upload");
       const chunks = [];
       for await (const chunk of data.file) {
@@ -2155,7 +2412,7 @@ function registerMergeRoutes(server2, ctx) {
           return reply.code(501).send({ error: "Import not available on this server" });
         }
         const jsonData = JSON.stringify(merged.chatLabData);
-        const tmpDir = fs4.mkdtempSync(path6.join(os.tmpdir(), "chatlab-merged-"));
+        const tmpDir = createChatLabTempDir("merge", "import-");
         const safeName = path6.basename(outputName).replace(/[/\\?%*:|"<>]/g, "_") || "merged";
         const tmpPath = path6.join(tmpDir, `${safeName}.json`);
         fs4.writeFileSync(tmpPath, jsonData, "utf-8");
@@ -2204,7 +2461,7 @@ function registerMergeRoutes(server2, ctx) {
     }
     const handles = [];
     for (const sid of sessionIds) {
-      const db = ensureDb2(ctx, sid);
+      const db = ensureDb(ctx, sid);
       const exported = exportSessionToJson(db);
       const { db: tempDb, tempDbPath } = mergeCache.createTempDatabase(exported.meta.name);
       const writer = new TempDbWriter(tempDb);
@@ -2237,240 +2494,293 @@ function registerMergeRoutes(server2, ctx) {
       const handle = mergeCache.store(exported.meta.name, tempDbPath);
       handles.push({ sessionId: sid, handle });
     }
-    return { success: true, handles };
+    return { success: true, handles };
+  });
+}
+
+// ../../packages/http-routes/src/routes/web/nlp.ts
+import * as fs5 from "fs";
+import * as path7 from "path";
+function registerNlpRoutes(server2, ctx) {
+  const nlpDir = path7.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 () => {
+    return POS_TAG_DEFINITIONS;
+  });
+  server2.get("/_web/nlp/dicts", async () => {
+    return getDictList(nlpDir);
+  });
+  server2.get("/_web/nlp/dicts/:id/status", async (request) => {
+    return isDictDownloaded(nlpDir, request.params.id);
+  });
+  server2.post("/_web/nlp/dicts/:id/download", async (request) => {
+    return downloadDict(nlpDir, request.params.id);
+  });
+  server2.delete("/_web/nlp/dicts/:id", async (request) => {
+    return deleteDict(nlpDir, request.params.id);
+  });
+  server2.post("/_web/nlp/word-frequency", async (request) => {
+    const params = request.body;
+    const db = ctx.dbManager.open(params.sessionId);
+    if (!db) {
+      throw Object.assign(new Error(`Session not found: ${params.sessionId}`), { statusCode: 404 });
+    }
+    const { sessionId, ...keyParams } = params;
+    const effectiveDictId = !params.dictType || params.dictType === "default" ? "zh-CN" : String(params.dictType);
+    const dictFilePath = path7.join(nlpDir, `${effectiveDictId}.dict`);
+    let dictVersion;
+    try {
+      const st = fs5.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",
+    async (request) => {
+      const { text, locale, minLength } = request.body;
+      return segmentText(text, locale, minLength);
+    }
+  );
 }
 
-// ../../packages/http-routes/src/routes/web/cache.ts
-import * as fs5 from "fs";
-import * as fsp from "fs/promises";
-import * as path7 from "path";
-async function getDirSize(dirPath) {
-  let totalSize = 0;
-  try {
-    if (!fs5.existsSync(dirPath)) return 0;
-    const files = await fsp.readdir(dirPath, { withFileTypes: true });
-    for (const file of files) {
-      const filePath = path7.join(dirPath, file.name);
-      if (file.isDirectory()) {
-        totalSize += await getDirSize(filePath);
-      } else {
-        const stat2 = await fsp.stat(filePath);
-        totalSize += stat2.size;
-      }
+// ../../packages/http-routes/src/routes/web/people-relationships.ts
+function registerPeopleRelationshipsRoutes(server2, ctx) {
+  const service = ctx.peopleRelationshipsService ?? createPeopleRelationshipsService({
+    adapter: ctx.sessionAdapter,
+    pathProvider: ctx.pathProvider,
+    runtimeIdentity: ctx.runtimeIdentity,
+    nativeBinding: ctx.nativeBinding
+  });
+  server2.addHook("onClose", async () => {
+    await service.close();
+  });
+  server2.get("/_web/people/relationships", async (request) => {
+    return service.getGraph({
+      acceptStale: isTruthy3(request.query.acceptStale),
+      timeRangePreset: parseContactsTimeRangePreset2(request.query.timeRange),
+      graphScope: parsePeopleRelationshipsGraphScope(request.query.scope),
+      query: request.query.q
+    });
+  });
+  server2.post("/_web/people/relationships/recompute", async (request) => {
+    return service.startRecompute({
+      timeRangePreset: parseContactsTimeRangePreset2(request.query.timeRange),
+      graphScope: parsePeopleRelationshipsGraphScope(request.query.scope),
+      query: request.query.q
+    });
+  });
+  server2.get(
+    "/_web/people/relationships/:key/neighborhood",
+    async (request) => {
+      return service.getNeighborhood(request.params.key, {
+        acceptStale: isTruthy3(request.query.acceptStale),
+        timeRangePreset: parseContactsTimeRangePreset2(request.query.timeRange)
+      });
     }
-  } catch {
-  }
-  return totalSize;
+  );
 }
-async function getFileCount(dirPath) {
-  let count = 0;
-  try {
-    if (!fs5.existsSync(dirPath)) return 0;
-    const files = await fsp.readdir(dirPath, { withFileTypes: true });
-    for (const file of files) {
-      const filePath = path7.join(dirPath, file.name);
-      if (file.isDirectory()) {
-        count += await getFileCount(filePath);
-      } else {
-        count++;
-      }
-    }
-  } catch {
-  }
-  return count;
+function isTruthy3(value) {
+  return value === "1" || value === "true" || value === "yes";
 }
-function hasChatLabDatabases(dirPath) {
-  try {
-    const markerPath = path7.join(dirPath, ".chatlab");
-    const dbDir = path7.join(dirPath, "databases");
-    if (!fs5.existsSync(markerPath) || !fs5.existsSync(dbDir)) return false;
-    return fs5.readdirSync(dbDir).some((file) => file.endsWith(".db"));
-  } catch {
-    return false;
-  }
+function parseContactsTimeRangePreset2(value) {
+  return CONTACTS_TIME_RANGE_PRESETS.includes(value) ? value : "1y";
 }
-function registerCacheRoutes(server2, ctx) {
-  const pp = ctx.pathProvider;
-  const downloadsDir = ctx.downloadsDir ?? pp.getDownloadsDir();
-  server2.get("/_web/cache/info", async () => {
-    const directories = [
-      {
-        id: "databases",
-        name: "settings.storage.cache.databases.name",
-        description: "settings.storage.cache.databases.description",
-        path: pp.getDatabaseDir(),
-        scope: "user-data",
-        rootPath: pp.getUserDataDir(),
-        icon: "i-heroicons-circle-stack",
-        canClear: false
-      },
-      {
-        id: "ai",
-        name: "settings.storage.cache.ai.name",
-        description: "settings.storage.cache.ai.description",
-        path: pp.getAiDataDir(),
-        scope: "system-data",
-        rootPath: pp.getSystemDir(),
-        icon: "i-heroicons-sparkles",
-        canClear: false
-      },
-      {
-        id: "cache",
-        name: "settings.storage.cache.statsCache.name",
-        description: "settings.storage.cache.statsCache.description",
-        path: pp.getCacheDir(),
-        scope: "system-data",
-        rootPath: pp.getSystemDir(),
-        icon: "i-heroicons-bolt",
-        canClear: true
-      },
-      {
-        id: "logs",
-        name: "settings.storage.cache.logs.name",
-        description: "settings.storage.cache.logs.description",
-        path: pp.getLogsDir(),
-        scope: "system-data",
-        rootPath: pp.getSystemDir(),
-        icon: "i-heroicons-document-text",
-        canClear: true
-      }
-    ];
-    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: fs5.existsSync(dir.path) };
-      })
-    );
-    return {
-      baseDir: pp.getSystemDir(),
-      directories: results,
-      totalSize: results.reduce((sum, d) => sum + d.size, 0)
-    };
+function parsePeopleRelationshipsGraphScope(value) {
+  return value === "close" || value === "friends" ? value : "panorama";
+}
+
+// ../../packages/http-routes/src/routes/web/preferences.ts
+function registerPreferencesRoutes(server2, ctx) {
+  const prefManager = ctx.preferencesManager ?? new PreferencesManager(ctx.pathProvider.getSystemDir());
+  server2.get("/_web/preferences", async () => {
+    return prefManager.load();
   });
-  server2.post("/_web/cache/clear", async (request) => {
-    const { cacheId } = request.body;
-    const allowedDirs = {
-      cache: pp.getCacheDir(),
-      logs: pp.getLogsDir()
-    };
-    const dirPath = allowedDirs[cacheId];
-    if (!dirPath) return { success: false, error: "Not allowed to clear this directory" };
-    if (!fs5.existsSync(dirPath)) return { success: true };
-    const files = await fsp.readdir(dirPath);
-    for (const file of files) {
-      const filePath = path7.join(dirPath, file);
-      const stat2 = await fsp.stat(filePath);
-      if (stat2.isDirectory()) {
-        await fsp.rm(filePath, { recursive: true });
-      } else {
-        await fsp.unlink(filePath);
+  server2.patch("/_web/preferences", async (request) => {
+    return prefManager.save(request.body);
+  });
+  server2.get("/_web/preferences/ui-config", async () => {
+    const config = loadConfig();
+    return config.ui;
+  });
+  server2.patch("/_web/preferences/ui-config", async (request) => {
+    try {
+      for (const [key, value] of Object.entries(request.body)) {
+        if (value !== void 0) {
+          writeConfigField("ui", key, value);
+        }
       }
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
     }
+  });
+  server2.get("/_web/preferences/locale", async () => {
+    const config = loadConfig();
+    return { lang: config.locale.lang };
+  });
+  server2.patch("/_web/preferences/locale", async (request) => {
+    try {
+      writeConfigField("locale", "lang", request.body.lang);
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  });
+}
+
+// ../../packages/http-routes/src/routes/web/session-index.ts
+function registerSessionIndexRoutes(server2, ctx) {
+  const { sessionAdapter: adapter } = ctx;
+  server2.get("/_web/sessions/index-stats", async () => {
+    return session_index_service_exports.getAllIndexStats(adapter);
+  });
+  server2.post("/_web/sessions/:id/generate-index", async (request) => {
+    const gapThreshold = request.body?.gapThreshold ?? 1800;
+    const sessionCount = session_index_service_exports.generateIndex(adapter, request.params.id, gapThreshold);
+    return { sessionCount };
+  });
+  server2.post("/_web/sessions/:id/generate-incremental-index", async (request) => {
+    const gapThreshold = request.body?.gapThreshold ?? 1800;
+    const sessionCount = session_index_service_exports.generateIncrementalIndex(adapter, request.params.id, gapThreshold);
+    return { sessionCount };
+  });
+  server2.post("/_web/sessions/:id/clear-index", async (request) => {
+    session_index_service_exports.clearIndex(adapter, request.params.id);
     return { success: true };
   });
-  server2.get("/_web/cache/data-dir", async () => {
-    const pending = ctx.getPendingDataDirMigration?.();
-    return {
-      path: pp.getUserDataDir(),
-      defaultPath: ctx.defaultUserDataDir,
-      isCustom: ctx.isCustomDataDir ?? false,
-      canSetDataDir: ctx.canSetDataDir ?? Boolean(ctx.setDataDir),
-      managedScope: "chat-databases",
-      managedDescription: "settings.storage.dataLocation.managedDescription",
-      hasLegacyDataAtDefaultDir: Boolean(ctx.defaultUserDataDir) && path7.resolve(pp.getUserDataDir()) !== path7.resolve(ctx.defaultUserDataDir ?? "") && hasChatLabDatabases(ctx.defaultUserDataDir ?? ""),
-      pendingMigration: pending ? {
-        from: pending.from,
-        to: pending.to,
-        createdAt: pending.createdAt
-      } : void 0
-    };
+  server2.get("/_web/sessions/:id/search/fts", async (request, reply) => {
+    if (!session_index_service_exports.getFtsStatus(adapter, request.params.id)) {
+      return reply.code(400).send({ error: "FTS index not built for this session" });
+    }
+    const keywords = request.query.keywords.split(/\s+/).filter(Boolean);
+    if (keywords.length === 0) return { rowids: [], total: 0 };
+    const limit = parseInt(request.query.limit || "100", 10);
+    const offset = parseInt(request.query.offset || "0", 10);
+    return session_index_service_exports.searchFts(adapter, request.params.id, keywords, limit, offset);
+  });
+  server2.get("/_web/sessions/:id/fts/status", async (request) => {
+    return { hasFtsIndex: session_index_service_exports.getFtsStatus(adapter, request.params.id) };
+  });
+  server2.post("/_web/sessions/:id/fts/rebuild", async (request) => {
+    const result = session_index_service_exports.rebuildFts(adapter, request.params.id);
+    return { success: true, indexed: result.indexed };
   });
-  server2.post("/_web/cache/data-dir", async (request, reply) => {
-    if (!ctx.setDataDir) {
-      return reply.code(501).send({ success: false, error: "Data directory changes are not supported" });
-    }
-    const targetPath = typeof request.body?.path === "string" ? request.body.path : null;
-    const migrate = request.body?.migrate !== false;
-    return ctx.setDataDir(targetPath, migrate);
+}
+
+// ../../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 () => {
+    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/cache/latest-import-log", async () => {
-    const importLogDir = path7.join(pp.getLogsDir(), "import");
-    if (!fs5.existsSync(importLogDir)) {
-      return { success: false, error: "Log directory not found" };
+  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 });
     }
-    const files = await fsp.readdir(importLogDir);
-    const logFiles = files.filter((f) => f.startsWith("import_") && f.endsWith(".log"));
-    if (logFiles.length === 0) {
-      return { success: false, error: "No import logs found" };
+    if (ctx.aiChatManager) {
+      session.aiConversationCount = ctx.aiChatManager.getAIChats(request.params.id).length;
     }
-    const fileStats = await Promise.all(
-      logFiles.map(async (f) => {
-        const filePath = path7.join(importLogDir, f);
-        const stat2 = await fsp.stat(filePath);
-        return { name: f, path: filePath, mtime: stat2.mtime.getTime() };
-      })
-    );
-    fileStats.sort((a, b) => b.mtime - a.mtime);
-    return { success: true, path: fileStats[0].path, name: fileStats[0].name };
+    return session;
   });
-  server2.post("/_web/cache/save-to-downloads", async (request) => {
-    const { filename, dataUrl } = request.body;
-    if (!filename || !dataUrl) {
-      return { success: false, error: "filename and dataUrl are required" };
+  server2.delete("/_web/sessions/:id", async (request, reply) => {
+    const { id } = request.params;
+    try {
+      const deleted = session_service_exports.deleteSession(adapter, id);
+      if (!deleted) {
+        return reply.code(404).send({ success: false, error: "File not found" });
+      }
+      return { success: true };
+    } catch (err) {
+      return reply.code(500).send({ success: false, error: String(err) });
     }
-    let buffer;
-    if (dataUrl.includes(";base64,")) {
-      const base64Data = dataUrl.split(";base64,")[1];
-      buffer = Buffer.from(base64Data, "base64");
-    } else if (dataUrl.includes("charset=utf-8,")) {
-      const textData = dataUrl.split("charset=utf-8,")[1];
-      buffer = Buffer.from(decodeURIComponent(textData), "utf-8");
-    } else {
-      const base64Data = dataUrl.replace(/^data:[^,]+,/, "");
-      buffer = Buffer.from(base64Data, "base64");
+  });
+  server2.patch("/_web/sessions/:id/name", async (request) => {
+    session_service_exports.renameSession(adapter, request.params.id, request.body.name);
+    return { success: true };
+  });
+  server2.patch(
+    "/_web/sessions/:id/owner",
+    async (request) => {
+      session_service_exports.updateSessionOwnerId(adapter, request.params.id, request.body.ownerId ?? null);
+      return { success: true };
     }
-    if (!fs5.existsSync(downloadsDir)) {
-      fs5.mkdirSync(downloadsDir, { recursive: 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
+      );
     }
-    const filePath = path7.join(downloadsDir, filename);
-    fs5.writeFileSync(filePath, buffer);
-    return { success: true, filePath };
+  );
+  server2.post("/_web/sessions/:id/owner/dismiss-prompt", async (request) => {
+    owner_profile_service_exports.dismissOwnerPrompt(preferences(), request.params.id);
+    return { success: true };
   });
-  server2.post("/_web/cache/open-dir", async (request, reply) => {
-    if (!ctx.openDirectory) return reply.code(501).send({ success: false, error: "Not supported" });
-    const { cacheId } = request.body;
-    const dirPaths = {
-      base: pp.getSystemDir(),
-      userData: pp.getUserDataDir(),
-      databases: pp.getDatabaseDir(),
-      cache: pp.getCacheDir(),
-      ai: pp.getAiDataDir(),
-      logs: pp.getLogsDir(),
-      downloads: downloadsDir
-    };
-    const dirPath = dirPaths[cacheId];
-    if (!dirPath) return { success: false, error: "Unknown directory" };
-    if (!fs5.existsSync(dirPath)) {
-      await fsp.mkdir(dirPath, { recursive: true });
+}
+
+// ../../packages/http-routes/src/routes/web/sql.ts
+function registerSqlRoutes(server2, ctx) {
+  const { sessionAdapter: adapter } = ctx;
+  server2.post("/_web/sessions/:id/sql", async (request, reply) => {
+    const db = adapter.ensureReadonly(request.params.id);
+    const { sql } = request.body || {};
+    if (!sql || typeof sql !== "string") {
+      return reply.code(400).send({ error: "Missing sql parameter" });
     }
     try {
-      await ctx.openDirectory(dirPath);
-    } catch (error) {
-      return { success: false, error: error instanceof Error ? error.message : String(error) };
+      const result = executeSql(db, sql, { columnar: true, timing: true, maxRows: 0 });
+      return {
+        columns: result.columns,
+        rows: result.rows,
+        rowCount: result.rowCount,
+        duration: result.duration ?? 0,
+        limited: result.truncated
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "SQL execution error";
+      return reply.code(400).send({ error: message });
     }
-    return { success: true };
   });
-  server2.post("/_web/cache/show-in-folder", async (request, reply) => {
-    if (!ctx.showInFolder) return reply.code(501).send({ success: false, error: "Not supported" });
-    const { filePath } = request.body;
-    if (!filePath) return { success: false, error: "filePath is required" };
-    try {
-      await ctx.showInFolder(filePath);
-    } catch (error) {
-      return { success: false, error: error instanceof Error ? error.message : String(error) };
+  server2.get("/_web/sessions/:id/schema", async (request) => {
+    const db = adapter.ensureReadonly(request.params.id);
+    return getSchemaDetailed(db);
+  });
+  server2.post("/_web/sessions/:id/query", async (request) => {
+    const db = adapter.ensureReadonly(request.params.id);
+    const { sql, params = [] } = request.body;
+    if (!sql || typeof sql !== "string") {
+      throw Object.assign(new Error('Missing or invalid "sql" field'), { statusCode: 400 });
     }
-    return { success: true };
+    const stmt = db.prepare(sql.trim());
+    if (!stmt.readonly) {
+      throw Object.assign(new Error("Only READ-ONLY statements are allowed"), { statusCode: 403 });
+    }
+    if (Array.isArray(params)) {
+      return stmt.all(...params);
+    }
+    return stmt.all(params);
   });
 }
 
@@ -2500,25 +2810,9 @@ function registerTelemetryRoutes(server2, ctx) {
   );
 }
 
-// ../../packages/http-routes/src/routes/web/logs.ts
-function registerLogRoutes(server2, _ctx) {
-  server2.post("/_web/logs/report", async (req, reply) => {
-    const { level, message, stack, url } = req.body ?? {};
-    if (!message) return reply.code(400).send({ error: "message required" });
-    const detail = [url ? `url=${url}` : null, stack ? `
-${stack}` : null].filter(Boolean).join(" ");
-    if (level === "warn") appLogger.warn("web", message, detail || void 0);
-    else appLogger.error("web", message, detail || void 0);
-    return { ok: true };
-  });
-}
-
-// ../../packages/http-routes/src/register.ts
-function registerSharedRoutes(server2, ctx, options) {
+// ../../packages/http-routes/src/routes/web/register.ts
+function registerWebRoutes(server2, ctx, options) {
   const resolvedCtx = ctx.preferencesManager ? ctx : { ...ctx, preferencesManager: new PreferencesManager(ctx.pathProvider.getSystemDir()) };
-  registerSystemRoutes(server2, resolvedCtx);
-  registerRestSessionRoutes(server2, resolvedCtx);
-  registerImportRoutes(server2, resolvedCtx);
   registerSessionRoutes(server2, resolvedCtx);
   registerMemberRoutes(server2, resolvedCtx);
   registerContactsRoutes(server2, resolvedCtx);
@@ -2530,77 +2824,17 @@ function registerSharedRoutes(server2, ctx, options) {
   registerSessionIndexRoutes(server2, resolvedCtx);
   registerExportRoutes(server2, resolvedCtx);
   registerNlpRoutes(server2, resolvedCtx);
-  if (options?.requireAi) {
-    const missing = [];
-    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, resolvedCtx);
-  registerAiSkillRoutes(server2, resolvedCtx);
-  registerAiLlmRoutes(server2, resolvedCtx);
-  registerAiLlmStreamRoutes(server2, resolvedCtx);
-  registerAiAgentStreamRoutes(server2, resolvedCtx);
-  registerAiToolRoutes(server2, resolvedCtx);
-  registerAiChatRoutes(server2, resolvedCtx);
-  registerAiSummaryRoutes(server2, resolvedCtx);
-  registerAiLogRoutes(server2, resolvedCtx);
-  registerSemanticIndexRoutes(server2, resolvedCtx);
+  registerAiRoutes(server2, resolvedCtx, options);
   registerMergeRoutes(server2, resolvedCtx);
   registerCacheRoutes(server2, resolvedCtx);
   registerTelemetryRoutes(server2, resolvedCtx);
-  registerLogRoutes(server2, resolvedCtx);
+  registerLogRoutes(server2);
 }
 
-// ../../packages/http-routes/src/auth.ts
-import { timingSafeEqual, createHmac, randomBytes } from "crypto";
-var cachedToken = null;
-var requireAuthEnabled = false;
-function setAuthToken(token) {
-  cachedToken = token;
-}
-function setRequireAuth(enabled) {
-  requireAuthEnabled = enabled;
-}
-var hmacKey = randomBytes(32);
-function safeTokenCompare(a, b) {
-  const hashA = createHmac("sha256", hmacKey).update(a).digest();
-  const hashB = createHmac("sha256", hmacKey).update(b).digest();
-  return timingSafeEqual(hashA, hashB);
-}
-async function authHook(request, reply) {
-  if (!cachedToken) return;
-  const url = request.url;
-  if (url.startsWith("/api/")) {
-    return requireBearerToken(request, reply);
-  }
-  if (url.startsWith("/_web/")) {
-    if (requireAuthEnabled) return requireBearerToken(request, reply);
-    return;
-  }
-}
-function requireBearerToken(request, reply) {
-  if (!cachedToken) return;
-  const authHeader = request.headers.authorization;
-  if (!authHeader || !authHeader.startsWith("Bearer ")) {
-    const err = unauthorized();
-    reply.code(err.statusCode).send(errorResponse(err));
-    return;
-  }
-  const token = authHeader.slice(7);
-  if (!safeTokenCompare(token, cachedToken)) {
-    const err = unauthorized();
-    reply.code(err.statusCode).send(errorResponse(err));
-    return;
-  }
+// ../../packages/http-routes/src/register.ts
+function registerSharedRoutes(server2, ctx, options) {
+  registerRestRoutes(server2, ctx);
+  registerWebRoutes(server2, ctx, options);
 }
 
 // ../../packages/http-routes/src/routes/web/automation.ts
@@ -2747,44 +2981,8 @@ function registerAutomationRoutes(server2, ctx) {
   });
 }
 
-// src/http/server.ts
-var JSON_BODY_LIMIT = 50 * 1024 * 1024;
-function createServer() {
-  const server2 = Fastify({
-    logger: false,
-    bodyLimit: JSON_BODY_LIMIT
-  });
-  server2.addHook("onRequest", authHook);
-  server2.setErrorHandler((error, request, reply) => {
-    const apiError = apiErrorFromUnknown(error);
-    if (apiError) {
-      reply.code(apiError.statusCode).send(errorResponse(apiError));
-      return;
-    }
-    if (error.statusCode === 413) {
-      const bodyErr = new ApiError("BODY_TOO_LARGE" /* BODY_TOO_LARGE */, "Request body exceeds 50MB limit");
-      reply.code(413).send(errorResponse(bodyErr));
-      return;
-    }
-    const statusCode = error.statusCode;
-    if (statusCode && statusCode >= 400 && statusCode < 600) {
-      reply.code(statusCode).send({ success: false, error: { code: "CLIENT_ERROR", message: error.message } });
-      return;
-    }
-    appLogger.error("http", `${request.method} ${request.url} -> 500`, error);
-    const err = serverError(error.message);
-    reply.code(err.statusCode).send(errorResponse(err));
-  });
-  return server2;
-}
-
-// src/http/routes/web/index.ts
-import * as os3 from "os";
-import * as path10 from "path";
-
 // src/http/routes/web/import.ts
 import * as fs7 from "fs";
-import * as os2 from "os";
 import * as path8 from "path";
 import { randomUUID } from "crypto";
 import { pipeline } from "stream/promises";
@@ -2815,9 +3013,7 @@ function cleanupTemp(...paths) {
   }
 }
 function registerImportRoutes2(server2, dbManager2, options = {}) {
-  const sourceManager = options.sourceManager ?? new ArchiveImportSourceManager({
-    tempRoot: fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-import-sources-"))
-  });
+  const sourceManager = options.sourceManager ?? new ArchiveImportSourceManager();
   const runAutoImport = options.runAutoImport ?? autoImport.bind(null, dbManager2);
   const runPreparedImport = options.runPreparedImport ?? (async (manifestPath, onProgress) => {
     const result = await runAutoImport(manifestPath, {
@@ -2835,7 +3031,7 @@ function registerImportRoutes2(server2, dbManager2, options = {}) {
       limits: { fileSize: ARCHIVE_UPLOAD_LIMIT }
     });
     if (!data) return reply.code(400).send({ success: false, error: "error.no_file_selected" });
-    const uploadPath = path8.join(os2.tmpdir(), `chatlab-archive-${randomUUID()}.zip`);
+    const uploadPath = path8.join(getChatLabTempScopeDir("imports"), `archive-${randomUUID()}.zip`);
     try {
       await pipeline(data.file, fs7.createWriteStream(uploadPath, { flags: "wx" }));
       if (data.file.truncated) {
@@ -2902,7 +3098,7 @@ data: ${JSON.stringify(eventData)}
   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 = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-detect-"));
+    const tmpDir = createChatLabTempDir("imports", "detect-");
     const tmpPath = path8.join(tmpDir, data.filename || "upload");
     try {
       const chunks = [];
@@ -2920,7 +3116,7 @@ data: ${JSON.stringify(eventData)}
   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 = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-scan-"));
+    const tmpDir = createChatLabTempDir("imports", "scan-");
     const tmpPath = path8.join(tmpDir, data.filename || "upload");
     try {
       const chunks = [];
@@ -2937,7 +3133,7 @@ data: ${JSON.stringify(eventData)}
   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 = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-import-"));
+    const tmpDir = createChatLabTempDir("imports", "upload-");
     const tmpPath = path8.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
@@ -2981,7 +3177,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 = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-dir-import-"));
+    const tmpDir = createChatLabTempDir("imports", "directory-");
     const relativePaths = [];
     const fileBuffers = [];
     try {
@@ -3052,7 +3248,7 @@ 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 = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-inc-"));
+    const tmpDir = createChatLabTempDir("imports", "incremental-");
     const tmpPath = path8.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
@@ -3090,7 +3286,7 @@ 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 = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-analyze-"));
+    const tmpDir = createChatLabTempDir("imports", "analyze-");
     const tmpPath = path8.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
@@ -3108,7 +3304,7 @@ 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 = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-analyze-"));
+    const tmpDir = createChatLabTempDir("imports", "analyze-");
     const tmpPath = path8.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
@@ -3144,7 +3340,7 @@ data: ${JSON.stringify(eventData)}
 
 `);
     }
-    const tmpDir = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-demo-"));
+    const tmpDir = createChatLabTempDir("imports", "cli-demo-");
     try {
       const localPaths = [];
       for (let i = 0; i < total; i++) {
@@ -3231,29 +3427,29 @@ function buildWebUpdateCheckResult(options) {
 }
 
 // src/http/routes/web/index.ts
-function registerWebRoutes(server2, dbManager2, options) {
+function registerWebRoutes2(server2, dbManager2, options) {
   const adapter = createDatabaseManagerAdapter(dbManager2);
   const mergeCache = options?.pathProvider ? new MergeSessionCache(options.pathProvider, { nativeBinding: options.nativeBinding }) : null;
   mergeCache?.cleanupOrphans();
   const fallbackPathProvider = {
-    getSystemDir: () => path10.join(os3.homedir(), ".chatlab"),
-    getUserDataDir: () => path10.join(os3.homedir(), ".chatlab", "data"),
-    getDatabaseDir: () => path10.join(os3.homedir(), ".chatlab", "data", "databases"),
-    getVectorDir: () => path10.join(os3.homedir(), ".chatlab", "data", "vector"),
-    getAiDataDir: () => path10.join(os3.homedir(), ".chatlab", "ai"),
-    getSettingsDir: () => path10.join(os3.homedir(), ".chatlab", "settings"),
-    getCacheDir: () => path10.join(os3.homedir(), ".chatlab", "cache"),
-    getTempDir: () => path10.join(os3.homedir(), ".chatlab", "temp"),
-    getLogsDir: () => path10.join(os3.homedir(), ".chatlab", "logs"),
-    getDownloadsDir: () => path10.join(os3.homedir(), "Downloads")
+    getSystemDir: () => path10.join(os.homedir(), ".chatlab"),
+    getUserDataDir: () => path10.join(os.homedir(), ".chatlab", "data"),
+    getDatabaseDir: () => path10.join(os.homedir(), ".chatlab", "data", "databases"),
+    getVectorDir: () => path10.join(os.homedir(), ".chatlab", "data", "vector"),
+    getAiDataDir: () => path10.join(os.homedir(), ".chatlab", "ai"),
+    getSettingsDir: () => path10.join(os.homedir(), ".chatlab", "settings"),
+    getCacheDir: () => path10.join(os.homedir(), ".chatlab", "cache"),
+    getTempDir: () => getChatLabTempScopeDir("runtime"),
+    getLogsDir: () => path10.join(os.homedir(), ".chatlab", "logs"),
+    getDownloadsDir: () => path10.join(os.homedir(), "Downloads")
   };
   const resolvedPathProvider = options?.pathProvider ?? fallbackPathProvider;
   const ai = options?.aiContext;
   const cliStreamImport = async (dm, filePath) => {
-    const { streamImport: streamImport2 } = await import("./stream-import-BPCHGRAN.mjs");
+    const { streamImport: streamImport2 } = await import("./stream-import-ERTT7U6V.mjs");
     const result = await streamImport2(dm, filePath);
     if (!result.success) {
-      const { IMPORT_IN_PROGRESS_ERROR_KEY: IMPORT_IN_PROGRESS_ERROR_KEY2, ImportInProgressError: ImportInProgressError2 } = await import("./src-MNH5S423.mjs");
+      const { IMPORT_IN_PROGRESS_ERROR_KEY: IMPORT_IN_PROGRESS_ERROR_KEY2, ImportInProgressError: ImportInProgressError2 } = await import("./src-ZOCLFBCJ.mjs");
       if (result.error === IMPORT_IN_PROGRESS_ERROR_KEY2) throw new ImportInProgressError2();
       throw new Error(result.error || "Import failed");
     }
@@ -3357,73 +3553,14 @@ function registerProxyRoutes(server2) {
   });
 }
 
-// src/ai/manager-factory.ts
-import * as fs8 from "fs";
-import * as path11 from "path";
-import { createHash, randomUUID as randomUUID2 } from "crypto";
-var nodeFs = {
-  ensureDir(dir) {
-    if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
-  },
-  listFiles(dir, ext) {
-    if (!fs8.existsSync(dir)) return [];
-    return fs8.readdirSync(dir).filter((f) => f.endsWith(ext));
-  },
-  readFile(filePath) {
-    return fs8.readFileSync(filePath, "utf-8");
-  },
-  writeFile(filePath, content) {
-    fs8.writeFileSync(filePath, content, "utf-8");
-  },
-  deleteFile(filePath) {
-    if (fs8.existsSync(filePath)) fs8.unlinkSync(filePath);
-  },
-  fileExists(filePath) {
-    return fs8.existsSync(filePath);
-  },
-  joinPath(...parts) {
-    return path11.join(...parts);
-  }
-};
-var managerCache = /* @__PURE__ */ new Map();
-function getAssistantManager(aiDataDir) {
-  let cached = managerCache.get(aiDataDir);
-  if (!cached) {
-    cached = {
-      assistant: new AssistantManager({
-        fs: nodeFs,
-        assistantsDir: path11.join(aiDataDir, "assistants"),
-        builtinRawConfigs: [],
-        generateId: () => `custom_${randomUUID2().replace(/-/g, "").slice(0, 12)}`
-      }),
-      skill: new SkillManagerCore({
-        fs: nodeFs,
-        skillsDir: path11.join(aiDataDir, "skills"),
-        builtinRawSkills: [],
-        contentHash: (content) => createHash("md5").update(content).digest("hex")
-      })
-    };
-    managerCache.set(aiDataDir, cached);
-  }
-  return cached.assistant;
-}
-function getSkillManagerCore(aiDataDir) {
-  let cached = managerCache.get(aiDataDir);
-  if (!cached) {
-    getAssistantManager(aiDataDir);
-    cached = managerCache.get(aiDataDir);
-  }
-  return cached.skill;
-}
-
 // ../../packages/sync/src/types.ts
 var noop = () => {
 };
 var NOOP_LOGGER = { info: noop, warn: noop, error: noop };
 
 // ../../packages/sync/src/data-source-manager.ts
-import * as fs9 from "fs";
-import * as path12 from "path";
+import * as fs8 from "fs";
+import * as path11 from "path";
 import * as crypto from "crypto";
 var CONFIG_FILE = "data-sources.json";
 function generateId(prefix = "ds") {
@@ -3451,17 +3588,17 @@ var DataSourceManager = class {
     this.logger = logger ?? NOOP_LOGGER;
   }
   getConfigPath() {
-    return path12.join(this.configDir, CONFIG_FILE);
+    return path11.join(this.configDir, CONFIG_FILE);
   }
   ensureDir() {
-    fs9.mkdirSync(this.configDir, { recursive: true });
+    fs8.mkdirSync(this.configDir, { recursive: true });
   }
   // ==================== Load / Save ====================
   loadAll() {
     try {
       const filePath = this.getConfigPath();
-      if (fs9.existsSync(filePath)) {
-        const raw = fs9.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.");
@@ -3480,7 +3617,7 @@ var DataSourceManager = class {
   saveAll(sources) {
     try {
       this.ensureDir();
-      fs9.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);
     }
@@ -3574,7 +3711,7 @@ var DataSourceManager = class {
 };
 
 // ../../packages/sync/src/pull-engine.ts
-import * as fs10 from "fs";
+import * as fs9 from "fs";
 import * as crypto2 from "crypto";
 var MAX_PAGES_PER_PULL = 5e3;
 var PULL_OVERLAP_SECONDS = 60;
@@ -3596,7 +3733,7 @@ function parseSyncFromFile(filePath) {
   try {
     const isJsonl = filePath.endsWith(".jsonl");
     if (isJsonl) {
-      const content = fs10.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 {
@@ -3615,7 +3752,7 @@ function parseSyncFromFile(filePath) {
       }
       return null;
     }
-    const raw = fs10.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;
@@ -3629,7 +3766,7 @@ function parseSyncFromFile(filePath) {
 function fileContainsMessages(filePath) {
   try {
     if (filePath.endsWith(".jsonl")) {
-      const content = fs10.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;
@@ -3642,7 +3779,7 @@ function fileContainsMessages(filePath) {
       }
       return false;
     }
-    const raw = fs10.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 {
@@ -3659,7 +3796,7 @@ function getMaxMessageTimestampFromFile(filePath) {
       }
     };
     if (filePath.endsWith(".jsonl")) {
-      const content = fs10.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;
@@ -3672,7 +3809,7 @@ function getMaxMessageTimestampFromFile(filePath) {
       }
       return maxTs;
     }
-    const raw = fs10.readFileSync(filePath, "utf-8");
+    const raw = fs9.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (Array.isArray(parsed.messages)) {
       for (const message of parsed.messages) {
@@ -3686,7 +3823,7 @@ function getMaxMessageTimestampFromFile(filePath) {
 }
 function cleanupTempFile(filePath) {
   try {
-    if (fs10.existsSync(filePath)) fs10.unlinkSync(filePath);
+    if (fs9.existsSync(filePath)) fs9.unlinkSync(filePath);
   } catch {
   }
 }
@@ -3783,7 +3920,7 @@ var PullEngine = class {
           limit: ds.pullLimit
         });
         try {
-          const stat2 = fs10.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) {
@@ -3803,7 +3940,7 @@ var PullEngine = class {
                   offset,
                   limit: ds.pullLimit
                 });
-                const retryStat = fs10.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) {
@@ -4153,13 +4290,12 @@ function reloadTimer(dsId, skipInitialPull = false) {
 }
 
 // src/sync/adapters.ts
-import * as fs11 from "fs";
-import * as os4 from "os";
-import * as path13 from "path";
+import * as fs10 from "fs";
+import * as path12 from "path";
 import * as crypto3 from "crypto";
 function getTempFilePath(ext) {
   const id = crypto3.randomBytes(8).toString("hex");
-  return path13.join(os4.tmpdir(), `chatlab-pull-${id}${ext}`);
+  return path12.join(getChatLabTempScopeDir("sync"), `pull-${id}${ext}`);
 }
 var NodeFetcher = class {
   async fetchToTempFile(baseUrl, remoteSessionId, token, params) {
@@ -4176,7 +4312,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());
-    fs11.writeFileSync(tempFile, buffer);
+    fs10.writeFileSync(tempFile, buffer);
     return tempFile;
   }
 };
@@ -4189,7 +4325,7 @@ var DirectImporter = class {
   }
   sessionExists(sessionId) {
     const dbPath = this.dbManager.getDbPath(sessionId);
-    if (!fs11.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();
@@ -4197,7 +4333,7 @@ var DirectImporter = class {
       if (row.cnt === 0) {
         this.logger.warn(`[DirectImporter] DB file exists but has no message table: ${sessionId}, removing`);
         try {
-          fs11.unlinkSync(dbPath);
+          fs10.unlinkSync(dbPath);
         } catch {
         }
         return false;
@@ -4207,7 +4343,7 @@ var DirectImporter = class {
       if (error instanceof DataDirCompatibilityError) throw error;
       this.logger.warn(`[DirectImporter] Cannot validate DB file: ${sessionId}, removing`);
       try {
-        fs11.unlinkSync(dbPath);
+        fs10.unlinkSync(dbPath);
       } catch {
       }
       return false;
@@ -4330,25 +4466,10 @@ function cleanupSync() {
 var server = null;
 var dbManager = null;
 var aiChatManager = null;
-function createFileConfigStorage(aiDataDir) {
-  return {
-    readJson(key) {
-      try {
-        return JSON.parse(fs12.readFileSync(`${aiDataDir}/${key}.json`, "utf-8"));
-      } catch {
-        return null;
-      }
-    },
-    writeJson(key, data) {
-      if (!fs12.existsSync(aiDataDir)) fs12.mkdirSync(aiDataDir, { recursive: true });
-      fs12.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 (fs12.existsSync(nativePath)) return nativePath;
+  if (fs11.existsSync(nativePath)) return nativePath;
   return void 0;
 }
 function ensureToken(config) {
@@ -4402,20 +4523,11 @@ async function startHttpServer(options) {
   aiChatManager = new AIChatManager(aiDataDir, { nativeBinding });
   const assistantManager = getAssistantManager(aiDataDir);
   const skillManagerCore = getSkillManagerCore(aiDataDir);
-  const llmConfigStore = new LLMConfigStore(createFileConfigStorage(aiDataDir), {
-    resolveApiKey: (provider, authProfile) => resolveApiKey(provider, authProfile) || void 0,
-    onApiKeyCreated: (config2, apiKey) => {
-      const profileName = config2.name?.toLowerCase().replace(/\s+/g, "-") || config2.provider;
-      writeAuthProfile(profileName, { type: "api_key", provider: config2.provider, key: apiKey });
-      return profileName;
-    },
-    onApiKeyDeleted: (config2) => {
-      const profileName = config2.authProfile;
-      if (profileName) deleteAuthProfile(profileName);
-    }
-  });
+  const configStorage = createFileConfigStorage(aiDataDir);
+  const llmConfigStore = createAuthProfileLlmConfigStore(configStorage);
   initAppLogger(pathProvider.getLogsDir());
   initServerAiLogger(pathProvider.getLogsDir());
+  appLogger.info("temp-workspace", "Temporary workspace initialized", { root: pathProvider.getTempDir() });
   appLogger.info("server", `HTTP server starting on ${host}:${port}`);
   logNativeParserStatus();
   setAuthToken(token);
@@ -4439,7 +4551,7 @@ async function startHttpServer(options) {
     console.warn("[semantic-index] worker client unavailable:", err instanceof Error ? err.message : String(err));
     semanticIndexService = void 0;
   }
-  registerWebRoutes(server, dbManager, {
+  registerWebRoutes2(server, dbManager, {
     pathProvider,
     nativeBinding,
     runtimeIdentity: runtime,
@@ -4450,13 +4562,13 @@ async function startHttpServer(options) {
       assistantManager,
       skillManagerCore,
       llmConfigStore,
-      customProviderStore: new CustomProviderStore(createFileConfigStorage(aiDataDir)),
-      customModelStore: new CustomModelStore(createFileConfigStorage(aiDataDir)),
+      customProviderStore: new CustomProviderStore(configStorage),
+      customModelStore: new CustomModelStore(configStorage),
       runAgentStream: createCliRunAgentStream(dbManager, aiChatManager, semanticIndexService)
     }
   });
   initSync(server, dbManager, pathProvider, { port, host, token });
-  if (options?.webRoot && fs12.existsSync(options.webRoot)) {
+  if (options?.webRoot && fs11.existsSync(options.webRoot)) {
     registerProxyRoutes(server);
     const fastifyStatic = await import("@fastify/static");
     await server.register(fastifyStatic.default, {
@@ -4493,8 +4605,8 @@ async function stopHttpServer() {
 
 export {
   createServer,
-  registerWebRoutes,
+  registerWebRoutes2 as registerWebRoutes,
   startHttpServer,
   stopHttpServer
 };
-//# sourceMappingURL=chunk-BSSR4ZYW.mjs.map
+//# sourceMappingURL=chunk-GZO3NAHC.mjs.map