chatlab-cli 0.28.1 → 0.30.0

package/dist/{chunk-AB6TAXTQ.mjs → chunk-4IZ3WKYU.mjs}

@@ -4,30 +4,31 @@ import { fileURLToPath as __fileURLToPath } from 'url';
 const require = __createRequire(import.meta.url);
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
+import {
+  analyzeIncrementalImport,
+  analyzeNewImport,
+  incrementalImport,
+  streamImport
+} from "./chunk-FCCL5Z4W.mjs";
 import {
   closeServerAiLogger,
   createCliRunAgentStream,
+  getServerAiLogger,
   initServerAiLogger
-} from "./chunk-ERAAWLEF.mjs";
+} from "./chunk-ZFU2CHW3.mjs";
 import {
   AGENT_TOOL_REGISTRY,
   CoreDataProvider
-} from "./chunk-3QBVO4J7.mjs";
+} from "./chunk-5UBHNQFZ.mjs";
 import {
   assertCliDataDirCompatible
-} from "./chunk-NJB2NNB2.mjs";
+} from "./chunk-RDR6PS2R.mjs";
 import {
   getVersion
 } from "./chunk-5ADKYYNA.mjs";
 import {
   resolveCliPath
 } from "./chunk-FJ35V3TE.mjs";
-import {
-  analyzeIncrementalImport,
-  analyzeNewImport,
-  incrementalImport,
-  streamImport
-} from "./chunk-T7IETWHN.mjs";
 import {
   AnalyticsService,
   NodePathProvider,
@@ -38,59 +39,80 @@ import {
   createJiebaNlpProvider,
   createNodeDataDirSwitch,
   createSemanticIndexWorkerRuntimeClient,
-  getDbFileVersion,
   getDefaultNodeUserDataDir,
-  getOrComputeAnalysisCache,
   getPendingNodeDataDirMigration,
   hasPendingElectronDataWarning,
   serializeChatLabToJsonl
-} from "./chunk-YBS3YQB6.mjs";
+} from "./chunk-P3ZOLTGS.mjs";
 import {
   AIChatManager,
-  ALL_MIGRATIONS,
   ArchiveImportError,
   ArchiveImportSourceManager,
   AssistantManager,
-  BUILTIN_MODELS,
-  BUILTIN_PROVIDERS,
-  BUILTIN_TOOL_CATALOG,
   CustomModelStore,
   CustomProviderStore,
-  DataDirCompatibilityError,
-  DatabaseManager,
   LLMConfigStore,
   MergeSessionCache,
-  MigrationRunner,
-  POS_TAG_DEFINITIONS,
   SEMANTIC_INDEX_CONFIG_FILE,
   SemanticIndexConfigStore,
   SkillManagerCore,
   TempDbWriter,
-  appLogger,
   buildPiModel,
   computeWordFrequency,
   countMessagesTokens,
-  createDatabaseManagerAdapter,
-  deleteAuthProfile,
+  createContactsService,
+  createPeopleRelationshipsService,
   deleteDict,
   detectAllFormats,
   detectFormat,
   downloadDict,
   ensureDefaultDict,
-  executeReadonlySql,
-  executeSql,
   exportSessionToJson,
   export_service_exports,
   fetchRemoteModels,
   findEntryFileInDirectory,
+  getDefaultRulesForLocale,
+  getDictList,
+  getSupportedFormats,
+  isDictDownloaded,
+  isSemanticIndexConfigured,
+  member_service_exports,
+  mergeRulesForLocale,
+  owner_profile_service_exports,
+  persistSemanticIndexConfig,
+  pushImport,
+  resolveSemanticIndexApiKeySet,
+  runSimpleLlmStream,
+  scanMultiChatFile,
+  segmentText,
+  session_index_service_exports,
+  session_service_exports,
+  streamParseFileInfo,
+  summary_service_exports,
+  validateApiKey
+} from "./chunk-A2SANKG4.mjs";
+import {
+  ALL_MIGRATIONS,
+  BUILTIN_MODELS,
+  BUILTIN_PROVIDERS,
+  BUILTIN_TOOL_CATALOG,
+  CONTACTS_TIME_RANGE_PRESETS,
+  DataDirCompatibilityError,
+  DatabaseManager,
+  MigrationRunner,
+  POS_TAG_DEFINITIONS,
+  appLogger,
+  createDatabaseManagerAdapter,
+  deleteAuthProfile,
+  executeReadonlySql,
+  executeSql,
   getAvailableYears,
   getBuiltinModelsByProvider,
   getCatchphraseAnalysis,
   getCheckInAnalysis,
   getClusterGraph,
   getDailyActivity,
-  getDefaultRulesForLocale,
-  getDictList,
+  getDbFileVersion,
   getDivingAnalysis,
   getDragonKingAnalysis,
   getHourlyActivity,
@@ -109,13 +131,13 @@ import {
   getMessageTypeStats,
   getMonthlyActivity,
   getNightOwlAnalysis,
+  getOrComputeAnalysisCache,
   getRelationshipStats,
   getRepeatAnalysis,
   getSchemaDetailed,
   getSessionInfo,
   getSessionMeta,
   getSessionOverview,
-  getSupportedFormats,
   getTextLengthPercentiles,
   getTextStats,
   getTimeRange,
@@ -123,34 +145,18 @@ import {
   getYearlyActivity,
   initAppLogger,
   initNlpDir,
-  isDictDownloaded,
   isNewerStableVersion,
-  isSemanticIndexConfigured,
   loadConfig,
-  member_service_exports,
-  mergeRulesForLocale,
-  owner_profile_service_exports,
-  persistSemanticIndexConfig,
-  pushImport,
   queryMessages,
   resolveApiKey,
-  resolveSemanticIndexApiKeySet,
-  runSimpleLlmStream,
-  scanMultiChatFile,
-  segmentText,
-  session_index_service_exports,
-  session_service_exports,
-  streamParseFileInfo,
   stripAvatarFields,
-  summary_service_exports,
-  validateApiKey,
   verifyCliDataPath,
   writeAuthProfile,
   writeConfigField
-} from "./chunk-ZVDOFWL7.mjs";
+} from "./chunk-7BZLS2KW.mjs";
 
 // src/http/index.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 import * as crypto4 from "crypto";
 
 // src/http/server.ts
@@ -626,6 +632,121 @@ function registerMemberRoutes(server2, ctx) {
   );
 }
 
+// ../../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 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.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.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: isTruthy2(request.query.acceptStale),
+        timeRangePreset: parseContactsTimeRangePreset2(request.query.timeRange)
+      });
+    }
+  );
+}
+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/preferences.ts
 function registerPreferencesRoutes(server2, ctx) {
   const prefManager = ctx.preferencesManager ?? new PreferencesManager(ctx.pathProvider.getSystemDir());
@@ -977,7 +1098,14 @@ function registerSqlRoutes(server2, ctx) {
       return reply.code(400).send({ error: "Missing sql parameter" });
     }
     try {
-      return executeSql(db, sql, { timing: true });
+      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 });
@@ -1674,13 +1802,53 @@ function registerAiSummaryRoutes(server2, ctx) {
   });
 }
 
