chatlab-cli 0.34.0 → 0.34.2-beta.1

package/dist/{chat-command-XPY3WURC.mjs → chat-command-6IOH2QRF.mjs}

@@ -6,17 +6,17 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import {
   createCliRunAgentStream
-} from "./chunk-JCSPDTZL.mjs";
-import "./chunk-DGF3S3TZ.mjs";
-import "./chunk-S5NCEESV.mjs";
-import "./chunk-AQPDZAWB.mjs";
-import "./chunk-IGEHMLHM.mjs";
-import "./chunk-JTOHAMIW.mjs";
+} from "./chunk-H6D4DZOC.mjs";
+import "./chunk-72RWABYJ.mjs";
+import "./chunk-2XCNTG4O.mjs";
+import "./chunk-4LW6443F.mjs";
+import "./chunk-52P5ZRBD.mjs";
+import "./chunk-652KEAX3.mjs";
 import "./chunk-QZCNVAH6.mjs";
 import {
   getDefaultGeneralAssistantId
-} from "./chunk-OLE2USEN.mjs";
-import "./chunk-GFHSSCCR.mjs";
+} from "./chunk-INBJ7SND.mjs";
+import "./chunk-VSOWNKPA.mjs";
 
 // src/ai/chat-command.ts
 import { createInterface } from "readline/promises";
@@ -312,4 +312,4 @@ export {
   runChatCommand,
   runChatTurn
 };
-//# sourceMappingURL=chat-command-XPY3WURC.mjs.map
+//# sourceMappingURL=chat-command-6IOH2QRF.mjs.map

package/dist/{chunk-S5NCEESV.mjs → chunk-2XCNTG4O.mjs}

@@ -14,6 +14,8 @@ import {
   DESENSITIZE_RULES_SCHEMA_VERSION,
   EMBEDDING_INDEX_SCHEMA,
   EmbeddingIndexStore,
+  LOCAL_EMBEDDING_RUNTIME_PACKAGE,
+  LOCAL_EMBEDDING_RUNTIME_VERSION,
   LocalEmbeddingProvider,
   OpenAICompatibleEmbeddingProvider,
   QWEN3_PROFILE,
@@ -41,7 +43,9 @@ import {
   createChatDbFtsSearcher,
   createChatDbMessageRangeReader,
   createChatDbMessageSource,
+  createChatLabTempDir,
   createEmbedder,
+  createLocalEmbeddingRuntimeManager,
   createSemanticIndexService,
   defaultSemanticIndexConfig,
   deriveParentId,
@@ -57,13 +61,15 @@ import {
   isSemanticVoid,
   parseParentBounds,
   persistSemanticIndexConfig,
+  rebaseChatLabDemoDocuments,
   reciprocalRankFusion,
+  removeChatLabTempDir,
   resolveModelId,
   resolveSemanticIndexApiKeySet,
   runWarmup,
   vecTableName,
   vecTableSchema
-} from "./chunk-AQPDZAWB.mjs";
+} from "./chunk-4LW6443F.mjs";
 import {
   CHATLAB_FORMAT_VERSION,
   MEANINGFUL_POS_TAGS,
@@ -78,13 +84,16 @@ import {
   mergeMembers2 as mergeMembers,
   migrateFromElectronIfNeeded,
   normalizePlatformId,
+  readJsonFile,
   resolveApiKey,
   snapshotPathProvider,
-  writeConfigField
-} from "./chunk-OLE2USEN.mjs";
+  withFileLock,
+  writeConfigField,
+  writeJsonFileAtomically
+} from "./chunk-INBJ7SND.mjs";
 import {
   __export
-} from "./chunk-GFHSSCCR.mjs";
+} from "./chunk-VSOWNKPA.mjs";
 
 // ../../packages/node-runtime/src/node-path-provider.ts
 import * as fs2 from "fs";