-// ../../packages/http-routes/src/routes/web/ai-semantic-index.ts
+// ../../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 resolveAiLogPath(ctx) {
+  const currentPath = ctx.getCurrentAiLogPath?.();
+  if (currentPath && fs3.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" };
+    }
+    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/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(path4.join(ctx.aiDataDir, SEMANTIC_INDEX_CONFIG_FILE));
+      const configStore = new SemanticIndexConfigStore(path5.join(ctx.aiDataDir, SEMANTIC_INDEX_CONFIG_FILE));
       const configResponse = (config) => ({
         config,
         apiKeySet: resolveSemanticIndexApiKeySet(config, ctx.resolveApiKey),
@@ -1735,8 +1903,8 @@ function registerSemanticIndexRoutes(server2, ctx) {
   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 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);
@@ -1767,9 +1935,9 @@ function registerSemanticIndexRoutes(server2, ctx) {
 }
 
 // ../../packages/http-routes/src/routes/web/merge.ts
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 import * as os from "os";
-import * as path5 from "path";
+import * as path6 from "path";
 function ensureDb2(ctx, sessionId) {
   const db = ctx.dbManager.open(sessionId);
   if (!db) throw sessionNotFound(sessionId);
@@ -1786,31 +1954,31 @@ function registerMergeRoutes(server2, ctx) {
     if (contentType.includes("multipart/form-data")) {
       const data = await request.file();
       if (!data) return reply.code(400).send({ error: "No file uploaded" });
-      const tmpDir = fs3.mkdtempSync(path5.join(os.tmpdir(), "chatlab-merge-"));
-      const tmpPath = path5.join(tmpDir, data.filename || "upload");
+      const tmpDir = fs4.mkdtempSync(path6.join(os.tmpdir(), "chatlab-merge-"));
+      const tmpPath = path6.join(tmpDir, data.filename || "upload");
       const chunks = [];
       for await (const chunk of data.file) {
         chunks.push(chunk);
       }
-      fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
+      fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
       filePath = tmpPath;
       cleanupFile = true;
       cleanupDir = tmpDir;
     } else {
       const body = request.body;
       if (!body?.filePath) return reply.code(400).send({ error: "Missing filePath in body" });
-      if (!fs3.existsSync(body.filePath)) return reply.code(400).send({ error: "File not found" });
+      if (!fs4.existsSync(body.filePath)) return reply.code(400).send({ error: "File not found" });
       filePath = body.filePath;
     }
     try {
       const result = await streamParseFileInfo(filePath, {
         createTempDatabase(sourceFilePath) {
-          return mergeCache.createTempDatabase(path5.basename(sourceFilePath));
+          return mergeCache.createTempDatabase(path6.basename(sourceFilePath));
         },
         onProgress() {
         }
       });
-      const filename = path5.basename(filePath);
+      const filename = path6.basename(filePath);
       const handle = mergeCache.store(filename, result.tempDbPath);
       return {
         handle,
@@ -1824,13 +1992,13 @@ function registerMergeRoutes(server2, ctx) {
     } finally {
       if (cleanupFile) {
         try {
-          fs3.unlinkSync(filePath);
+          fs4.unlinkSync(filePath);
         } catch {
         }
       }
       if (cleanupDir) {
         try {
-          fs3.rmdirSync(cleanupDir);
+          fs4.rmdirSync(cleanupDir);
         } catch {
         }
       }
@@ -1879,20 +2047,20 @@ function registerMergeRoutes(server2, ctx) {
           return reply.code(501).send({ error: "Import not available on this server" });
         }
         const jsonData = JSON.stringify(merged.chatLabData);
-        const tmpDir = fs3.mkdtempSync(path5.join(os.tmpdir(), "chatlab-merged-"));
-        const safeName = path5.basename(outputName).replace(/[/\\?%*:|"<>]/g, "_") || "merged";
-        const tmpPath = path5.join(tmpDir, `${safeName}.json`);
-        fs3.writeFileSync(tmpPath, jsonData, "utf-8");
+        const tmpDir = fs4.mkdtempSync(path6.join(os.tmpdir(), "chatlab-merged-"));
+        const safeName = path6.basename(outputName).replace(/[/\\?%*:|"<>]/g, "_") || "merged";
+        const tmpPath = path6.join(tmpDir, `${safeName}.json`);
+        fs4.writeFileSync(tmpPath, jsonData, "utf-8");
         try {
           const importResult = await streamImport2(dbManager2, tmpPath);
           sessionId = importResult.sessionId;
         } finally {
           try {
-            fs3.unlinkSync(tmpPath);
+            fs4.unlinkSync(tmpPath);
           } catch {
           }
           try {
-            fs3.rmdirSync(tmpDir);
+            fs4.rmdirSync(tmpDir);
           } catch {
           }
         }
@@ -1966,16 +2134,16 @@ function registerMergeRoutes(server2, ctx) {
 }
 
 // ../../packages/http-routes/src/routes/web/cache.ts
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 import * as fsp from "fs/promises";
-import * as path6 from "path";
+import * as path7 from "path";
 async function getDirSize(dirPath) {
   let totalSize = 0;
   try {
-    if (!fs4.existsSync(dirPath)) return 0;
+    if (!fs5.existsSync(dirPath)) return 0;
     const files = await fsp.readdir(dirPath, { withFileTypes: true });
     for (const file of files) {
-      const filePath = path6.join(dirPath, file.name);
+      const filePath = path7.join(dirPath, file.name);
       if (file.isDirectory()) {
         totalSize += await getDirSize(filePath);
       } else {
@@ -1990,10 +2158,10 @@ async function getDirSize(dirPath) {
 async function getFileCount(dirPath) {
   let count = 0;
   try {
-    if (!fs4.existsSync(dirPath)) return 0;
+    if (!fs5.existsSync(dirPath)) return 0;
     const files = await fsp.readdir(dirPath, { withFileTypes: true });
     for (const file of files) {
-      const filePath = path6.join(dirPath, file.name);
+      const filePath = path7.join(dirPath, file.name);
       if (file.isDirectory()) {
         count += await getFileCount(filePath);
       } else {
@@ -2006,10 +2174,10 @@ async function getFileCount(dirPath) {
 }
 function hasChatLabDatabases(dirPath) {
   try {
-    const markerPath = path6.join(dirPath, ".chatlab");
-    const dbDir = path6.join(dirPath, "databases");
-    if (!fs4.existsSync(markerPath) || !fs4.existsSync(dbDir)) return false;
-    return fs4.readdirSync(dbDir).some((file) => file.endsWith(".db"));
+    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;
   }
@@ -2055,7 +2223,7 @@ function registerCacheRoutes(server2, ctx) {
     const results = await Promise.all(
       directories.map(async (dir) => {
         const [size, fileCount] = await Promise.all([getDirSize(dir.path), getFileCount(dir.path)]);
-        return { ...dir, size, fileCount, exists: fs4.existsSync(dir.path) };
+        return { ...dir, size, fileCount, exists: fs5.existsSync(dir.path) };
       })
     );
     return {
@@ -2072,10 +2240,10 @@ function registerCacheRoutes(server2, ctx) {
     };
     const dirPath = allowedDirs[cacheId];
     if (!dirPath) return { success: false, error: "Not allowed to clear this directory" };
-    if (!fs4.existsSync(dirPath)) return { success: true };
+    if (!fs5.existsSync(dirPath)) return { success: true };
     const files = await fsp.readdir(dirPath);
     for (const file of files) {
-      const filePath = path6.join(dirPath, file);
+      const filePath = path7.join(dirPath, file);
       const stat2 = await fsp.stat(filePath);
       if (stat2.isDirectory()) {
         await fsp.rm(filePath, { recursive: true });
@@ -2092,7 +2260,7 @@ function registerCacheRoutes(server2, ctx) {
       defaultPath: ctx.defaultUserDataDir,
       isCustom: ctx.isCustomDataDir ?? false,
       canSetDataDir: ctx.canSetDataDir ?? Boolean(ctx.setDataDir),
-      hasLegacyDataAtDefaultDir: Boolean(ctx.defaultUserDataDir) && path6.resolve(pp.getUserDataDir()) !== path6.resolve(ctx.defaultUserDataDir ?? "") && hasChatLabDatabases(ctx.defaultUserDataDir ?? ""),
+      hasLegacyDataAtDefaultDir: Boolean(ctx.defaultUserDataDir) && path7.resolve(pp.getUserDataDir()) !== path7.resolve(ctx.defaultUserDataDir ?? "") && hasChatLabDatabases(ctx.defaultUserDataDir ?? ""),
       pendingMigration: pending ? {
         from: pending.from,
         to: pending.to,
@@ -2109,8 +2277,8 @@ function registerCacheRoutes(server2, ctx) {
     return ctx.setDataDir(targetPath, migrate);
   });
   server2.get("/_web/cache/latest-import-log", async () => {
-    const importLogDir = path6.join(pp.getLogsDir(), "import");
-    if (!fs4.existsSync(importLogDir)) {
+    const importLogDir = path7.join(pp.getLogsDir(), "import");
+    if (!fs5.existsSync(importLogDir)) {
       return { success: false, error: "Log directory not found" };
     }
     const files = await fsp.readdir(importLogDir);
@@ -2120,7 +2288,7 @@ function registerCacheRoutes(server2, ctx) {
     }
     const fileStats = await Promise.all(
       logFiles.map(async (f) => {
-        const filePath = path6.join(importLogDir, f);
+        const filePath = path7.join(importLogDir, f);
         const stat2 = await fsp.stat(filePath);
         return { name: f, path: filePath, mtime: stat2.mtime.getTime() };
       })
@@ -2144,11 +2312,11 @@ function registerCacheRoutes(server2, ctx) {
       const base64Data = dataUrl.replace(/^data:[^,]+,/, "");
       buffer = Buffer.from(base64Data, "base64");
     }
-    if (!fs4.existsSync(downloadsDir)) {
-      fs4.mkdirSync(downloadsDir, { recursive: true });
+    if (!fs5.existsSync(downloadsDir)) {
+      fs5.mkdirSync(downloadsDir, { recursive: true });
     }
-    const filePath = path6.join(downloadsDir, filename);
-    fs4.writeFileSync(filePath, buffer);
+    const filePath = path7.join(downloadsDir, filename);
+    fs5.writeFileSync(filePath, buffer);
     return { success: true, filePath };
   });
   server2.post("/_web/cache/open-dir", async (request, reply) => {
@@ -2164,7 +2332,7 @@ function registerCacheRoutes(server2, ctx) {
     };
     const dirPath = dirPaths[cacheId];
     if (!dirPath) return { success: false, error: "Unknown directory" };
-    if (!fs4.existsSync(dirPath)) {
+    if (!fs5.existsSync(dirPath)) {
       await fsp.mkdir(dirPath, { recursive: true });
     }
     try {
@@ -2234,6 +2402,8 @@ function registerSharedRoutes(server2, ctx, options) {
   registerImportRoutes(server2, resolvedCtx);
   registerSessionRoutes(server2, resolvedCtx);
   registerMemberRoutes(server2, resolvedCtx);
+  registerContactsRoutes(server2, resolvedCtx);
+  registerPeopleRelationshipsRoutes(server2, resolvedCtx);
   registerPreferencesRoutes(server2, resolvedCtx);
   registerAnalyticsRoutes(server2, resolvedCtx);
   registerSqlRoutes(server2, resolvedCtx);
@@ -2262,6 +2432,7 @@ function registerSharedRoutes(server2, ctx, options) {
   registerAiToolRoutes(server2, resolvedCtx);
   registerAiChatRoutes(server2, resolvedCtx);
   registerAiSummaryRoutes(server2, resolvedCtx);
+  registerAiLogRoutes(server2, resolvedCtx);
   registerSemanticIndexRoutes(server2, resolvedCtx);
   registerMergeRoutes(server2, resolvedCtx);
   registerCacheRoutes(server2, resolvedCtx);
@@ -2312,6 +2483,150 @@ function requireBearerToken(request, reply) {
   }
 }
 
+// ../../packages/http-routes/src/routes/web/automation.ts
+function requireAutomation(ctx) {
+  return ctx.automation ?? null;
+}
+function normalizeBaseUrl(input) {
+  let url = input.trim().replace(/\/+$/, "");
+  if (url && !/^https?:\/\//i.test(url)) url = `http://${url}`;
+  if (url && !url.endsWith("/api/v1")) {
+    url = url.replace(/\/api\/v1$/, "") + "/api/v1";
+  }
+  return url;
+}
+function buildRemoteSessionsUrl(baseUrl, query = {}) {
+  const searchParams = new URLSearchParams();
+  searchParams.set("format", "chatlab");
+  if (query.keyword?.trim()) searchParams.set("keyword", query.keyword.trim());
+  if (query.limit && Number(query.limit) > 0) searchParams.set("limit", String(query.limit));
+  if (query.cursor) searchParams.set("cursor", query.cursor);
+  return `${baseUrl}/sessions?${searchParams.toString()}`;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function parseRemoteSessionsResponse(body) {
+  const parsed = JSON.parse(body);
+  let sessions;
+  let pageSource;
+  if (Array.isArray(parsed)) {
+    sessions = parsed;
+  } else {
+    const record = asRecord(parsed);
+    const data = asRecord(record?.data);
+    const sessionsSource = record?.sessions ?? data?.sessions ?? record?.data;
+    sessions = Array.isArray(sessionsSource) ? sessionsSource : [];
+    pageSource = asRecord(record?.page) ?? asRecord(data?.page);
+  }
+  return {
+    sessions,
+    page: pageSource && typeof pageSource === "object" ? {
+      hasMore: Boolean(pageSource.hasMore),
+      nextCursor: typeof pageSource.nextCursor === "string" ? pageSource.nextCursor : void 0
+    } : void 0
+  };
+}
+function registerAutomationRoutes(server2, ctx) {
+  server2.get("/_web/automation/config", async (_request, reply) => {
+    const automation = requireAutomation(ctx);
+    if (!automation?.serverInfo) return reply.code(404).send({ error: "Automation is not enabled" });
+    return {
+      enabled: true,
+      port: automation.serverInfo.port,
+      token: automation.serverInfo.token,
+      host: automation.serverInfo.host
+    };
+  });
+  server2.get("/_web/automation/data-sources", async (_request, reply) => {
+    const automation = requireAutomation(ctx);
+    if (!automation) return reply.code(404).send({ error: "Automation is not enabled" });
+    return automation.dsManager.loadAll();
+  });
+  server2.post("/_web/automation/data-sources", async (request, reply) => {
+    const automation = requireAutomation(ctx);
+    if (!automation) return reply.code(404).send({ error: "Automation is not enabled" });
+    const ds = automation.dsManager.add(request.body);
+    automation.reloadTimer?.(ds.id);
+    return ds;
+  });
+  server2.patch("/_web/automation/data-sources/:id", async (request, reply) => {
+    const automation = requireAutomation(ctx);
+    if (!automation) return reply.code(404).send({ error: "Automation is not enabled" });
+    const ds = automation.dsManager.update(request.params.id, request.body);
+    if (!ds) return reply.code(404).send({ error: "Data source not found" });
+    automation.reloadTimer?.(ds.id);
+    return ds;
+  });
+  server2.delete("/_web/automation/data-sources/:id", async (request, reply) => {
+    const automation = requireAutomation(ctx);
+    if (!automation) return reply.code(404).send({ error: "Automation is not enabled" });
+    automation.stopTimer?.(request.params.id);
+    const ok = automation.dsManager.delete(request.params.id);
+    if (!ok) return reply.code(404).send({ error: "Data source not found" });
+    return { success: true };
+  });
+  server2.post("/_web/automation/data-sources/:id/sessions", async (request, reply) => {
+    const automation = requireAutomation(ctx);
+    if (!automation) return reply.code(404).send({ error: "Automation is not enabled" });
+    const added = automation.dsManager.addSessions(request.params.id, request.body.sessions);
+    if (added.length === 0 && !automation.dsManager.get(request.params.id)) {
+      return reply.code(404).send({ error: "Data source not found" });
+    }
+    automation.reloadTimer?.(request.params.id, true);
+    for (const sess of added) {
+      void automation.pullEngine.triggerPull(request.params.id, sess.id).catch(() => void 0);
+    }
+    return added;
+  });
+  server2.delete("/_web/automation/data-sources/:id/sessions/:sessId", async (request, reply) => {
+    const automation = requireAutomation(ctx);
+    if (!automation) return reply.code(404).send({ error: "Automation is not enabled" });
+    const removed = automation.dsManager.removeSession(request.params.id, request.params.sessId);
+    if (!removed) return reply.code(404).send({ error: "Session not found" });
+    automation.reloadTimer?.(request.params.id);
+    if (request.query.deleteData === "true" && removed.targetSessionId) {
+      automation.deleteSessionData?.(removed.targetSessionId);
+    }
+    return { success: true };
+  });
+  server2.post(
+    "/_web/automation/data-sources/:id/pull",
+    async (request, reply) => {
+      const automation = requireAutomation(ctx);
+      if (!automation) return reply.code(404).send({ error: "Automation is not enabled" });
+      return automation.pullEngine.triggerPull(request.params.id, request.body?.sessionId);
+    }
+  );
+  server2.post("/_web/automation/data-sources/:id/pull-all", async (request, reply) => {
+    const automation = requireAutomation(ctx);
+    if (!automation) return reply.code(404).send({ error: "Automation is not enabled" });
+    return automation.pullEngine.triggerPullAll(request.params.id);
+  });
+  server2.get("/_web/automation/sync-progress", async (_request, reply) => {
+    const automation = requireAutomation(ctx);
+    if (!automation) return reply.code(404).send({ error: "Automation is not enabled" });
+    return automation.pullEngine.getProgress();
+  });
+  server2.get("/_web/automation/remote-sessions", async (request, reply) => {
+    const automation = requireAutomation(ctx);
+    if (!automation) return reply.code(404).send({ error: "Automation is not enabled" });
+    const { baseUrl, token, keyword, limit, cursor } = request.query;
+    if (!baseUrl) return reply.code(400).send({ error: "baseUrl is required" });
+    const url = buildRemoteSessionsUrl(normalizeBaseUrl(baseUrl), { keyword, limit, cursor });
+    const headers = { Accept: "application/json" };
+    if (token) headers.Authorization = `Bearer ${token}`;
+    try {
+      const resp = await fetch(url, { headers, signal: AbortSignal.timeout(3e4) });
+      if (!resp.ok) throw new Error(`Remote server returned HTTP ${resp.status}`);
+      const body = await resp.text();
+      return parseRemoteSessionsResponse(body);
+    } catch (err) {
+      return reply.code(502).send({ error: err instanceof Error ? err.message : "Failed to fetch remote sessions" });
+    }
+  });
+}
+
 // src/http/server.ts
 var JSON_BODY_LIMIT = 50 * 1024 * 1024;
 function createServer() {
@@ -2345,21 +2660,21 @@ function createServer() {
 
 // src/http/routes/web/index.ts
 import * as os3 from "os";
-import * as path9 from "path";
+import * as path10 from "path";
 
 // src/http/routes/web/import.ts
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as os2 from "os";
-import * as path7 from "path";
+import * as path8 from "path";
 import { randomUUID } from "crypto";
 import { pipeline } from "stream/promises";
 
 // src/http/routes/web/helpers.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 function resolveNativeBinding() {
   if (process.versions.electron) return void 0;
   const nativePath = resolveCliPath("native/better_sqlite3.node");
-  if (fs5.existsSync(nativePath)) return nativePath;
+  if (fs6.existsSync(nativePath)) return nativePath;
   return void 0;
 }
 
@@ -2369,11 +2684,11 @@ var ARCHIVE_UPLOAD_LIMIT = 50 * 1024 * 1024 * 1024;
 function cleanupTemp(...paths) {
   for (const p of paths) {
     try {
-      const stat2 = fs6.statSync(p);
+      const stat2 = fs7.statSync(p);
       if (stat2.isDirectory()) {
-        fs6.rmSync(p, { recursive: true, force: true });
+        fs7.rmSync(p, { recursive: true, force: true });
       } else {
-        fs6.unlinkSync(p);
+        fs7.unlinkSync(p);
       }
     } catch {
     }
@@ -2381,7 +2696,7 @@ function cleanupTemp(...paths) {
 }
 function registerImportRoutes2(server2, dbManager2, options = {}) {
   const sourceManager = options.sourceManager ?? new ArchiveImportSourceManager({
-    tempRoot: fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-import-sources-"))
+    tempRoot: fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-import-sources-"))
   });
   const runPreparedImport = options.runPreparedImport ?? (async (manifestPath, onProgress) => {
     const result = await streamImport(dbManager2, manifestPath, {
@@ -2405,9 +2720,9 @@ 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 = path7.join(os2.tmpdir(), `chatlab-archive-${randomUUID()}.zip`);
+    const uploadPath = path8.join(os2.tmpdir(), `chatlab-archive-${randomUUID()}.zip`);
     try {
-      await pipeline(data.file, fs6.createWriteStream(uploadPath, { flags: "wx" }));
+      await pipeline(data.file, fs7.createWriteStream(uploadPath, { flags: "wx" }));
       if (data.file.truncated) {
         cleanupTemp(uploadPath);
         return reply.code(413).send({ success: false, error: "error.archive_limit_exceeded" });
@@ -2472,14 +2787,14 @@ 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 = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-detect-"));
-    const tmpPath = path7.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-detect-"));
+    const tmpPath = path8.join(tmpDir, data.filename || "upload");
     try {
       const chunks = [];
       for await (const chunk of data.file) {
         chunks.push(chunk);
       }
-      fs6.writeFileSync(tmpPath, Buffer.concat(chunks));
+      fs7.writeFileSync(tmpPath, Buffer.concat(chunks));
       const format = detectFormat(tmpPath);
       const allFormats = detectAllFormats(tmpPath);
       return { format, allFormats };
@@ -2490,14 +2805,14 @@ 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 = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-scan-"));
-    const tmpPath = path7.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-scan-"));
+    const tmpPath = path8.join(tmpDir, data.filename || "upload");
     try {
       const chunks = [];
       for await (const chunk of data.file) {
         chunks.push(chunk);
       }
-      fs6.writeFileSync(tmpPath, Buffer.concat(chunks));
+      fs7.writeFileSync(tmpPath, Buffer.concat(chunks));
       const chats = await scanMultiChatFile(tmpPath);
       return { chats };
     } finally {
@@ -2507,13 +2822,13 @@ 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 = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-import-"));
-    const tmpPath = path7.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-import-"));
+    const tmpPath = path8.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
     }
-    fs6.writeFileSync(tmpPath, Buffer.concat(chunks));
+    fs7.writeFileSync(tmpPath, Buffer.concat(chunks));
     const formatId = data.fields?.formatId?.value;
     const chatIndexStr = data.fields?.chatIndex?.value;
     const chatIndex = chatIndexStr !== void 0 ? parseInt(chatIndexStr, 10) : void 0;
@@ -2556,7 +2871,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 = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-dir-import-"));
+    const tmpDir = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-dir-import-"));
     const relativePaths = [];
     const fileBuffers = [];
     try {
@@ -2584,10 +2899,10 @@ data: ${JSON.stringify(eventData)}
         if (segments.length > 1) {
           relPath = segments.slice(1).join("/");
         }
-        const targetPath = path7.resolve(tmpDir, relPath);
-        if (!targetPath.startsWith(tmpDir + path7.sep)) continue;
-        fs6.mkdirSync(path7.dirname(targetPath), { recursive: true });
-        fs6.writeFileSync(targetPath, fileBuffers[i].data);
+        const targetPath = path8.resolve(tmpDir, relPath);
+        if (!targetPath.startsWith(tmpDir + path8.sep)) continue;
+        fs7.mkdirSync(path8.dirname(targetPath), { recursive: true });
+        fs7.writeFileSync(targetPath, fileBuffers[i].data);
       }
       const entryPath = findEntryFileInDirectory(tmpDir);
       if (!entryPath) {
@@ -2632,13 +2947,13 @@ data: ${JSON.stringify({ success: false, error: err instanceof Error ? err.messa
     const sessionId = request.params.id;
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-inc-"));
-    const tmpPath = path7.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-inc-"));
+    const tmpPath = path8.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
     }
-    fs6.writeFileSync(tmpPath, Buffer.concat(chunks));
+    fs7.writeFileSync(tmpPath, Buffer.concat(chunks));
     reply.raw.writeHead(200, {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
@@ -2670,13 +2985,13 @@ data: ${JSON.stringify(eventData)}
     const sessionId = request.params.id;
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-analyze-"));
-    const tmpPath = path7.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-analyze-"));
+    const tmpPath = path8.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
     }
-    fs6.writeFileSync(tmpPath, Buffer.concat(chunks));
+    fs7.writeFileSync(tmpPath, Buffer.concat(chunks));
     try {
       return await analyzeIncrementalImport(dbManager2, sessionId, tmpPath);
     } catch (err) {
@@ -2688,13 +3003,13 @@ data: ${JSON.stringify(eventData)}
   server2.post("/_web/import/analyze", async (request, reply) => {
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-analyze-"));
-    const tmpPath = path7.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-analyze-"));
+    const tmpPath = path8.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
     }
-    fs6.writeFileSync(tmpPath, Buffer.concat(chunks));
+    fs7.writeFileSync(tmpPath, Buffer.concat(chunks));
     try {
       return await analyzeNewImport(tmpPath);
     } catch (err) {
@@ -2724,17 +3039,17 @@ data: ${JSON.stringify(eventData)}
 
 `);
     }
-    const tmpDir = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-demo-"));
+    const tmpDir = fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-demo-"));
     try {
       const localPaths = [];
       for (let i = 0; i < total; i++) {
         sendEvent("progress", { stage: "downloading", current: i + 1, total });
-        const localPath = path7.join(tmpDir, DEMO_FILES[i]);
+        const localPath = path8.join(tmpDir, DEMO_FILES[i]);
         const resp = await fetch(`${DEMO_BASE_URL}/${locale}/${DEMO_FILES[i]}`, {
           signal: AbortSignal.timeout(6e4)
         });
         if (!resp.ok) throw new Error(`Download demo failed (${DEMO_FILES[i]}): ${resp.status}`);
-        fs6.writeFileSync(localPath, Buffer.from(await resp.arrayBuffer()));
+        fs7.writeFileSync(localPath, Buffer.from(await resp.arrayBuffer()));
         localPaths.push(localPath);
       }
       sendEvent("progress", { stage: "importing", current: 1, total });
@@ -2765,7 +3080,7 @@ data: ${JSON.stringify(eventData)}
 }
 
 // src/http/routes/web/cache.ts
-import * as path8 from "path";
+import * as path9 from "path";
 import { execFile } from "child_process";
 function runExecFile(file, args, runner = execFile) {
   return new Promise((resolve4, reject) => {
@@ -2793,7 +3108,7 @@ async function showPathInFolder(filePath, platform = process.platform, runner) {
   } else if (platform === "win32") {
     await runExecFile("explorer.exe", [`/select,${filePath}`], runner);
   } else {
-    await runExecFile("xdg-open", [path8.dirname(filePath)], runner);
+    await runExecFile("xdg-open", [path9.dirname(filePath)], runner);
   }
 }
 
@@ -2816,27 +3131,27 @@ function registerWebRoutes(server2, dbManager2, options) {
   const mergeCache = options?.pathProvider ? new MergeSessionCache(options.pathProvider, { nativeBinding: options.nativeBinding }) : null;
   mergeCache?.cleanupOrphans();
   const fallbackPathProvider = {
-    getSystemDir: () => path9.join(os3.homedir(), ".chatlab"),
-    getUserDataDir: () => path9.join(os3.homedir(), ".chatlab", "data"),
-    getDatabaseDir: () => path9.join(os3.homedir(), ".chatlab", "data", "databases"),
-    getVectorDir: () => path9.join(os3.homedir(), ".chatlab", "data", "vector"),
-    getAiDataDir: () => path9.join(os3.homedir(), ".chatlab", "ai"),
-    getSettingsDir: () => path9.join(os3.homedir(), ".chatlab", "settings"),
-    getCacheDir: () => path9.join(os3.homedir(), ".chatlab", "cache"),
-    getTempDir: () => path9.join(os3.homedir(), ".chatlab", "temp"),
-    getLogsDir: () => path9.join(os3.homedir(), ".chatlab", "logs"),
-    getDownloadsDir: () => path9.join(os3.homedir(), "Downloads")
+    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")
   };
   const resolvedPathProvider = options?.pathProvider ?? fallbackPathProvider;
   const ai = options?.aiContext;
   const cliStreamImport = async (dm, filePath) => {
-    const { streamImport: streamImport2 } = await import("./stream-import-YZMZ56B5.mjs");
+    const { streamImport: streamImport2 } = await import("./stream-import-3JMXQD7P.mjs");
     const result = await streamImport2(dm, filePath);
     if (!result.sessionId) throw new Error("Import succeeded but no sessionId returned");
     return { sessionId: result.sessionId };
   };
   const defaultUserDataDir = getDefaultNodeUserDataDir();
-  const isCustom = path9.resolve(resolvedPathProvider.getUserDataDir()) !== path9.resolve(defaultUserDataDir);
+  const isCustom = path10.resolve(resolvedPathProvider.getUserDataDir()) !== path10.resolve(defaultUserDataDir);
   const semanticIndexService = options?.semanticIndexService;
   const analyticsService = "A-US-0629338532" ? new AnalyticsService(resolvedPathProvider.getSystemDir(), "A-US-0629338532", getVersion()) : void 0;
   registerSharedRoutes(
@@ -2845,10 +3160,12 @@ function registerWebRoutes(server2, dbManager2, options) {
       dbManager: dbManager2,
       sessionAdapter: adapter,
       pathProvider: resolvedPathProvider,
+      runtimeIdentity: options?.runtimeIdentity,
       getVersion,
       nativeBinding: options?.nativeBinding,
       semanticIndexService,
       analyticsService,
+      getCurrentAiLogPath: () => getServerAiLogger()?.getExistingLogPath() ?? null,
       openDirectory: openDirectoryPath,
       showInFolder: showPathInFolder,
       downloadsDir: resolvedPathProvider.getDownloadsDir(),
@@ -2931,31 +3248,31 @@ function registerProxyRoutes(server2) {
 }
 
 // src/ai/manager-factory.ts
-import * as fs7 from "fs";
-import * as path10 from "path";
+import * as fs8 from "fs";
+import * as path11 from "path";
 import { createHash, randomUUID as randomUUID2 } from "crypto";
 var nodeFs = {
   ensureDir(dir) {
-    if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
+    if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
   },
   listFiles(dir, ext) {
-    if (!fs7.existsSync(dir)) return [];
-    return fs7.readdirSync(dir).filter((f) => f.endsWith(ext));
+    if (!fs8.existsSync(dir)) return [];
+    return fs8.readdirSync(dir).filter((f) => f.endsWith(ext));
   },
   readFile(filePath) {
-    return fs7.readFileSync(filePath, "utf-8");
+    return fs8.readFileSync(filePath, "utf-8");
   },
   writeFile(filePath, content) {
-    fs7.writeFileSync(filePath, content, "utf-8");
+    fs8.writeFileSync(filePath, content, "utf-8");
   },
   deleteFile(filePath) {
-    if (fs7.existsSync(filePath)) fs7.unlinkSync(filePath);
+    if (fs8.existsSync(filePath)) fs8.unlinkSync(filePath);
   },
   fileExists(filePath) {
-    return fs7.existsSync(filePath);
+    return fs8.existsSync(filePath);
   },
   joinPath(...parts) {
-    return path10.join(...parts);
+    return path11.join(...parts);
   }
 };
 var managerCache = /* @__PURE__ */ new Map();
@@ -2965,13 +3282,13 @@ function getAssistantManager(aiDataDir) {
     cached = {
       assistant: new AssistantManager({
         fs: nodeFs,
-        assistantsDir: path10.join(aiDataDir, "assistants"),
+        assistantsDir: path11.join(aiDataDir, "assistants"),
         builtinRawConfigs: [],
         generateId: () => `custom_${randomUUID2().replace(/-/g, "").slice(0, 12)}`
       }),
       skill: new SkillManagerCore({
         fs: nodeFs,
-        skillsDir: path10.join(aiDataDir, "skills"),
+        skillsDir: path11.join(aiDataDir, "skills"),
         builtinRawSkills: [],
         contentHash: (content) => createHash("md5").update(content).digest("hex")
       })
@@ -2995,14 +3312,14 @@ var noop = () => {
 var NOOP_LOGGER = { info: noop, warn: noop, error: noop };
 
 // ../../packages/sync/src/data-source-manager.ts
-import * as fs8 from "fs";
-import * as path11 from "path";
+import * as fs9 from "fs";
+import * as path12 from "path";
 import * as crypto from "crypto";
 var CONFIG_FILE = "data-sources.json";
 function generateId(prefix = "ds") {
   return `${prefix}_${crypto.randomBytes(6).toString("hex")}`;
 }
-function normalizeBaseUrl(input) {
+function normalizeBaseUrl2(input) {
   let url = input.trim().replace(/\/+$/, "");
   if (url && !/^https?:\/\//i.test(url)) {
     url = `http://${url}`;
@@ -3024,17 +3341,17 @@ var DataSourceManager = class {
     this.logger = logger ?? NOOP_LOGGER;
   }
   getConfigPath() {
-    return path11.join(this.configDir, CONFIG_FILE);
+    return path12.join(this.configDir, CONFIG_FILE);
   }
   ensureDir() {
-    fs8.mkdirSync(this.configDir, { recursive: true });
+    fs9.mkdirSync(this.configDir, { recursive: true });
   }
   // ==================== Load / Save ====================
   loadAll() {
     try {
       const filePath = this.getConfigPath();
-      if (fs8.existsSync(filePath)) {
-        const raw = fs8.readFileSync(filePath, "utf-8");
+      if (fs9.existsSync(filePath)) {
+        const raw = fs9.readFileSync(filePath, "utf-8");
         const parsed = JSON.parse(raw);
         if (!isValidDataSourceArray(parsed)) {
           this.logger.warn("[DataSource] Incompatible config format detected, returning empty.");
@@ -3053,7 +3370,7 @@ var DataSourceManager = class {
   saveAll(sources) {
     try {
       this.ensureDir();
-      fs8.writeFileSync(this.getConfigPath(), JSON.stringify(sources, null, 2), "utf-8");
+      fs9.writeFileSync(this.getConfigPath(), JSON.stringify(sources, null, 2), "utf-8");
     } catch (err) {
       this.logger.error("[DataSource] Failed to save config", err);
     }
@@ -3067,7 +3384,7 @@ var DataSourceManager = class {
     const ds = {
       id: generateId("src"),
       name: partial.name || "",
-      baseUrl: normalizeBaseUrl(partial.baseUrl),
+      baseUrl: normalizeBaseUrl2(partial.baseUrl),
       token: partial.token,
       intervalMinutes: partial.intervalMinutes,
       pullLimit: partial.pullLimit || 1e3,
@@ -3085,7 +3402,7 @@ var DataSourceManager = class {
     if (idx === -1) return null;
     const ds = sources[idx];
     if (updates.name !== void 0) ds.name = updates.name;
-    if (updates.baseUrl !== void 0) ds.baseUrl = normalizeBaseUrl(updates.baseUrl);
+    if (updates.baseUrl !== void 0) ds.baseUrl = normalizeBaseUrl2(updates.baseUrl);
     if (updates.token !== void 0) ds.token = updates.token;
     if (updates.intervalMinutes !== void 0) ds.intervalMinutes = updates.intervalMinutes;
     if (updates.pullLimit !== void 0) ds.pullLimit = updates.pullLimit;
@@ -3146,42 +3463,13 @@ var DataSourceManager = class {
   }
 };
 
-// ../../packages/sync/src/discovery.ts
-function buildRemoteSessionsUrl(baseUrl, query = {}) {
-  const searchParams = new URLSearchParams();
-  searchParams.set("format", "chatlab");
-  if (query.keyword?.trim()) searchParams.set("keyword", query.keyword.trim());
-  if (query.limit && query.limit > 0) searchParams.set("limit", String(query.limit));
-  if (query.cursor) searchParams.set("cursor", query.cursor);
-  return `${baseUrl}/sessions?${searchParams.toString()}`;
-}
-function parseRemoteSessionsResponse(body) {
-  const parsed = JSON.parse(body);
-  let sessions;
-  let pageSource;
-  if (Array.isArray(parsed)) {
-    sessions = parsed;
-  } else if (parsed && typeof parsed === "object") {
-    sessions = parsed.sessions ?? parsed.data?.sessions ?? parsed.data ?? [];
-    if (!Array.isArray(sessions)) sessions = [];
-    pageSource = parsed.page ?? parsed.data?.page;
-  } else {
-    sessions = [];
-  }
-  return {
-    sessions,
-    page: pageSource && typeof pageSource === "object" ? {
-      hasMore: Boolean(pageSource.hasMore),
-      nextCursor: typeof pageSource.nextCursor === "string" ? pageSource.nextCursor : void 0
-    } : void 0
-  };
-}
-
 // ../../packages/sync/src/pull-engine.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as crypto2 from "crypto";
 var MAX_PAGES_PER_PULL = 5e3;
 var PULL_OVERLAP_SECONDS = 60;
+var SOURCE_UNAVAILABLE_LOG_COOLDOWN_MS = 5 * 60 * 1e3;
+var SOURCE_UNAVAILABLE_ERROR_CODES = /* @__PURE__ */ new Set(["ECONNREFUSED", "ENOTFOUND", "ECONNRESET", "ETIMEDOUT", "ABORT_ERR"]);
 function buildPullUrl(baseUrl, remoteSessionId, params) {
   const base = `${baseUrl}/sessions/${remoteSessionId}/messages`;
   const qs = ["format=chatlab"];
@@ -3198,7 +3486,7 @@ function parseSyncFromFile(filePath) {
   try {
     const isJsonl = filePath.endsWith(".jsonl");
     if (isJsonl) {
-      const content = fs9.readFileSync(filePath, "utf-8");
+      const content = fs10.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 {
@@ -3217,7 +3505,7 @@ function parseSyncFromFile(filePath) {
       }
       return null;
     }
-    const raw = fs9.readFileSync(filePath, "utf-8");
+    const raw = fs10.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.sync && typeof parsed.sync === "object") {
       const s = parsed.sync;
@@ -3231,7 +3519,7 @@ function parseSyncFromFile(filePath) {
 function fileContainsMessages(filePath) {
   try {
     if (filePath.endsWith(".jsonl")) {
-      const content = fs9.readFileSync(filePath, "utf-8");
+      const content = fs10.readFileSync(filePath, "utf-8");
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed) continue;
@@ -3244,7 +3532,7 @@ function fileContainsMessages(filePath) {
       }
       return false;
     }
-    const raw = fs9.readFileSync(filePath, "utf-8");
+    const raw = fs10.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed.messages) && parsed.messages.length > 0;
   } catch {
@@ -3261,7 +3549,7 @@ function getMaxMessageTimestampFromFile(filePath) {
       }
     };
     if (filePath.endsWith(".jsonl")) {
-      const content = fs9.readFileSync(filePath, "utf-8");
+      const content = fs10.readFileSync(filePath, "utf-8");
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed) continue;
@@ -3274,7 +3562,7 @@ function getMaxMessageTimestampFromFile(filePath) {
       }
       return maxTs;
     }
-    const raw = fs9.readFileSync(filePath, "utf-8");
+    const raw = fs10.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (Array.isArray(parsed.messages)) {
       for (const message of parsed.messages) {
@@ -3288,10 +3576,35 @@ function getMaxMessageTimestampFromFile(filePath) {
 }
 function cleanupTempFile(filePath) {
   try {
-    if (fs9.existsSync(filePath)) fs9.unlinkSync(filePath);
+    if (fs10.existsSync(filePath)) fs10.unlinkSync(filePath);
   } catch {
   }
 }
+function getErrorProp(error, prop) {
+  return error && typeof error === "object" ? error[prop] : void 0;
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error || "Pull failed");
+}
+function describeSourceUnavailableError(error) {
+  let current = error;
+  while (current && typeof current === "object") {
+    const code = getErrorProp(current, "code");
+    const name = getErrorProp(current, "name");
+    if (typeof code === "string" && SOURCE_UNAVAILABLE_ERROR_CODES.has(code)) {
+      const address = getErrorProp(current, "address");
+      const port = getErrorProp(current, "port");
+      if (typeof address === "string" && (typeof port === "number" || typeof port === "string")) {
+        return `${code} ${address}:${port}`;
+      }
+      const host = getErrorProp(current, "hostname") ?? getErrorProp(current, "host");
+      return typeof host === "string" ? `${code} ${host}` : code;
+    }
+    if (name === "AbortError") return "Request timeout";
+    current = getErrorProp(current, "cause");
+  }
+  return null;
+}
 var PullEngine = class {
   fetcher;
   importer;
@@ -3302,6 +3615,7 @@ var PullEngine = class {
   onSessionImported;
   pullingSourceIds = /* @__PURE__ */ new Set();
   progressMap = /* @__PURE__ */ new Map();
+  sourceUnavailableLogs = /* @__PURE__ */ new Map();
   constructor(options) {
     this.fetcher = options.fetcher;
     this.importer = options.importer;
@@ -3337,7 +3651,6 @@ var PullEngine = class {
       this.logger.info(`[Pull] Skipping "${sess.name}": import in progress`);
       return { success: false, newMessageCount: 0, error: "Import in progress" };
     }
-    this.logger.info(`[Pull] Pulling "${sess.name}" from ${ds.baseUrl}`);
     let totalNewMessages = 0;
     let since = sess.lastPullAt;
     let offset;
@@ -3354,7 +3667,7 @@ var PullEngine = class {
           limit: ds.pullLimit
         });
         try {
-          const stat2 = fs9.statSync(tempFile);
+          const stat2 = fs10.statSync(tempFile);
           this.logger.info(`[Pull] "${sess.name}" page ${pageCount}: fetched ${stat2.size} bytes`);
           const sync0 = parseSyncFromFile(tempFile);
           if (stat2.size < 1024) {
@@ -3374,7 +3687,7 @@ var PullEngine = class {
                   offset,
                   limit: ds.pullLimit
                 });
-                const retryStat = fs9.statSync(retryFile);
+                const retryStat = fs10.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) {
@@ -3545,8 +3858,11 @@ var PullEngine = class {
       }
       return { success: true, newMessageCount: totalNewMessages };
     } catch (error) {
-      const errMsg = error.message || "Pull failed";
-      this.logger.error(`[Pull] Pull failed for "${sess.name}"`, error);
+      const sourceUnavailable = describeSourceUnavailableError(error);
+      const errMsg = sourceUnavailable ?? getErrorMessage(error);
+      if (!sourceUnavailable) {
+        this.logger.error(`[Pull] Pull failed for "${sess.name}": ${errMsg}`);
+      }
       this.dsManager.updateSession(sourceId, sess.id, {
         lastPullAt: Math.floor(Date.now() / 1e3),
         lastStatus: "error",
@@ -3554,7 +3870,7 @@ var PullEngine = class {
       });
       this.notifier.onPullResult(sourceId, sess.id, "error", errMsg);
       this.markProgressDone(sess.id);
-      return { success: false, newMessageCount: 0, error: errMsg };
+      return { success: false, newMessageCount: 0, error: errMsg, sourceUnavailable: !!sourceUnavailable };
     }
   }
   markProgressDone(sessionId) {
@@ -3571,13 +3887,43 @@ var PullEngine = class {
     }
     this.pullingSourceIds.add(ds.id);
     try {
-      for (const sess of ds.sessions) {
-        await this.executePullSession(ds.id, ds, sess);
+      let sourceUnavailable = false;
+      for (let index = 0; index < ds.sessions.length; index++) {
+        const sess = ds.sessions[index];
+        const result = await this.executePullSession(ds.id, ds, sess);
+        if (result.sourceUnavailable && result.error) {
+          sourceUnavailable = true;
+          this.markRemainingSessionsSourceUnavailable(ds, index + 1, result.error);
+          this.logSourceUnavailable(ds, result.error, ds.sessions.length - index);
+          break;
+        }
       }
+      if (!sourceUnavailable) this.sourceUnavailableLogs.delete(ds.id);
     } finally {
       this.pullingSourceIds.delete(ds.id);
     }
   }
+  markRemainingSessionsSourceUnavailable(ds, startIndex, detail) {
+    const now = Math.floor(Date.now() / 1e3);
+    for (const sess of ds.sessions.slice(startIndex)) {
+      this.dsManager.updateSession(ds.id, sess.id, {
+        lastPullAt: now,
+        lastStatus: "error",
+        lastError: detail
+      });
+      this.notifier.onPullResult(ds.id, sess.id, "error", detail);
+      this.markProgressDone(sess.id);
+    }
+  }
+  logSourceUnavailable(ds, detail, affectedSessions) {
+    const now = Date.now();
+    const previous = this.sourceUnavailableLogs.get(ds.id);
+    if (previous && previous.detail === detail && now - previous.lastLoggedAt < SOURCE_UNAVAILABLE_LOG_COOLDOWN_MS) {
+      return;
+    }
+    this.sourceUnavailableLogs.set(ds.id, { detail, lastLoggedAt: now });
+    this.logger.warn(`[Pull] Source ${ds.baseUrl} unavailable: ${detail}, skipped ${affectedSessions} sessions`);
+  }
   async triggerPull(sourceId, sessionId) {
     const ds = this.dsManager.get(sourceId);
     if (!ds) return { success: false, error: "Data source not found" };
@@ -3585,6 +3931,8 @@ var PullEngine = class {
       const sess = ds.sessions.find((s) => s.id === sessionId);
       if (!sess) return { success: false, error: "Session not found" };
       const result = await this.executePullSession(sourceId, ds, sess);
+      if (result.sourceUnavailable && result.error) this.logSourceUnavailable(ds, result.error, 1);
+      if (result.success) this.sourceUnavailableLogs.delete(ds.id);
       return { success: result.success, error: result.error };
     }
     if (this.pullingSourceIds.has(sourceId)) {
@@ -3594,10 +3942,19 @@ var PullEngine = class {
     this.pullingSourceIds.add(sourceId);
     try {
       const errors = [];
-      for (const sess of ds.sessions) {
+      let sourceUnavailable = false;
+      for (let index = 0; index < ds.sessions.length; index++) {
+        const sess = ds.sessions[index];
         const result = await this.executePullSession(sourceId, ds, sess);
         if (!result.success && result.error) errors.push(`${sess.name}: ${result.error}`);
+        if (result.sourceUnavailable && result.error) {
+          sourceUnavailable = true;
+          this.markRemainingSessionsSourceUnavailable(ds, index + 1, result.error);
+          this.logSourceUnavailable(ds, result.error, ds.sessions.length - index);
+          break;
+        }
       }
+      if (!sourceUnavailable) this.sourceUnavailableLogs.delete(ds.id);
       if (errors.length > 0) {
         return { success: false, error: errors.join("; ") };
       }
@@ -3678,13 +4035,13 @@ function reloadTimer(dsId, skipInitialPull = false) {
 }
 
 // src/sync/adapters.ts
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import * as os4 from "os";
-import * as path12 from "path";
+import * as path13 from "path";
 import * as crypto3 from "crypto";
 function getTempFilePath(ext) {
   const id = crypto3.randomBytes(8).toString("hex");
-  return path12.join(os4.tmpdir(), `chatlab-pull-${id}${ext}`);
+  return path13.join(os4.tmpdir(), `chatlab-pull-${id}${ext}`);
 }
 var NodeFetcher = class {
   async fetchToTempFile(baseUrl, remoteSessionId, token, params) {
@@ -3701,7 +4058,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());
-    fs10.writeFileSync(tempFile, buffer);
+    fs11.writeFileSync(tempFile, buffer);
     return tempFile;
   }
 };
@@ -3714,7 +4071,7 @@ var DirectImporter = class {
   }
   sessionExists(sessionId) {
     const dbPath = this.dbManager.getDbPath(sessionId);
-    if (!fs10.existsSync(dbPath)) return false;
+    if (!fs11.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();
@@ -3722,7 +4079,7 @@ var DirectImporter = class {
       if (row.cnt === 0) {
         this.logger.warn(`[DirectImporter] DB file exists but has no message table: ${sessionId}, removing`);
         try {
-          fs10.unlinkSync(dbPath);
+          fs11.unlinkSync(dbPath);
         } catch {
         }
         return false;
@@ -3732,7 +4089,7 @@ var DirectImporter = class {
       if (error instanceof DataDirCompatibilityError) throw error;
       this.logger.warn(`[DirectImporter] Cannot validate DB file: ${sessionId}, removing`);
       try {
-        fs10.unlinkSync(dbPath);
+        fs11.unlinkSync(dbPath);
       } catch {
       }
       return false;
@@ -3791,92 +4148,6 @@ var NoopNotifier = class {
   onPullResult = noop2;
 };
 
-// src/sync/routes.ts
-function registerAutomationRoutes(server2, ctx) {
-  const { dsManager: dsManager2, pullEngine: pullEngine2, dbManager: dbManager2, serverInfo } = ctx;
-  server2.get("/_web/automation/config", async () => {
-    return {
-      enabled: true,
-      port: serverInfo.port,
-      token: serverInfo.token,
-      host: serverInfo.host
-    };
-  });
-  server2.get("/_web/automation/data-sources", async () => {
-    return dsManager2.loadAll();
-  });
-  server2.post("/_web/automation/data-sources", async (request) => {
-    const ds = dsManager2.add(request.body);
-    reloadTimer(ds.id);
-    return ds;
-  });
-  server2.patch("/_web/automation/data-sources/:id", async (request, reply) => {
-    const ds = dsManager2.update(request.params.id, request.body);
-    if (!ds) return reply.code(404).send({ error: "Data source not found" });
-    reloadTimer(ds.id);
-    return ds;
-  });
-  server2.delete("/_web/automation/data-sources/:id", async (request, reply) => {
-    stopTimer(request.params.id);
-    const ok = dsManager2.delete(request.params.id);
-    if (!ok) return reply.code(404).send({ error: "Data source not found" });
-    return { success: true };
-  });
-  server2.post("/_web/automation/data-sources/:id/sessions", async (request, reply) => {
-    const added = dsManager2.addSessions(request.params.id, request.body.sessions);
-    if (added.length === 0 && !dsManager2.get(request.params.id)) {
-      return reply.code(404).send({ error: "Data source not found" });
-    }
-    reloadTimer(request.params.id, true);
-    for (const sess of added) {
-      pullEngine2.triggerPull(request.params.id, sess.id).catch(() => {
-      });
-    }
-    return added;
-  });
-  server2.delete("/_web/automation/data-sources/:id/sessions/:sessId", async (request, reply) => {
-    const removed = dsManager2.removeSession(request.params.id, request.params.sessId);
-    if (!removed) return reply.code(404).send({ error: "Session not found" });
-    reloadTimer(request.params.id);
-    if (request.query.deleteData === "true" && removed.targetSessionId) {
-      dbManager2.deleteSessionDatabaseFiles(removed.targetSessionId);
-    }
-    return { success: true };
-  });
-  server2.post(
-    "/_web/automation/data-sources/:id/pull",
-    async (request) => {
-      return pullEngine2.triggerPull(request.params.id, request.body?.sessionId);
-    }
-  );
-  server2.post("/_web/automation/data-sources/:id/pull-all", async (request) => {
-    return pullEngine2.triggerPullAll(request.params.id);
-  });
-  server2.get("/_web/automation/sync-progress", async () => {
-    return pullEngine2.getProgress();
-  });
-  server2.get("/_web/automation/remote-sessions", async (request, reply) => {
-    const { baseUrl, token, keyword, limit, cursor } = request.query;
-    if (!baseUrl) return reply.code(400).send({ error: "baseUrl is required" });
-    const normalizedUrl = normalizeBaseUrl(baseUrl);
-    const url = buildRemoteSessionsUrl(normalizedUrl, {
-      keyword,
-      limit: limit ? parseInt(limit, 10) : void 0,
-      cursor
-    });
-    const headers = { Accept: "application/json" };
-    if (token) headers["Authorization"] = `Bearer ${token}`;
-    try {
-      const resp = await fetch(url, { headers, signal: AbortSignal.timeout(3e4) });
-      if (!resp.ok) throw new Error(`Remote server returned HTTP ${resp.status}`);
-      const body = await resp.text();
-      return parseRemoteSessionsResponse(body);
-    } catch (err) {
-      return reply.code(502).send({ error: err.message || "Failed to fetch remote sessions" });
-    }
-  });
-}
-
 // src/sync/index.ts
 var syncLogger = {
   info: (msg) => console.log(`[Sync] ${msg}`),
@@ -3907,7 +4178,16 @@ function initSync(server2, dbManager2, pathProvider, serverInfo) {
       }
     }
   });
-  registerAutomationRoutes(server2, { dsManager, pullEngine, dbManager: dbManager2, serverInfo });
+  registerAutomationRoutes(server2, {
+    automation: {
+      dsManager,
+      pullEngine,
+      serverInfo,
+      deleteSessionData: (sessionId) => dbManager2.deleteSessionDatabaseFiles(sessionId),
+      reloadTimer,
+      stopTimer
+    }
+  });
   initScheduler({
     dsManager,
     pullEngine,
@@ -3928,21 +4208,21 @@ function createFileConfigStorage(aiDataDir) {
   return {
     readJson(key) {
       try {
-        return JSON.parse(fs11.readFileSync(`${aiDataDir}/${key}.json`, "utf-8"));
+        return JSON.parse(fs12.readFileSync(`${aiDataDir}/${key}.json`, "utf-8"));
       } catch {
         return null;
       }
     },
     writeJson(key, data) {
-      if (!fs11.existsSync(aiDataDir)) fs11.mkdirSync(aiDataDir, { recursive: true });
-      fs11.writeFileSync(`${aiDataDir}/${key}.json`, JSON.stringify(data, null, 2), "utf-8");
+      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 (fs11.existsSync(nativePath)) return nativePath;
+  if (fs12.existsSync(nativePath)) return nativePath;
   return void 0;
 }
 function ensureToken(config) {
@@ -4035,6 +4315,7 @@ async function startHttpServer(options) {
   registerWebRoutes(server, dbManager, {
     pathProvider,
     nativeBinding,
+    runtimeIdentity: runtime,
     semanticIndexService,
     aiContext: {
       aiDataDir,
@@ -4048,7 +4329,7 @@ async function startHttpServer(options) {
     }
   });
   initSync(server, dbManager, pathProvider, { port, host, token });
-  if (options?.webRoot && fs11.existsSync(options.webRoot)) {
+  if (options?.webRoot && fs12.existsSync(options.webRoot)) {
     registerProxyRoutes(server);
     const fastifyStatic = await import("@fastify/static");
     await server.register(fastifyStatic.default, {
@@ -4089,4 +4370,4 @@ export {
   startHttpServer,
   stopHttpServer
 };
-//# sourceMappingURL=chunk-AB6TAXTQ.mjs.map
+//# sourceMappingURL=chunk-4IZ3WKYU.mjs.map