@@ -337,7 +346,7 @@ function deletePendingDataDirCleanup(systemDir, currentDir, cleanupId, deps = {}
   if (!cleanup) return { success: false, error: "Pending data directory cleanup not found" };
   const sourceDir = cleanup.sourceDir;
   const overlapsCurrentDir = normalizePathForCompare(sourceDir) === normalizePathForCompare(currentDir) || isSubPath(sourceDir, currentDir) || isSubPath(currentDir, sourceDir);
-  const overlapsSystemDir = normalizePathForCompare(sourceDir) === normalizePathForCompare(systemDir) || isSubPath(sourceDir, systemDir);
+  const overlapsSystemDir = normalizePathForCompare(sourceDir) === normalizePathForCompare(systemDir) || isSubPath(sourceDir, systemDir) || isSubPath(systemDir, sourceDir);
   if (overlapsCurrentDir || overlapsSystemDir) {
     appLogger.warn("data-dir", "Old data directory cleanup rejected because the path is still in use", { cleanupId });
     return { success: false, error: "Old data directory overlaps a directory still in use" };
@@ -873,100 +882,365 @@ function* serializeChatLabToJsonl(data) {
 }
 
 // ../../packages/node-runtime/src/services/analytics.ts
-import * as fs4 from "fs";
 import * as path4 from "path";
-var REGIONS = {
-  US: "https://us.aptabase.com",
-  EU: "https://eu.aptabase.com"
+import { randomUUID as randomUUID2 } from "crypto";
+var DEFAULT_DATA = {
+  lastReportDate: null,
+  firstReportDate: null,
+  anonymousId: null,
+  enabled: true
 };
-var DEFAULT_DATA = { lastReportDate: null, firstReportDate: null, enabled: true };
+var EVENT_NAMES = /* @__PURE__ */ new Set([
+  "app_started",
+  "app_active_new",
+  "app_active",
+  "chat_import_started",
+  "chat_import_completed",
+  "chat_import_failed",
+  "incremental_import_used",
+  "feature_used",
+  "ai_setup_completed",
+  "ai_request_started",
+  "ai_request_completed"
+]);
+var FEATURE_IDS = /* @__PURE__ */ new Set([
+  "insights",
+  "ranking",
+  "ai_chat",
+  "sql_lab",
+  "message_search",
+  "member_management",
+  "session_merge",
+  "export"
+]);
+var FAILURE_REASONS = /* @__PURE__ */ new Set([
+  "auth",
+  "network",
+  "rate_limit",
+  "model_not_found",
+  "aborted",
+  "parse",
+  "write",
+  "unknown"
+]);
+var APP_LOCALES = /* @__PURE__ */ new Set(["zh-CN", "zh-TW", "en-US", "ja-JP"]);
+function getUmamiConfigFromEnv() {
+  const endpoint = "https://t.feapp.cn/api/send"?.trim();
+  const websiteId = "3fbbc313-d122-4649-9c50-eef4bfad2650"?.trim();
+  return endpoint && websiteId ? { endpoint, websiteId } : void 0;
+}
+function normalizeOs() {
+  if (process.platform === "darwin") return "macos";
+  if (process.platform === "win32") return "windows";
+  if (process.platform === "linux") return "linux";
+  return "other";
+}
+function normalizeLocale(value) {
+  if (typeof value !== "string") return "unknown";
+  const trimmed = value.trim();
+  return APP_LOCALES.has(trimmed) ? trimmed : "unknown";
+}
+function normalizeAnalyticsImportPlatform(value) {
+  if (typeof value !== "string") return "unknown";
+  const platform = value.trim();
+  const hasPathOrControlCharacter = [...platform].some(
+    (char) => char === "/" || char === "\\" || char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127
+  );
+  return platform.length > 0 && platform.length <= 64 && !hasPathOrControlCharacter ? platform : "unknown";
+}
+function normalizeDuration(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return null;
+  return Math.min(Math.round(value), 24 * 60 * 60 * 1e3);
+}
+function normalizeEvent(eventName, props = {}) {
+  if (!EVENT_NAMES.has(eventName)) return null;
+  const name = eventName;
+  const properties = {};
+  if (name.startsWith("chat_import_")) {
+    properties.chat_platform = normalizeAnalyticsImportPlatform(props.chat_platform);
+  }
+  if (name === "chat_import_completed" || name === "ai_request_completed") {
+    const duration = normalizeDuration(props.duration_ms);
+    if (duration !== null) properties.duration_ms = duration;
+  }
+  if (name === "feature_used") {
+    if (typeof props.feature_id !== "string" || !FEATURE_IDS.has(props.feature_id)) return null;
+    properties.feature_id = props.feature_id;
+  }
+  if (name === "ai_request_completed") {
+    if (typeof props.success !== "boolean") return null;
+    properties.success = props.success;
+  }
+  if (name === "chat_import_failed" || name === "ai_request_completed" && props.success === false) {
+    const reason = typeof props.failure_reason === "string" ? props.failure_reason : "unknown";
+    properties.failure_reason = FAILURE_REASONS.has(reason) ? reason : "unknown";
+  }
+  return { name, properties };
+}
+function eventPath(event) {
+  if (event.name === "incremental_import_used") return "/import/incremental";
+  if (event.name.startsWith("chat_import_")) return "/import";
+  if (event.name.startsWith("ai_")) return "/ai";
+  if (event.name === "feature_used") return `/features/${event.properties.feature_id}`;
+  return "/app";
+}
 var AnalyticsService = class {
   dataPath;
-  endpoint;
-  appKey;
-  appVersion;
-  sessionId;
-  constructor(systemDir, appKey, appVersion) {
+  options;
+  sessionId = randomUUID2();
+  appLocale = "unknown";
+  startupAttempted = false;
+  // Product constraint: only one ChatLab runtime is expected to use a system directory at a time.
+  // Daily-active deduplication is intentionally process-local unless concurrent runtimes become supported.
+  dailyActivePromise = null;
+  constructor(systemDir, options) {
     this.dataPath = path4.join(systemDir, "analytics.json");
-    this.appKey = appKey;
-    this.appVersion = appVersion;
-    this.sessionId = `${Math.floor(Date.now() / 1e3)}${Math.floor(Math.random() * 1e8).toString().padStart(8, "0")}`;
-    const parts = appKey.split("-");
-    const base = parts.length === 3 ? REGIONS[parts[1]] : void 0;
-    this.endpoint = base ? `${base}/api/v0/event` : null;
+    this.options = {
+      ...options,
+      umami: options.umami ?? getUmamiConfigFromEnv()
+    };
   }
   load() {
     try {
-      if (fs4.existsSync(this.dataPath)) {
-        return { ...DEFAULT_DATA, ...JSON.parse(fs4.readFileSync(this.dataPath, "utf-8")) };
-      }
-    } catch (_e) {
+      const stored = readJsonFile(this.dataPath);
+      if (stored) return { ...DEFAULT_DATA, ...stored };
+    } catch (error) {
+      appLogger.error("analytics", "Failed to read analytics settings; using defaults", error);
     }
     return { ...DEFAULT_DATA };
   }
-  save(data) {
+  updateData(update, fallback) {
     try {
-      fs4.writeFileSync(this.dataPath, JSON.stringify(data, null, 2), "utf-8");
-    } catch (e) {
-      console.error("[Analytics] Failed to save:", e);
+      return withFileLock(this.dataPath, () => {
+        const data = this.load();
+        const result = update(data);
+        writeJsonFileAtomically(this.dataPath, data, 384);
+        return result;
+      });
+    } catch (error) {
+      appLogger.error("analytics", "Failed to update analytics settings", error);
+      return fallback;
     }
   }
-  getEnabled() {
-    return this.load().enabled;
+  getOrCreateAnonymousId() {
+    const fallback = randomUUID2();
+    return this.updateData((data) => {
+      data.anonymousId ??= randomUUID2();
+      return data.anonymousId;
+    }, fallback);
   }
-  setEnabled(enabled) {
-    const data = this.load();
-    data.enabled = enabled;
-    this.save(data);
+  isAiModelConfigured() {
+    try {
+      return this.options.getAiModelConfigured?.() === true;
+    } catch (error) {
+      appLogger.error("analytics", "Failed to resolve AI configuration state", error);
+      return false;
+    }
   }
-  async track(eventName, props) {
-    if (!this.endpoint) return false;
-    if (!this.getEnabled()) return false;
+  buildEnvelope(event) {
+    return {
+      ...event,
+      anonymousId: this.getOrCreateAnonymousId(),
+      sessionId: this.sessionId,
+      appVersion: this.options.appVersion,
+      appType: this.options.appType,
+      os: normalizeOs(),
+      appLocale: this.appLocale,
+      aiModelConfigured: this.isAiModelConfigured()
+    };
+  }
+  commonProperties(envelope) {
+    return {
+      session_id: envelope.sessionId,
+      app_version: envelope.appVersion,
+      app_type: envelope.appType,
+      os: envelope.os,
+      app_locale: envelope.appLocale,
+      ai_model_configured: envelope.aiModelConfigured,
+      schema_version: 1
+    };
+  }
+  async sendToUmami(envelope) {
+    const umami = this.options.umami;
+    if (!umami) return false;
     try {
-      const resp = await fetch(this.endpoint, {
+      const response = await fetch(umami.endpoint, {
         method: "POST",
-        headers: { "Content-Type": "application/json", "App-Key": this.appKey },
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": `ChatLab/${envelope.appVersion} (${envelope.os}; ${envelope.appType})`
+        },
         body: JSON.stringify({
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          sessionId: this.sessionId,
-          eventName,
-          systemProps: {
-            isDebug: false,
-            locale: "",
-            osName: process.platform,
-            osVersion: "",
-            engineName: "Node.js",
-            engineVersion: process.versions.node,
-            appVersion: this.appVersion,
-            sdkVersion: "chatlab@1"
-          },
-          props
-        })
+          type: "event",
+          payload: {
+            website: umami.websiteId,
+            hostname: "chatlab",
+            url: eventPath(envelope),
+            language: envelope.appLocale,
+            name: envelope.name,
+            id: envelope.anonymousId,
+            data: {
+              ...this.commonProperties(envelope),
+              ...envelope.properties
+            }
+          }
+        }),
+        signal: AbortSignal.timeout(5e3)
       });
-      return resp.ok;
-    } catch (e) {
-      console.error(`[Analytics] Failed to track ${eventName}:`, e);
+      if (!response.ok) {
+        appLogger.warn("analytics", "Umami rejected analytics event", {
+          eventName: envelope.name,
+          status: response.status
+        });
+      }
+      return response.ok;
+    } catch (error) {
+      appLogger.error("analytics", "Failed to send analytics event to Umami", error);
       return false;
     }
   }
-  async trackDailyActive(props) {
-    if (!this.endpoint) return;
+  getEnabled() {
+    return this.load().enabled;
+  }
+  setEnabled(enabled) {
+    this.updateData((data) => {
+      data.enabled = enabled;
+    }, void 0);
+  }
+  setAppLocale(locale) {
+    this.appLocale = normalizeLocale(locale);
+  }
+  async track(eventName, props) {
+    if (!this.getEnabled()) return false;
+    if (props?.app_locale !== void 0) this.setAppLocale(String(props.app_locale));
+    const event = normalizeEvent(eventName, props);
+    if (!event) return false;
+    if (!this.options.umami) return false;
+    const envelope = this.buildEnvelope(event);
+    const delivered = await this.sendToUmami(envelope);
+    appLogger.debug("analytics", delivered ? "Analytics event delivered" : "Analytics event was not delivered", {
+      eventName: envelope.name
+    });
+    return delivered;
+  }
+  trackDailyActive(props) {
+    if (this.dailyActivePromise) {
+      const locale = props?.app_locale ?? props?.locale;
+      if (locale !== void 0) this.setAppLocale(String(locale));
+      return this.dailyActivePromise;
+    }
+    this.dailyActivePromise = this.trackDailyActiveInternal(props).finally(() => {
+      this.dailyActivePromise = null;
+    });
+    return this.dailyActivePromise;
+  }
+  async trackDailyActiveInternal(props) {
+    const locale = props?.app_locale ?? props?.locale;
+    if (locale !== void 0) this.setAppLocale(String(locale));
     const data = this.load();
     if (!data.enabled) return;
+    if (!this.startupAttempted) {
+      this.startupAttempted = true;
+      await this.track("app_started");
+    }
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const isNew = data.firstReportDate === null;
-    if (isNew) data.firstReportDate = today;
-    if (data.lastReportDate === today) {
-      if (isNew) this.save(data);
-      return;
-    }
-    const tracked = await this.track(isNew ? "app_active_new" : "app_active", props);
+    if (data.lastReportDate === today) return;
+    const tracked = await this.track(isNew ? "app_active_new" : "app_active");
     if (!tracked) return;
-    data.lastReportDate = today;
-    this.save(data);
+    this.updateData((persisted) => {
+      persisted.firstReportDate ??= today;
+      persisted.lastReportDate = today;
+    }, void 0);
   }
 };
 
+// ../../packages/node-runtime/src/services/demo-import.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+var DEMO_BASE_URL = "https://chatlab.fun/assets/demo";
+var DEMO_FILES = ["demo-group.json", "demo-private-B-wukong.json"];
+async function importDemoSessions(options) {
+  const total = DEMO_FILES.length;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const sessionIds = [];
+  let tempDir;
+  try {
+    const createdTempDir = createChatLabTempDir("imports", options.tempPrefix);
+    tempDir = createdTempDir;
+    appLogger.info("demo-import", "Demo import started", {
+      locale: options.locale,
+      sessionCount: total,
+      targetTimeZone: options.targetTimeZone ?? "runtime-local"
+    });
+    const downloaded = [];
+    for (let index = 0; index < total; index++) {
+      const filename = DEMO_FILES[index];
+      options.onProgress?.({ stage: "downloading", current: index + 1, total });
+      const response = await fetchImpl.call(globalThis, `${DEMO_BASE_URL}/${options.locale}/${filename}`, {
+        signal: AbortSignal.timeout(6e4)
+      });
+      if (!response.ok) throw new Error(`Download demo failed (${filename}): HTTP ${response.status}`);
+      const content = Buffer.from(await response.arrayBuffer());
+      if (content.byteLength < 100) {
+        throw new Error(`Downloaded demo file is too small (${filename})`);
+      }
+      downloaded.push(content.toString("utf8"));
+    }
+    const rebased = rebaseChatLabDemoDocuments(downloaded, options.now?.() ?? /* @__PURE__ */ new Date(), options.targetTimeZone);
+    const localPaths = rebased.documents.map((document, index) => {
+      const localPath = path5.join(createdTempDir, DEMO_FILES[index]);
+      fs4.writeFileSync(localPath, document, "utf8");
+      return localPath;
+    });
+    appLogger.info("demo-import", "Demo timeline prepared", {
+      sessionCount: total,
+      offsetSeconds: rebased.offsetSeconds,
+      latestTimestamp: rebased.latestTimestamp
+    });
+    for (let index = 0; index < localPaths.length; index++) {
+      options.onProgress?.({ stage: "importing", current: index + 1, total });
+      const result = await options.importFile(localPaths[index]);
+      if (!result.success || !result.sessionId) {
+        throw new Error(result.error || `Failed to import demo: ${DEMO_FILES[index]}`);
+      }
+      sessionIds.push(result.sessionId);
+    }
+    const [groupSessionId, ...privateSessionIds] = sessionIds;
+    options.onProgress?.({ stage: "done", current: total, total });
+    appLogger.info("demo-import", "Demo import completed", { sessionCount: sessionIds.length });
+    return { success: true, groupSessionId, privateSessionIds };
+  } catch (error) {
+    const rollbackFailures = [];
+    for (const sessionId of sessionIds.toReversed()) {
+      try {
+        await options.deleteSession(sessionId);
+      } catch (rollbackError) {
+        rollbackFailures.push(rollbackError);
+        appLogger.error("demo-import", `Failed to roll back Demo session ${sessionId}`, rollbackError);
+      }
+    }
+    if (sessionIds.length > 0 && rollbackFailures.length === 0) {
+      appLogger.info("demo-import", "Rolled back partially imported Demo sessions", {
+        sessionCount: sessionIds.length
+      });
+    }
+    const originalMessage = error instanceof Error ? error.message : String(error);
+    const message = rollbackFailures.length === 0 ? originalMessage : `${originalMessage} (${rollbackFailures.length} Demo session(s) could not be rolled back.)`;
+    options.onProgress?.({ stage: "error", current: 0, total, message });
+    appLogger.error("demo-import", "Demo import failed", error);
+    return { success: false, error: message };
+  } finally {
+    if (tempDir) {
+      try {
+        removeChatLabTempDir(tempDir, "imports");
+      } catch (error) {
+        appLogger.warn("demo-import", "Failed to clean up Demo temporary directory", error);
+      }
+    }
+  }
+}
+
 // ../../packages/node-runtime/src/semantic-index/index.ts
 var semantic_index_exports = {};
 __export(semantic_index_exports, {
@@ -977,6 +1251,8 @@ __export(semantic_index_exports, {
   DEFAULT_SEMANTIC_INDEX_MODEL_DOWNLOAD_SOURCE: () => DEFAULT_SEMANTIC_INDEX_MODEL_DOWNLOAD_SOURCE,
   EMBEDDING_INDEX_SCHEMA: () => EMBEDDING_INDEX_SCHEMA,
   EmbeddingIndexStore: () => EmbeddingIndexStore,
+  LOCAL_EMBEDDING_RUNTIME_PACKAGE: () => LOCAL_EMBEDDING_RUNTIME_PACKAGE,
+  LOCAL_EMBEDDING_RUNTIME_VERSION: () => LOCAL_EMBEDDING_RUNTIME_VERSION,
   SEARCH_MAX_RESULTS_DEFAULT: () => SEARCH_MAX_RESULTS_DEFAULT,
   SEARCH_MAX_RESULTS_MAX: () => SEARCH_MAX_RESULTS_MAX,
   SEARCH_MAX_RESULTS_MIN: () => SEARCH_MAX_RESULTS_MIN,
@@ -1002,6 +1278,7 @@ __export(semantic_index_exports, {
   createChatDbMessageRangeReader: () => createChatDbMessageRangeReader,
   createChatDbMessageSource: () => createChatDbMessageSource,
   createEmbedder: () => createEmbedder,
+  createLocalEmbeddingRuntimeManager: () => createLocalEmbeddingRuntimeManager,
   createSemanticIndexService: () => createSemanticIndexService,
   createSemanticIndexWorkerClient: () => createSemanticIndexWorkerClient,
   createSemanticIndexWorkerRuntimeClient: () => createSemanticIndexWorkerRuntimeClient,
@@ -1027,7 +1304,7 @@ __export(semantic_index_exports, {
 });
 
 // ../../packages/node-runtime/src/semantic-index/worker-client.ts
-import path5 from "path";
+import path6 from "path";
 
 // ../../packages/node-runtime/src/semantic-index/worker-thread-transport.ts
 import { Worker } from "worker_threads";
@@ -1117,6 +1394,7 @@ function createSemanticIndexWorkerThreadTransport(options) {
 
 // ../../packages/node-runtime/src/semantic-index/worker-client.ts
 var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
+var MODEL_PRELOAD_STATUS_POLL_MS = 2e3;
 var defaultTimers = {
   setTimeout: (callback, ms) => setTimeout(callback, ms),
   clearTimeout: (timer) => clearTimeout(timer)
@@ -1125,8 +1403,10 @@ var SemanticIndexWorkerClient = class {
   transport = null;
   pendingRequests = 0;
   idleTimer = null;
+  modelPreloadPollTimer = null;
   activeBuildSessionIds = /* @__PURE__ */ new Set();
   hasUnknownActiveBuild = false;
+  hasActiveModelPreload = false;
   activeModelDownloadProxyUrl;
   configStore;
   transportFactory;
@@ -1152,7 +1432,10 @@ var SemanticIndexWorkerClient = class {
       apiKey: options?.apiKey,
       writeAuthProfile: this.writeAuthProfile
     });
-    if (!saved.enabled) this.clearActiveBuildTracking();
+    if (!saved.enabled) {
+      this.clearActiveBuildTracking();
+    }
+    if (!saved.enabled || saved.mode !== "local") this.clearModelPreloadTracking();
     const needsWorker = saved.enabled && saved.mode === "local" && this.configStore.isConfigured();
     if (!this.transport && !needsWorker) return saved;
     if (needsWorker) await this.closeTransportForLocalModelProxyChangeIfNeeded();
@@ -1165,8 +1448,10 @@ var SemanticIndexWorkerClient = class {
     return resolveSemanticIndexApiKeySet(this.configStore.get(), this.resolveApiKey);
   }
   async getModelStatus() {
-    if (!this.transport) return "idle";
-    return this.call("getModelStatus", []);
+    if (!this.transport && !this.shouldStartLocalModelWorker()) return "idle";
+    const status = await this.call("getModelStatus", [], { scheduleIdle: false });
+    this.updateModelPreloadStatus(status);
+    return status;
   }
   enable(sessionId) {
     return this.call("enable", [sessionId]);
@@ -1304,6 +1589,10 @@ var SemanticIndexWorkerClient = class {
     if (isKeylessSemanticIndexApiBaseUrl(config.api?.baseUrl)) return true;
     return resolveSemanticIndexApiKeySet(config, this.resolveApiKey);
   }
+  shouldStartLocalModelWorker() {
+    const config = this.configStore.get();
+    return config.enabled && config.mode === "local" && this.configStore.isConfigured();
+  }
   updateActiveBuildFromCompleteSnapshot(statuses) {
     this.hasUnknownActiveBuild = false;
     this.activeBuildSessionIds = new Set(
@@ -1325,8 +1614,43 @@ var SemanticIndexWorkerClient = class {
     this.hasUnknownActiveBuild = false;
     this.activeBuildSessionIds.clear();
   }
+  updateModelPreloadStatus(status) {
+    this.hasActiveModelPreload = status === "installing-runtime" || status === "downloading-model";
+    if (this.hasActiveModelPreload) this.scheduleModelPreloadPoll();
+    else {
+      this.clearModelPreloadPoll();
+      this.scheduleIdleCloseIfNeeded();
+    }
+  }
+  scheduleModelPreloadPoll() {
+    this.clearModelPreloadPoll();
+    if (!this.transport || !this.hasActiveModelPreload) return;
+    this.modelPreloadPollTimer = this.timers.setTimeout(() => {
+      this.modelPreloadPollTimer = null;
+      void this.pollModelPreloadStatus();
+    }, MODEL_PRELOAD_STATUS_POLL_MS);
+  }
+  async pollModelPreloadStatus() {
+    if (!this.transport || !this.hasActiveModelPreload) return;
+    try {
+      await this.getModelStatus();
+    } catch (error) {
+      appLogger.error("semantic-index", "Background model preload status poll failed; closing worker", error);
+      await this.closeFailedProbeTransport();
+    }
+  }
+  clearModelPreloadPoll() {
+    if (this.modelPreloadPollTimer) {
+      this.timers.clearTimeout(this.modelPreloadPollTimer);
+      this.modelPreloadPollTimer = null;
+    }
+  }
+  clearModelPreloadTracking() {
+    this.hasActiveModelPreload = false;
+    this.clearModelPreloadPoll();
+  }
   scheduleIdleCloseIfNeeded() {
-    if (!this.transport || this.pendingRequests > 0 || this.hasUnknownActiveBuild || this.activeBuildSessionIds.size > 0)
+    if (!this.transport || this.pendingRequests > 0 || this.hasUnknownActiveBuild || this.hasActiveModelPreload || this.activeBuildSessionIds.size > 0)
       return;
     this.clearIdleTimer();
     this.idleTimer = this.timers.setTimeout(() => {
@@ -1345,6 +1669,7 @@ var SemanticIndexWorkerClient = class {
     const transport = this.transport;
     this.transport = null;
     this.activeModelDownloadProxyUrl = void 0;
+    this.clearModelPreloadTracking();
     this.clearActiveBuildTracking();
     if (transport) await transport.close();
   }
@@ -1361,7 +1686,7 @@ function createSemanticIndexWorkerClient(options) {
 }
 function createSemanticIndexWorkerRuntimeClient(options) {
   const configStore = new SemanticIndexConfigStore(
-    path5.join(options.pathProvider.getAiDataDir(), SEMANTIC_INDEX_CONFIG_FILE)
+    path6.join(options.pathProvider.getAiDataDir(), SEMANTIC_INDEX_CONFIG_FILE)
   );
   return createSemanticIndexWorkerClient({
     configStore,
@@ -1376,7 +1701,8 @@ function createSemanticIndexWorkerRuntimeClient(options) {
         runtime: options.runtime,
         nativeBinding: options.nativeBinding,
         sqliteVecLoadablePath: options.sqliteVecLoadablePath,
-        modelDownloadProxyUrl
+        modelDownloadProxyUrl,
+        localEmbeddingRuntime: options.localEmbeddingRuntime
       }
     })
   });
@@ -1421,7 +1747,8 @@ export {
   buildMergedOutput,
   serializeChatLabToJsonl,
   AnalyticsService,
+  importDemoSessions,
   createSemanticIndexWorkerRuntimeClient,
   semantic_index_exports
 };
-//# sourceMappingURL=chunk-S5NCEESV.mjs.map
+//# sourceMappingURL=chunk-2XCNTG4O.mjs.map