chatlab-cli 0.33.0 → 0.34.0

package/dist/{chunk-C3B7RXES.mjs → chunk-OLE2USEN.mjs}

@@ -27,7 +27,10 @@ var localeConfigSchema = z.object({
   lang: z.string().default("")
 });
 var uiConfigSchema = z.object({
-  default_session_tab: z.enum(["overview", "ai-chat"]).default("overview"),
+  default_session_tab: z.preprocess(
+    (value) => value === "overview" ? "insights" : value,
+    z.enum(["insights", "ai-chat"]).default("insights")
+  ),
   session_gap_threshold: z.number().int().min(60).max(86400).default(1800),
   summary_strategy: z.enum(["brief", "standard"]).default("standard")
 });
@@ -296,9 +299,119 @@ var MigrationRunner = class {
 };
 
 // ../../packages/config/src/migrations/m001-legacy-to-multi-config.ts
+import * as path5 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+
+// ../../packages/config/src/atomic-json-file.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
-import { randomUUID } from "crypto";
+import { createHash, randomUUID } from "crypto";
+var LOCK_RETRY_MS = 10;
+var LOCK_TIMEOUT_MS = 1e4;
+var LOCK_STALE_MS = 3e4;
+var waitBuffer = new Int32Array(new SharedArrayBuffer(4));
+function waitForRetry() {
+  Atomics.wait(waitBuffer, 0, 0, LOCK_RETRY_MS);
+}
+function isProcessRunning(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function getRemovableLockToken(lockPath) {
+  try {
+    const owner = fs4.readFileSync(lockPath, "utf-8");
+    const ownerPid = Number.parseInt(owner.split(":", 1)[0] || "", 10);
+    const ageMs = Date.now() - fs4.statSync(lockPath).mtimeMs;
+    if (!Number.isInteger(ownerPid) || ownerPid <= 0) {
+      return ageMs > LOCK_STALE_MS ? owner : null;
+    }
+    if (!isProcessRunning(ownerPid)) return owner;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function tryRecoverStaleLock(lockPath, staleToken, deadline) {
+  const staleTokenHash = createHash("sha256").update(`${lockPath}\0${staleToken}`).digest("hex");
+  const recoveryPath = path4.join(path4.dirname(lockPath), `.chatlab-lock-recovery-${staleTokenHash}`);
+  const recoveryLock = acquireLockPath(recoveryPath, deadline);
+  try {
+    if (fs4.readFileSync(lockPath, "utf-8") !== staleToken) return false;
+    fs4.rmSync(lockPath, { force: true });
+    return true;
+  } catch {
+    return false;
+  } finally {
+    releaseFileLock(recoveryLock.lockPath, recoveryLock.token);
+  }
+}
+function acquireLockPath(lockPath, deadline) {
+  const token = `${process.pid}:${randomUUID()}`;
+  fs4.mkdirSync(path4.dirname(lockPath), { recursive: true });
+  while (true) {
+    try {
+      fs4.writeFileSync(lockPath, token, { encoding: "utf-8", flag: "wx", mode: 384 });
+      return { lockPath, token };
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST") throw error;
+      const removableToken = getRemovableLockToken(lockPath);
+      if (removableToken !== null && tryRecoverStaleLock(lockPath, removableToken, deadline)) {
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out waiting for configuration file lock: ${lockPath}`);
+      }
+      waitForRetry();
+    }
+  }
+}
+function acquireFileLock(filePath) {
+  return acquireLockPath(`${filePath}.lock`, Date.now() + LOCK_TIMEOUT_MS);
+}
+function releaseFileLock(lockPath, token) {
+  try {
+    if (fs4.readFileSync(lockPath, "utf-8") === token) {
+      fs4.rmSync(lockPath, { force: true });
+    }
+  } catch {
+  }
+}
+function withFileLock(filePath, action) {
+  const lock = acquireFileLock(filePath);
+  try {
+    return action();
+  } finally {
+    releaseFileLock(lock.lockPath, lock.token);
+  }
+}
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeJsonFileAtomically(filePath, data, mode) {
+  fs4.mkdirSync(path4.dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.tmp-${process.pid}-${randomUUID()}`;
+  try {
+    fs4.writeFileSync(tempPath, JSON.stringify(data, null, 2), {
+      encoding: "utf-8",
+      ...mode === void 0 ? {} : { mode }
+    });
+    fs4.renameSync(tempPath, filePath);
+  } finally {
+    fs4.rmSync(tempPath, { force: true });
+  }
+}
+
+// ../../packages/config/src/migrations/m001-legacy-to-multi-config.ts
 function isLegacyFlatConfig(data) {
   if (!data || typeof data !== "object") return false;
   const obj = data;
@@ -309,108 +422,94 @@ var m001LegacyToMultiConfig = {
   name: "legacy-to-multi-config",
   description: "Convert legacy flat LLM config to multi-config format",
   async up(ctx) {
-    const configPath = path4.join(ctx.aiDataDir, "llm-config.json");
-    if (!fs4.existsSync(configPath)) return;
-    const raw = fs4.readFileSync(configPath, "utf-8");
-    let data;
-    try {
-      data = JSON.parse(raw);
-    } catch {
-      return;
-    }
-    if (!isLegacyFlatConfig(data)) return;
-    ctx.logger.info("Migration", "Converting legacy flat config to multi-config format");
-    const now = Date.now();
-    const newConfig = {
-      id: randomUUID(),
-      name: data.provider,
-      provider: data.provider,
-      apiKey: data.apiKey || "",
-      model: data.model || "",
-      maxTokens: data.maxTokens,
-      createdAt: now,
-      updatedAt: now
-    };
-    const migrated = {
-      schemaVersion: 1,
-      configs: [newConfig],
-      defaultAssistant: { configId: newConfig.id, modelId: newConfig.model },
-      fastModel: null
-    };
-    fs4.writeFileSync(configPath, JSON.stringify(migrated, null, 2), "utf-8");
-    ctx.logger.info("Migration", "Legacy config migrated to multi-config format");
+    const configPath = path5.join(ctx.aiDataDir, "llm-config.json");
+    withFileLock(configPath, () => {
+      const data = readJsonFile(configPath);
+      if (!isLegacyFlatConfig(data)) return;
+      ctx.logger.info("Migration", "Converting legacy flat config to multi-config format");
+      const now = Date.now();
+      const newConfig = {
+        id: randomUUID2(),
+        name: data.provider,
+        provider: data.provider,
+        apiKey: data.apiKey || "",
+        model: data.model || "",
+        maxTokens: data.maxTokens,
+        createdAt: now,
+        updatedAt: now
+      };
+      const migrated = {
+        schemaVersion: 1,
+        configs: [newConfig],
+        defaultAssistant: { configId: newConfig.id, modelId: newConfig.model },
+        fastModel: null
+      };
+      writeJsonFileAtomically(configPath, migrated);
+      ctx.logger.info("Migration", "Legacy config migrated to multi-config format");
+    });
   }
 };
 
 // ../../packages/config/src/migrations/m002-schema-v2.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 var m002SchemaV2 = {
   version: 2,
   name: "schema-v2",
   description: "Upgrade LLM config to schema v2 (remove deprecated fields)",
   async up(ctx) {
-    const configPath = path5.join(ctx.aiDataDir, "llm-config.json");
-    if (!fs5.existsSync(configPath)) return;
-    let data;
-    try {
-      data = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
-    } catch {
-      return;
-    }
-    const schemaVersion = data.schemaVersion || 0;
-    if (schemaVersion >= 2) return;
-    ctx.logger.info("Migration", "Upgrading LLM config to schema v2");
-    const configs = data.configs || [];
-    const cleanedConfigs = configs.map((c) => {
-      const { disableThinking: _dt, isReasoningModel: _rm, ...rest } = c;
-      return rest;
+    const configPath = path6.join(ctx.aiDataDir, "llm-config.json");
+    withFileLock(configPath, () => {
+      const data = readJsonFile(configPath);
+      if (!data) return;
+      const schemaVersion = data.schemaVersion || 0;
+      if (schemaVersion >= 2) return;
+      ctx.logger.info("Migration", "Upgrading LLM config to schema v2");
+      const configs = data.configs || [];
+      const cleanedConfigs = configs.map((c) => {
+        const { disableThinking: _dt, isReasoningModel: _rm, ...rest } = c;
+        return rest;
+      });
+      data.configs = cleanedConfigs;
+      data.schemaVersion = 2;
+      writeJsonFileAtomically(configPath, data);
     });
-    data.configs = cleanedConfigs;
-    data.schemaVersion = 2;
-    fs5.writeFileSync(configPath, JSON.stringify(data, null, 2), "utf-8");
   }
 };
 
 // ../../packages/config/src/migrations/m003-schema-v3.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as path7 from "path";
 var m003SchemaV3 = {
   version: 3,
   name: "schema-v3-dual-slot",
   description: "Upgrade LLM config to schema v3 (dual-slot model selection)",
   async up(ctx) {
-    const configPath = path6.join(ctx.aiDataDir, "llm-config.json");
-    if (!fs6.existsSync(configPath)) return;
-    let data;
-    try {
-      data = JSON.parse(fs6.readFileSync(configPath, "utf-8"));
-    } catch {
-      return;
-    }
-    const schemaVersion = data.schemaVersion || 0;
-    if (schemaVersion >= 3) return;
-    ctx.logger.info("Migration", "Upgrading LLM config to schema v3 (dual-slot)");
-    const configs = data.configs || [];
-    const activeConfigId = data.activeConfigId;
-    const resolvedConfig = activeConfigId && configs.find((c) => c.id === activeConfigId) ? configs.find((c) => c.id === activeConfigId) : configs[0] ?? null;
-    data.defaultAssistant = resolvedConfig ? { configId: resolvedConfig.id, modelId: resolvedConfig.model || "" } : null;
-    data.fastModel = data.fastModel ?? null;
-    data.schemaVersion = 3;
-    delete data.activeConfigId;
-    fs6.writeFileSync(configPath, JSON.stringify(data, null, 2), "utf-8");
+    const configPath = path7.join(ctx.aiDataDir, "llm-config.json");
+    withFileLock(configPath, () => {
+      const data = readJsonFile(configPath);
+      if (!data) return;
+      const schemaVersion = data.schemaVersion || 0;
+      if (schemaVersion >= 3) return;
+      ctx.logger.info("Migration", "Upgrading LLM config to schema v3 (dual-slot)");
+      const configs = data.configs || [];
+      const activeConfigId = data.activeConfigId;
+      const resolvedConfig = activeConfigId && configs.find((c) => c.id === activeConfigId) ? configs.find((c) => c.id === activeConfigId) : configs[0] ?? null;
+      data.defaultAssistant = resolvedConfig ? { configId: resolvedConfig.id, modelId: resolvedConfig.model || "" } : null;
+      data.fastModel = data.fastModel ?? null;
+      data.schemaVersion = 3;
+      delete data.activeConfigId;
+      writeJsonFileAtomically(configPath, data);
+    });
   }
 };
 
 // ../../packages/config/src/migrations/m004-encrypted-keys-to-auth-profiles.ts
-import * as fs9 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 
 // ../../packages/config/src/migrations/crypto-legacy.ts
-import * as fs7 from "fs";
+import * as fs5 from "fs";
 import * as os2 from "os";
-import * as path7 from "path";
-import { createDecipheriv, createHash } from "crypto";
+import * as path8 from "path";
+import { createDecipheriv, createHash as createHash2 } from "crypto";
 import { execSync } from "child_process";
 var ENCRYPTED_PREFIX = "enc:";
 var ALGORITHM = "aes-256-gcm";
@@ -421,8 +520,8 @@ function isEncrypted(value) {
 }
 function readKeyFromFile(keyPath) {
   try {
-    if (fs7.existsSync(keyPath)) {
-      const key = fs7.readFileSync(keyPath, "utf-8").trim();
+    if (fs5.existsSync(keyPath)) {
+      const key = fs5.readFileSync(keyPath, "utf-8").trim();
       if (key.length >= 32) return key;
     }
   } catch {
@@ -431,14 +530,14 @@ function readKeyFromFile(keyPath) {
 }
 function getAllDeviceKeyPaths() {
   const home = os2.homedir();
-  const paths = [path7.join(home, ".chatlab", DEVICE_KEY_FILE)];
+  const paths = [path8.join(home, ".chatlab", DEVICE_KEY_FILE)];
   if (process.platform === "darwin") {
-    paths.push(path7.join(home, "Library", "Application Support", "ChatLab", "data", DEVICE_KEY_FILE));
+    paths.push(path8.join(home, "Library", "Application Support", "ChatLab", "data", DEVICE_KEY_FILE));
   } else if (process.platform === "win32") {
-    const appData = process.env.APPDATA || path7.join(home, "AppData", "Roaming");
-    paths.push(path7.join(appData, "ChatLab", "data", DEVICE_KEY_FILE));
+    const appData = process.env.APPDATA || path8.join(home, "AppData", "Roaming");
+    paths.push(path8.join(appData, "ChatLab", "data", DEVICE_KEY_FILE));
   } else {
-    paths.push(path7.join(home, ".config", "ChatLab", "data", DEVICE_KEY_FILE));
+    paths.push(path8.join(home, ".config", "ChatLab", "data", DEVICE_KEY_FILE));
   }
   return paths;
 }
@@ -476,16 +575,16 @@ function deriveLegacyKeys() {
         machineId = raw.replace(/[\r\n\s]/g, "").toLowerCase();
       }
       if (machineId) {
-        const hashed = createHash("sha256").update(machineId).digest("hex");
+        const hashed = createHash2("sha256").update(machineId).digest("hex");
         keys.push(
-          createHash("sha256").update(hashed + SALT).digest()
+          createHash2("sha256").update(hashed + SALT).digest()
         );
       }
     }
   } catch {
   }
   keys.push(
-    createHash("sha256").update("chatlab-fallback-key" + SALT).digest()
+    createHash2("sha256").update("chatlab-fallback-key" + SALT).digest()
   );
   return keys;
 }
@@ -508,7 +607,7 @@ function tryDecryptWithKey(encrypted, key) {
 function decryptApiKey(encrypted) {
   if (!encrypted || !isEncrypted(encrypted)) return encrypted || "";
   for (const dk of getAllDeviceKeys()) {
-    const derived = createHash("sha256").update(dk + SALT).digest();
+    const derived = createHash2("sha256").update(dk + SALT).digest();
     const result = tryDecryptWithKey(encrypted, derived);
     if (result !== null) return result;
   }
@@ -520,27 +619,32 @@ function decryptApiKey(encrypted) {
 }
 
 // ../../packages/config/src/auth-profiles.ts
-import * as fs8 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 var AUTH_PROFILES_FILE = "auth-profiles.json";
+function deriveAuthProfileName(provider, config) {
+  if (provider !== "openai-compatible") {
+    return provider.toLowerCase().replace(/\s+/g, "-");
+  }
+  if (typeof config.baseUrl === "string" && config.baseUrl) {
+    try {
+      return new URL(config.baseUrl).hostname.toLowerCase();
+    } catch {
+    }
+  }
+  if (typeof config.name === "string" && config.name) {
+    return config.name.toLowerCase().replace(/\s+/g, "-");
+  }
+  return "custom";
+}
 function getAuthProfilesPath() {
-  return path8.join(getConfigDir(), AUTH_PROFILES_FILE);
+  return path9.join(getConfigDir(), AUTH_PROFILES_FILE);
 }
 function loadAuthProfiles() {
-  const filePath = getAuthProfilesPath();
-  if (!fs8.existsSync(filePath)) {
-    return { version: 1, profiles: {} };
-  }
-  try {
-    const content = fs8.readFileSync(filePath, "utf-8");
-    const data = JSON.parse(content);
-    if (!data.profiles || typeof data.profiles !== "object") {
-      return { version: 1, profiles: {} };
-    }
-    return data;
-  } catch {
+  const data = readJsonFile(getAuthProfilesPath());
+  if (!data?.profiles || typeof data.profiles !== "object") {
     return { version: 1, profiles: {} };
   }
+  return data;
 }
 function getApiKeyByProfile(profileName) {
   const data = loadAuthProfiles();
@@ -564,89 +668,72 @@ function resolveApiKey(provider, authProfile) {
   return getApiKeyByProvider(provider);
 }
 function writeAuthProfile(name, profile) {
-  const configDir = getConfigDir();
-  if (!fs8.existsSync(configDir)) {
-    fs8.mkdirSync(configDir, { recursive: true });
-  }
-  const data = loadAuthProfiles();
-  data.profiles[name] = profile;
   const filePath = getAuthProfilesPath();
-  fs8.writeFileSync(filePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+  withFileLock(filePath, () => {
+    const data = loadAuthProfiles();
+    data.profiles[name] = profile;
+    writeJsonFileAtomically(filePath, data, 384);
+  });
 }
 function deleteAuthProfile(name) {
-  const data = loadAuthProfiles();
-  if (!(name in data.profiles)) return false;
-  delete data.profiles[name];
   const filePath = getAuthProfilesPath();
-  fs8.writeFileSync(filePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
-  return true;
+  return withFileLock(filePath, () => {
+    const data = loadAuthProfiles();
+    if (!(name in data.profiles)) return false;
+    delete data.profiles[name];
+    writeJsonFileAtomically(filePath, data, 384);
+    return true;
+  });
 }
 
 // ../../packages/config/src/migrations/m004-encrypted-keys-to-auth-profiles.ts
-function deriveProfileName(provider, config) {
-  if (provider !== "openai-compatible") {
-    return provider.toLowerCase().replace(/\s+/g, "-");
-  }
-  const baseUrl = config.baseUrl;
-  if (baseUrl) {
-    try {
-      return new URL(baseUrl).hostname.toLowerCase();
-    } catch {
-    }
-  }
-  const name = config.name;
-  if (name) return name.toLowerCase().replace(/\s+/g, "-");
-  return "custom";
-}
 var m004EncryptedKeysToAuthProfiles = {
   version: 4,
   name: "encrypted-keys-to-auth-profiles",
   description: "Migrate encrypted API keys from llm-config.json to auth-profiles.json",
   async up(ctx) {
-    const configPath = path9.join(ctx.aiDataDir, "llm-config.json");
-    if (!fs9.existsSync(configPath)) return;
-    let data;
-    try {
-      data = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
-    } catch {
-      return;
-    }
-    const configs = data.configs || [];
-    let migrated = false;
-    const usedProfileNames = /* @__PURE__ */ new Set();
-    for (const config of configs) {
-      const apiKey = config.apiKey;
-      if (!apiKey) continue;
-      const provider = config.provider || "unknown";
-      let plainKey = null;
-      if (isEncrypted(apiKey)) {
-        plainKey = decryptApiKey(apiKey);
-        if (!plainKey) {
-          ctx.logger.warn("Migration", `Failed to decrypt API key for "${config.name}", skipping`);
-          continue;
+    const configPath = path10.join(ctx.aiDataDir, "llm-config.json");
+    withFileLock(configPath, () => {
+      const data = readJsonFile(configPath);
+      if (!data) return;
+      const configs = data.configs || [];
+      let migrated = false;
+      const usedProfileNames = /* @__PURE__ */ new Set();
+      for (const config of configs) {
+        const apiKey = config.apiKey;
+        if (!apiKey) continue;
+        const provider = config.provider || "unknown";
+        let plainKey = null;
+        if (isEncrypted(apiKey)) {
+          plainKey = decryptApiKey(apiKey);
+          if (!plainKey) {
+            ctx.logger.warn("Migration", `Failed to decrypt API key for "${config.name}", skipping`);
+            continue;
+          }
+        } else if (apiKey.length > 0) {
+          plainKey = apiKey;
         }
-      } else if (apiKey.length > 0) {
-        plainKey = apiKey;
-      }
-      if (plainKey) {
-        const baseName = deriveProfileName(provider, config);
-        let profileName = baseName;
-        if (usedProfileNames.has(profileName)) {
-          let i = 2;
-          while (usedProfileNames.has(`${profileName}-${i}`)) i++;
-          profileName = `${profileName}-${i}`;
+        if (plainKey) {
+          const baseName = deriveAuthProfileName(provider, config);
+          let profileName = baseName;
+          if (usedProfileNames.has(profileName)) {
+            let i = 2;
+            while (usedProfileNames.has(`${profileName}-${i}`)) i++;
+            profileName = `${profileName}-${i}`;
+          }
+          usedProfileNames.add(profileName);
+          writeAuthProfile(profileName, { type: "api_key", provider, key: plainKey });
+          config.authProfile = profileName;
+          config.apiKey = "";
+          migrated = true;
+          ctx.logger.info("Migration", `Migrated API key \u2192 profile "${profileName}"`);
         }
-        usedProfileNames.add(profileName);
-        writeAuthProfile(profileName, { type: "api_key", provider, key: plainKey });
-        config.apiKey = "";
-        migrated = true;
-        ctx.logger.info("Migration", `Migrated API key \u2192 profile "${profileName}"`);
       }
-    }
-    if (migrated) {
-      fs9.writeFileSync(configPath, JSON.stringify(data, null, 2), "utf-8");
-      ctx.logger.info("Migration", "Cleared API keys from llm-config.json");
-    }
+      if (migrated) {
+        writeJsonFileAtomically(configPath, data);
+        ctx.logger.info("Migration", "Cleared API keys from llm-config.json");
+      }
+    });
   }
 };
 
@@ -1068,6 +1155,9 @@ var BUILTIN_PROVIDERS = [
   MINIMAX,
   OPENAI_COMPATIBLE
 ];
+function getBuiltinProviderById(id) {
+  return BUILTIN_PROVIDERS.find((p) => p.id === id) || null;
+}
 
 // ../../packages/core/src/ai/model-catalog.ts
 function builtin(m) {
@@ -1907,6 +1997,9 @@ var BUILTIN_MODELS = [
 function getBuiltinModelsByProvider(providerId) {
   return BUILTIN_MODELS.filter((m) => m.providerId === providerId);
 }
+function getBuiltinModelById(providerId, modelId) {
+  return BUILTIN_MODELS.find((m) => m.providerId === providerId && m.id === modelId) || null;
+}
 
 // ../../packages/core/src/ai/content-parser.ts
 var THINK_TAGS = ["think", "analysis", "reasoning", "reflection", "thought", "thinking"];
@@ -2773,6 +2866,15 @@ function getSegmentSummaries(db, options) {
   });
 }
 var DEFAULT_SESSION_GAP_THRESHOLD = 1800;
+function hasSessionIndex(db) {
+  if (!hasTable(db, "segment")) return false;
+  try {
+    const row = db.prepare("SELECT COUNT(*) as count FROM segment").get();
+    return (row?.count ?? 0) > 0;
+  } catch {
+    return false;
+  }
+}
 function getSessionIndexStats(db) {
   let sessionCount = 0;
   if (hasTable(db, "segment")) {
@@ -4912,6 +5014,7 @@ function getAnnualSummarySessionFacts(db, sessionId, range) {
 function aggregateAnnualSummaryFacts(facts, range, elapsedDayCount) {
   const ownerMessagesByDay = /* @__PURE__ */ new Map();
   const directContactsByDay = /* @__PURE__ */ new Map();
+  const directContactsByMonth = /* @__PURE__ */ new Map();
   const directContacts = /* @__PURE__ */ new Set();
   const messageTypes = /* @__PURE__ */ new Map();
   const textLengths = /* @__PURE__ */ new Map();
@@ -4945,11 +5048,15 @@ function aggregateAnnualSummaryFacts(facts, range, elapsedDayCount) {
     mergeNumberRecord(textLengths, item.textLengthCounts, Number);
     for (const [date, keys] of Object.entries(item.directContactKeysByDay)) {
       const daily = directContactsByDay.get(date) ?? /* @__PURE__ */ new Set();
+      const month = date.slice(0, 7);
+      const monthly = directContactsByMonth.get(month) ?? /* @__PURE__ */ new Set();
       keys.forEach((key) => {
         daily.add(key);
+        monthly.add(key);
         directContacts.add(key);
       });
       directContactsByDay.set(date, daily);
+      directContactsByMonth.set(month, monthly);
     }
   }
   const dailyActivity = [...ownerMessagesByDay.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([date, messageCount]) => ({ date, messageCount }));
@@ -4967,6 +5074,7 @@ function aggregateAnnualSummaryFacts(facts, range, elapsedDayCount) {
       averageDirectContactsPerDay: roundAverage(dailyDirectContactTotal, elapsedDayCount)
     },
     monthlyActivity: buildMonthlyActivity(range, ownerMessagesByDay),
+    monthlyDirectContacts: buildMonthlyDirectContacts(range, directContactsByMonth),
     dailyActivity,
     messageTypes: [...messageTypes.entries()].sort(([a], [b]) => a - b).map(([type, count]) => ({ type, count })),
     textLength: buildTextLengthSummary(textLengths),
@@ -5035,6 +5143,9 @@ function buildMonthlyActivity(range, ownerMessagesByDay) {
   }
   return listMonths(range).map((month) => ({ month, messageCount: counts.get(month) ?? 0 }));
 }
+function buildMonthlyDirectContacts(range, directContactsByMonth) {
+  return listMonths(range).map((month) => ({ month, contactCount: directContactsByMonth.get(month)?.size ?? 0 }));
+}
 function listMonths(range) {
   if (range.mode === "year" && range.year) {
     return Array.from({ length: 12 }, (_, index) => `${range.year}-${String(index + 1).padStart(2, "0")}`);
@@ -5883,13 +5994,10 @@ function getRelationshipStats(db, filter, options) {
     totalSessions: 0,
     hasSessionIndex: false,
     iceBreakers: [],
-    totalIceBreaks: 0,
     responseLatency: [],
     perseverance: [],
-    totalDoubleTexts: 0,
     monthlyResponseLatency: [],
-    monthlyPerseverance: [],
-    perseveranceThreshold
+    monthlyPerseverance: []
   };
   const sessionCount = db.prepare("SELECT COUNT(*) as count FROM segment").get();
   if (!sessionCount || sessionCount.count === 0) return emptyResult;
@@ -5919,11 +6027,10 @@ function getRelationshipStats(db, filter, options) {
   const memberInitTotals = /* @__PURE__ */ new Map();
   const memberCloseTotals = /* @__PURE__ */ new Map();
   const iceBreakMap = /* @__PURE__ */ new Map();
-  let totalIceBreaks = 0;
   let prevEndTs = null;
   for (const row of segmentRows) {
     const month = toLocalMonth(row.start_ts);
-    if (!monthMap.has(month)) monthMap.set(month, { initiateMap: /* @__PURE__ */ new Map(), closeMap: /* @__PURE__ */ new Map(), totalSessions: 0 });
+    if (!monthMap.has(month)) monthMap.set(month, { initiateMap: /* @__PURE__ */ new Map(), totalSessions: 0 });
     const ms = monthMap.get(month);
     ms.totalSessions++;
     if (row.initiator_id !== null) {
@@ -5931,14 +6038,12 @@ function getRelationshipStats(db, filter, options) {
       memberInitTotals.set(row.initiator_id, (memberInitTotals.get(row.initiator_id) ?? 0) + 1);
     }
     if (row.closer_id !== null) {
-      ms.closeMap.set(row.closer_id, (ms.closeMap.get(row.closer_id) ?? 0) + 1);
       memberCloseTotals.set(row.closer_id, (memberCloseTotals.get(row.closer_id) ?? 0) + 1);
     }
     if (prevEndTs !== null && row.initiator_id !== null && row.start_ts - prevEndTs > ICE_BREAK_THRESHOLD) {
       if (!iceBreakMap.has(month)) iceBreakMap.set(month, /* @__PURE__ */ new Map());
       const mMap = iceBreakMap.get(month);
       mMap.set(row.initiator_id, (mMap.get(row.initiator_id) ?? 0) + 1);
-      totalIceBreaks++;
     }
     prevEndTs = row.end_ts;
   }
@@ -5950,9 +6055,7 @@ function getRelationshipStats(db, filter, options) {
     const ms = monthMap.get(month);
     const members2 = Array.from(allMemberIds).map((memberId) => ({
       memberId,
-      name: memberNames.get(memberId) ?? `Unknown(${memberId})`,
-      initiateCount: ms.initiateMap.get(memberId) ?? 0,
-      closeCount: ms.closeMap.get(memberId) ?? 0
+      initiateCount: ms.initiateMap.get(memberId) ?? 0
     }));
     return { month, members: members2, totalSessions: ms.totalSessions };
   });
@@ -5978,16 +6081,13 @@ function getRelationshipStats(db, filter, options) {
     totalSessions: segmentRows.length,
     hasSessionIndex: true,
     iceBreakers,
-    totalIceBreaks,
-    ...msgStats,
-    perseveranceThreshold
+    ...msgStats
   };
 }
 function queryMessageLevelStats(db, segmentIds, memberNames, perseveranceThreshold) {
   const empty = {
     responseLatency: [],
     perseverance: [],
-    totalDoubleTexts: 0,
     monthlyResponseLatency: [],
     monthlyPerseverance: []
   };
@@ -6050,14 +6150,13 @@ function queryMessageLevelStats(db, segmentIds, memberNames, perseveranceThresho
   const responseLatency = Array.from(responseTotals.entries()).map(([memberId, { sum, count }]) => ({
     memberId,
     name: memberNames.get(memberId) ?? `Unknown(${memberId})`,
-    avgResponseTime: Math.round(sum / count),
-    totalResponses: count
+    avgResponseTime: Math.round(sum / count)
   })).sort((a, b) => a.avgResponseTime - b.avgResponseTime);
-  let totalDoubleTexts = 0;
-  const perseverance = Array.from(dtTotals.entries()).map(([memberId, count]) => {
-    totalDoubleTexts += count;
-    return { memberId, name: memberNames.get(memberId) ?? `Unknown(${memberId})`, totalDoubleTexts: count };
-  }).sort((a, b) => b.totalDoubleTexts - a.totalDoubleTexts);
+  const perseverance = Array.from(dtTotals.entries()).map(([memberId, count]) => ({
+    memberId,
+    name: memberNames.get(memberId) ?? `Unknown(${memberId})`,
+    totalDoubleTexts: count
+  })).sort((a, b) => b.totalDoubleTexts - a.totalDoubleTexts);
   const monthlyResponseLatency = Array.from(monthlyRespMap.entries()).sort(([a], [b]) => b.localeCompare(a)).map(([month, mMap]) => ({
     month,
     members: Array.from(mMap.entries()).map(([memberId, { sum, count }]) => ({
@@ -6075,13 +6174,214 @@ function queryMessageLevelStats(db, segmentIds, memberNames, perseveranceThresho
       doubleTextCount: count
     })).sort((a, b) => b.doubleTextCount - a.doubleTextCount)
   }));
-  return { responseLatency, perseverance, totalDoubleTexts, monthlyResponseLatency, monthlyPerseverance };
+  return { responseLatency, perseverance, monthlyResponseLatency, monthlyPerseverance };
 }
 function toLocalMonth(ts) {
   const d = new Date(ts * 1e3);
   return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`;
 }
 
+// ../../packages/core/src/query/advanced/journey.ts
+var SILENCE_THRESHOLD_SECONDS = 24 * 60 * 60;
+var EMPTY_RESULT = {
+  range: null,
+  hasSessionIndex: false,
+  months: [],
+  years: [],
+  peakMonth: null,
+  longestSegment: null,
+  longestSilence: null
+};
+function getJourneyStats(db, filter) {
+  const effectiveFilter = filter ? {
+    startTs: filter.startTs,
+    endTs: filter.endTs
+  } : void 0;
+  const monthlyRows = queryMonthlyRows(db, effectiveFilter);
+  if (monthlyRows.length === 0) return { ...EMPTY_RESULT };
+  const indexAvailable = hasSessionIndex(db) && hasTable(db, "message_context");
+  const segmentRows = indexAvailable ? querySegmentRows(db, effectiveFilter) : [];
+  const segmentCountByMonth = /* @__PURE__ */ new Map();
+  for (const segment2 of segmentRows) {
+    segmentCountByMonth.set(segment2.startMonth, (segmentCountByMonth.get(segment2.startMonth) ?? 0) + 1);
+  }
+  const firstRow = monthlyRows[0];
+  const lastRow = monthlyRows[monthlyRows.length - 1];
+  const monthsByKey = new Map(monthlyRows.map((row) => [row.month, row]));
+  const months = enumerateMonths(firstRow.month, lastRow.month).map((month) => {
+    const row = monthsByKey.get(month);
+    return {
+      month,
+      messageCount: row?.messageCount ?? 0,
+      activeDays: row?.activeDays ?? 0,
+      segmentCount: indexAvailable ? segmentCountByMonth.get(month) ?? 0 : null
+    };
+  });
+  const peakMonth = selectPeakMonth(months);
+  const years = buildYears(months);
+  const firstMessageTs = firstRow.firstMessageTs;
+  const lastMessageTs = lastRow.lastMessageTs;
+  return {
+    range: {
+      firstMessageTs,
+      lastMessageTs,
+      spanDays: Math.max(1, Math.floor((lastMessageTs - firstMessageTs) / 86400) + 1),
+      spanMonths: months.length,
+      activeDays: monthlyRows.reduce((sum, row) => sum + row.activeDays, 0),
+      activeMonths: monthlyRows.length
+    },
+    hasSessionIndex: indexAvailable,
+    months,
+    years,
+    peakMonth,
+    longestSegment: selectLongestSegment(segmentRows),
+    longestSilence: selectLongestSilence(segmentRows)
+  };
+}
+function queryMonthlyRows(db, filter) {
+  const { clause, params } = buildTimeFilter(filter, "msg");
+  const whereClause = buildSystemMessageFilter(clause);
+  return db.prepare(
+    `SELECT
+         strftime('%Y-%m', msg.ts, 'unixepoch', 'localtime') AS month,
+         COUNT(*) AS messageCount,
+         COUNT(DISTINCT strftime('%Y-%m-%d', msg.ts, 'unixepoch', 'localtime')) AS activeDays,
+         MIN(msg.ts) AS firstMessageTs,
+         MAX(msg.ts) AS lastMessageTs
+       FROM message msg
+       JOIN member m ON m.id = msg.sender_id
+       ${whereClause}
+       GROUP BY month
+       ORDER BY month ASC`
+  ).all(...params);
+}
+function querySegmentRows(db, filter) {
+  const { clause, params } = buildTimeFilter(filter, "msg");
+  const whereClause = buildSystemMessageFilter(clause);
+  return db.prepare(
+    `WITH filtered_messages AS (
+         SELECT
+           mc.segment_id AS segmentId,
+           msg.id AS messageId,
+           msg.sender_id AS senderId,
+           msg.ts AS ts,
+           COALESCE(m.group_nickname, m.account_name, m.platform_id) AS senderName,
+           ROW_NUMBER() OVER (
+             PARTITION BY mc.segment_id
+             ORDER BY msg.ts ASC, msg.id ASC
+           ) AS rowNumber
+         FROM message_context mc
+         JOIN segment s ON s.id = mc.segment_id
+         JOIN message msg ON msg.id = mc.message_id
+         JOIN member m ON m.id = msg.sender_id
+         ${whereClause}
+       ),
+       segment_summary AS (
+         SELECT
+           segmentId,
+           MIN(ts) AS startTs,
+           MAX(ts) AS endTs,
+           COUNT(*) AS messageCount
+         FROM filtered_messages
+         GROUP BY segmentId
+       )
+       SELECT
+         summary.segmentId,
+         summary.startTs,
+         summary.endTs,
+         summary.messageCount,
+         strftime('%Y-%m', summary.startTs, 'unixepoch', 'localtime') AS startMonth,
+         firstMessage.senderId AS initiatorId,
+         firstMessage.senderName AS initiatorName
+       FROM segment_summary summary
+       LEFT JOIN filtered_messages firstMessage
+         ON firstMessage.segmentId = summary.segmentId AND firstMessage.rowNumber = 1
+       ORDER BY summary.startTs ASC, summary.segmentId ASC`
+  ).all(...params);
+}
+function enumerateMonths(firstMonth, lastMonth) {
+  const [firstYear, firstMonthNumber] = firstMonth.split("-").map(Number);
+  const [lastYear, lastMonthNumber] = lastMonth.split("-").map(Number);
+  const firstIndex = firstYear * 12 + firstMonthNumber - 1;
+  const lastIndex = lastYear * 12 + lastMonthNumber - 1;
+  const months = [];
+  for (let index = firstIndex; index <= lastIndex; index++) {
+    const year = Math.floor(index / 12);
+    const month = index % 12 + 1;
+    months.push(`${year}-${String(month).padStart(2, "0")}`);
+  }
+  return months;
+}
+function selectPeakMonth(months) {
+  let peak = null;
+  for (const month of months) {
+    if (!peak || month.messageCount > peak.messageCount) peak = month;
+  }
+  return peak;
+}
+function buildYears(months) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const month of months) {
+    const year = Number.parseInt(month.month.slice(0, 4), 10);
+    const values = grouped.get(year);
+    if (values) values.push(month);
+    else grouped.set(year, [month]);
+  }
+  return Array.from(grouped.entries()).map(([year, values]) => {
+    const activeValues = values.filter((value) => value.messageCount > 0);
+    const peak = selectPeakMonth(values);
+    return {
+      year,
+      messageCount: values.reduce((sum, value) => sum + value.messageCount, 0),
+      activeDays: values.reduce((sum, value) => sum + value.activeDays, 0),
+      activeMonths: activeValues.length,
+      peakMonth: peak.month,
+      peakMonthMessageCount: peak.messageCount
+    };
+  });
+}
+function toJourneySegment(row) {
+  return {
+    segmentId: row.segmentId,
+    startTs: row.startTs,
+    endTs: row.endTs,
+    durationSeconds: Math.max(0, row.endTs - row.startTs),
+    messageCount: row.messageCount,
+    initiator: row.initiatorId === null || row.initiatorName === null ? null : { memberId: row.initiatorId, name: row.initiatorName }
+  };
+}
+function selectLongestSegment(rows) {
+  let longest = null;
+  for (const row of rows) {
+    const candidate = toJourneySegment(row);
+    if (!longest || candidate.durationSeconds > longest.durationSeconds || candidate.durationSeconds === longest.durationSeconds && candidate.messageCount > longest.messageCount || candidate.durationSeconds === longest.durationSeconds && candidate.messageCount === longest.messageCount && candidate.startTs < longest.startTs) {
+      longest = candidate;
+    }
+  }
+  return longest;
+}
+function selectLongestSilence(rows) {
+  let longest = null;
+  for (let index = 1; index < rows.length; index++) {
+    const previous = rows[index - 1];
+    const next = rows[index];
+    const durationSeconds = next.startTs - previous.endTs;
+    if (durationSeconds < SILENCE_THRESHOLD_SECONDS) continue;
+    const candidate = {
+      previousSegmentId: previous.segmentId,
+      nextSegmentId: next.segmentId,
+      startTs: previous.endTs,
+      endTs: next.startTs,
+      durationSeconds,
+      reopenedBy: next.initiatorId === null || next.initiatorName === null ? null : { memberId: next.initiatorId, name: next.initiatorName }
+    };
+    if (!longest || candidate.durationSeconds > longest.durationSeconds || candidate.durationSeconds === longest.durationSeconds && candidate.endTs < longest.endTs) {
+      longest = candidate;
+    }
+  }
+  return longest;
+}
+
 // ../../packages/core/src/query/advanced/languagePreference.ts
 var RE_ELLIPSIS = /\.{2,}|…+|。{2,}/g;
 var RE_EXCLAMATION = /[!！]+/g;
@@ -7503,15 +7803,15 @@ function runMigrations(db, migrationsList, forceRepair = false) {
 }
 
 // ../../packages/node-runtime/src/ai/ai-logger.ts
-import * as fs10 from "fs";
-import * as path10 from "path";
+import * as fs6 from "fs";
+import * as path11 from "path";
 var AiLogger = class {
   debugMode = false;
   logDir;
   logFile = null;
   logStream = null;
   constructor(logsDir) {
-    this.logDir = path10.join(logsDir, "ai");
+    this.logDir = path11.join(logsDir, "ai");
   }
   setDebugMode(enabled) {
     this.debugMode = enabled;
@@ -7541,14 +7841,14 @@ var AiLogger = class {
     return this.getLogFilePath();
   }
   getExistingLogPath() {
-    if (this.logFile && fs10.existsSync(this.logFile)) {
+    if (this.logFile && fs6.existsSync(this.logFile)) {
       return this.logFile;
     }
     return null;
   }
   ensureLogDir() {
-    if (!fs10.existsSync(this.logDir)) {
-      fs10.mkdirSync(this.logDir, { recursive: true });
+    if (!fs6.existsSync(this.logDir)) {
+      fs6.mkdirSync(this.logDir, { recursive: true });
     }
   }
   getLogFilePath() {
@@ -7558,14 +7858,14 @@ var AiLogger = class {
     const date = now.toISOString().split("T")[0];
     const hours = String(now.getHours()).padStart(2, "0");
     const minutes = String(now.getMinutes()).padStart(2, "0");
-    this.logFile = path10.join(this.logDir, `ai_${date}_${hours}-${minutes}.log`);
+    this.logFile = path11.join(this.logDir, `ai_${date}_${hours}-${minutes}.log`);
     return this.logFile;
   }
   getLogStream() {
     if (this.logStream) return this.logStream;
     const filePath = this.getLogFilePath();
-    const isNewOrEmptyFile = !fs10.existsSync(filePath) || fs10.statSync(filePath).size === 0;
-    this.logStream = fs10.createWriteStream(filePath, { flags: "a", encoding: "utf-8" });
+    const isNewOrEmptyFile = !fs6.existsSync(filePath) || fs6.statSync(filePath).size === 0;
+    this.logStream = fs6.createWriteStream(filePath, { flags: "a", encoding: "utf-8" });
     if (isNewOrEmptyFile) {
       this.logStream.write(`Local Path:  ${filePath.replace(/ /g, "\\ ")}
 
@@ -7628,8 +7928,8 @@ function extractErrorStack(error, stackLines = 5) {
 }
 
 // ../../packages/node-runtime/src/logging/app-logger.ts
-import * as fs11 from "fs";
-import * as path11 from "path";
+import * as fs7 from "fs";
+import * as path12 from "path";
 var LEVEL_ORDER = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 };
 var MAX_SIZE_BYTES = 10 * 1024 * 1024;
 var AppLogger = class {
@@ -7637,8 +7937,8 @@ var AppLogger = class {
   oldLogFile;
   threshold;
   constructor(logsDir) {
-    this.logFile = path11.join(logsDir, "app.log");
-    this.oldLogFile = path11.join(logsDir, "app.old.log");
+    this.logFile = path12.join(logsDir, "app.log");
+    this.oldLogFile = path12.join(logsDir, "app.old.log");
     this.threshold = resolveThreshold();
   }
   debug(scope, message, data) {
@@ -7665,9 +7965,9 @@ var AppLogger = class {
       if (tail) line += `
 ${tail}`;
       line += "\n";
-      ensureDir(path11.dirname(this.logFile));
+      ensureDir(path12.dirname(this.logFile));
       this.rotateIfNeeded();
-      fs11.appendFileSync(this.logFile, line, "utf-8");
+      fs7.appendFileSync(this.logFile, line, "utf-8");
     } catch (err) {
       console.error("[AppLogger] Failed to write log:", err);
     }
@@ -7676,12 +7976,12 @@ ${tail}`;
   rotateIfNeeded() {
     let size = 0;
     try {
-      size = fs11.statSync(this.logFile).size;
+      size = fs7.statSync(this.logFile).size;
     } catch {
       return;
     }
     if (size < MAX_SIZE_BYTES) return;
-    fs11.renameSync(this.logFile, this.oldLogFile);
+    fs7.renameSync(this.logFile, this.oldLogFile);
   }
 };
 function resolveThreshold() {
@@ -7705,7 +8005,7 @@ ${stack}` : "");
   }
 }
 function ensureDir(dir) {
-  if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
+  if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
 }
 var instance = null;
 function initAppLogger(logsDir) {
@@ -7720,8 +8020,8 @@ var appLogger = {
 };
 
 // ../../packages/node-runtime/src/nlp/segmenter.ts
-import * as fs12 from "fs";
-import * as path12 from "path";
+import * as fs8 from "fs";
+import * as path13 from "path";
 import { createRequire } from "module";
 var _nlpDir = null;
 var jiebaInstances = /* @__PURE__ */ new Map();
@@ -7734,14 +8034,14 @@ function getNlpDir() {
 }
 function existsDictOnDisk(dictId) {
   if (!_nlpDir) return false;
-  return fs12.existsSync(path12.join(_nlpDir, `${dictId}.dict`));
+  return fs8.existsSync(path13.join(_nlpDir, `${dictId}.dict`));
 }
 function tryLoadDictFromDisk(dictId) {
   if (!_nlpDir) return null;
-  const dictPath = path12.join(_nlpDir, `${dictId}.dict`);
-  if (!fs12.existsSync(dictPath)) return null;
+  const dictPath = path13.join(_nlpDir, `${dictId}.dict`);
+  if (!fs8.existsSync(dictPath)) return null;
   try {
-    return fs12.readFileSync(dictPath);
+    return fs8.readFileSync(dictPath);
   } catch {
     return null;
   }
@@ -7972,29 +8272,29 @@ function tokenizeQueryForFts(keywords) {
 }
 
 // ../../packages/node-runtime/src/migrations/electron-data-migration.ts
-import * as fs13 from "fs";
+import * as fs9 from "fs";
 import * as os3 from "os";
-import * as path13 from "path";
+import * as path14 from "path";
 var SYSTEM_SUBDIRS = ["ai", "settings", "cache", "logs", "nlp"];
 var STORAGE_CONFIG_FILE = "storage.json";
 function getElectronUserDataDir(options = {}) {
   const home = options.homeDir ?? os3.homedir();
   switch (options.platform ?? process.platform) {
     case "darwin":
-      return path13.join(home, "Library", "Application Support", "ChatLab");
+      return path14.join(home, "Library", "Application Support", "ChatLab");
     case "win32": {
-      const appData = options.appDataDir ?? process.env.APPDATA ?? path13.join(home, "AppData", "Roaming");
-      return path13.join(appData, "ChatLab");
+      const appData = options.appDataDir ?? process.env.APPDATA ?? path14.join(home, "AppData", "Roaming");
+      return path14.join(appData, "ChatLab");
     }
     default:
-      return path13.join(home, ".config", "ChatLab");
+      return path14.join(home, ".config", "ChatLab");
   }
 }
 function readElectronStorageConfig(electronUserData) {
-  const configPath = path13.join(electronUserData, STORAGE_CONFIG_FILE);
-  if (!fs13.existsSync(configPath)) return {};
+  const configPath = path14.join(electronUserData, STORAGE_CONFIG_FILE);
+  if (!fs9.existsSync(configPath)) return {};
   try {
-    return JSON.parse(fs13.readFileSync(configPath, "utf-8"));
+    return JSON.parse(fs9.readFileSync(configPath, "utf-8"));
   } catch {
     return {};
   }
@@ -8002,45 +8302,45 @@ function readElectronStorageConfig(electronUserData) {
 function resolveElectronDataDir() {
   const electronUserData = getElectronUserDataDir();
   const storageConfig = readElectronStorageConfig(electronUserData);
-  if (storageConfig.dataDir && path13.isAbsolute(storageConfig.dataDir)) {
+  if (storageConfig.dataDir && path14.isAbsolute(storageConfig.dataDir)) {
     return storageConfig.dataDir;
   }
-  return path13.join(electronUserData, "data");
+  return path14.join(electronUserData, "data");
 }
 function hasDatabases(dir) {
-  const dbDir = path13.join(dir, "databases");
-  if (!fs13.existsSync(dbDir)) return false;
+  const dbDir = path14.join(dir, "databases");
+  if (!fs9.existsSync(dbDir)) return false;
   try {
-    return fs13.readdirSync(dbDir).some((f) => f.endsWith(".db"));
+    return fs9.readdirSync(dbDir).some((f) => f.endsWith(".db"));
   } catch {
     return false;
   }
 }
 function ensureDir2(dirPath) {
-  if (!fs13.existsSync(dirPath)) {
-    fs13.mkdirSync(dirPath, { recursive: true });
+  if (!fs9.existsSync(dirPath)) {
+    fs9.mkdirSync(dirPath, { recursive: true });
   }
 }
 function copyDirMerge(src, dest) {
   const stats = { copied: 0, skipped: 0 };
-  if (!fs13.existsSync(src)) return stats;
+  if (!fs9.existsSync(src)) return stats;
   ensureDir2(dest);
   let entries;
   try {
-    entries = fs13.readdirSync(src, { withFileTypes: true });
+    entries = fs9.readdirSync(src, { withFileTypes: true });
   } catch {
     return stats;
   }
   for (const entry of entries) {
-    const srcPath = path13.join(src, entry.name);
-    const destPath = path13.join(dest, entry.name);
+    const srcPath = path14.join(src, entry.name);
+    const destPath = path14.join(dest, entry.name);
     try {
       if (entry.isDirectory()) {
         const sub = copyDirMerge(srcPath, destPath);
         stats.copied += sub.copied;
         stats.skipped += sub.skipped;
-      } else if (!fs13.existsSync(destPath)) {
-        fs13.copyFileSync(srcPath, destPath);
+      } else if (!fs9.existsSync(destPath)) {
+        fs9.copyFileSync(srcPath, destPath);
         stats.copied++;
       } else {
         stats.skipped++;
@@ -8053,22 +8353,22 @@ function copyDirMerge(src, dest) {
 function writeMigrationLog(logDir, message) {
   try {
     ensureDir2(logDir);
-    const logPath = path13.join(logDir, "app.log");
+    const logPath = path14.join(logDir, "app.log");
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
-    fs13.appendFileSync(logPath, `[${ts}] [MIGRATION] ${message}
+    fs9.appendFileSync(logPath, `[${ts}] [MIGRATION] ${message}
 `, "utf-8");
   } catch {
   }
 }
 function wasElectronUsed() {
   const electronUserData = getElectronUserDataDir();
-  if (!fs13.existsSync(electronUserData)) return false;
-  return fs13.existsSync(path13.join(electronUserData, "Preferences")) || fs13.existsSync(path13.join(electronUserData, "Local Storage")) || fs13.existsSync(path13.join(electronUserData, "Session Storage")) || fs13.existsSync(path13.join(electronUserData, "data"));
+  if (!fs9.existsSync(electronUserData)) return false;
+  return fs9.existsSync(path14.join(electronUserData, "Preferences")) || fs9.existsSync(path14.join(electronUserData, "Local Storage")) || fs9.existsSync(path14.join(electronUserData, "Session Storage")) || fs9.existsSync(path14.join(electronUserData, "data"));
 }
 function verifyCliDataPath(databaseDir) {
-  if (fs13.existsSync(databaseDir)) {
+  if (fs9.existsSync(databaseDir)) {
     try {
-      if (fs13.readdirSync(databaseDir).some((f) => f.endsWith(".db"))) return true;
+      if (fs9.readdirSync(databaseDir).some((f) => f.endsWith(".db"))) return true;
     } catch {
     }
   }
@@ -8086,9 +8386,9 @@ function migrateFromElectronIfNeeded(systemDir) {
     let totalSkipped = 0;
     const movedDirs = [];
     for (const subDir of SYSTEM_SUBDIRS) {
-      const srcDir = path13.join(electronDataDir, subDir);
-      const destDir = path13.join(systemDir, subDir);
-      if (!fs13.existsSync(srcDir)) continue;
+      const srcDir = path14.join(electronDataDir, subDir);
+      const destDir = path14.join(systemDir, subDir);
+      if (!fs9.existsSync(srcDir)) continue;
       const { copied, skipped } = copyDirMerge(srcDir, destDir);
       if (copied > 0 || skipped > 0) {
         movedDirs.push(subDir);
@@ -8098,13 +8398,13 @@ function migrateFromElectronIfNeeded(systemDir) {
       }
     }
     for (const subDir of movedDirs) {
-      const srcDir = path13.join(electronDataDir, subDir);
+      const srcDir = path14.join(electronDataDir, subDir);
       try {
-        fs13.rmSync(srcDir, { recursive: true, force: true });
+        fs9.rmSync(srcDir, { recursive: true, force: true });
       } catch {
       }
     }
-    const logsDir = path13.join(systemDir, "logs");
+    const logsDir = path14.join(systemDir, "logs");
     const summary = `CLI first-run: detected Electron data at ${electronDataDir}, pointed user_data_dir there, copied ${totalCopied} system files (${movedDirs.join(", ") || "none"})`;
     writeMigrationLog(logsDir, summary);
     console.log(`[Migration] ${summary}`);
@@ -8118,7 +8418,7 @@ function migrateFromElectronIfNeeded(systemDir) {
     const errorMsg = error instanceof Error ? error.message : String(error);
     console.error("[Migration] Electron data migration failed:", errorMsg);
     try {
-      writeMigrationLog(path13.join(systemDir, "logs"), `Electron migration failed: ${errorMsg}`);
+      writeMigrationLog(path14.join(systemDir, "logs"), `Electron migration failed: ${errorMsg}`);
     } catch {
     }
     return { migrated: false, electronDetected: true, error: errorMsg };
@@ -8126,26 +8426,26 @@ function migrateFromElectronIfNeeded(systemDir) {
 }
 
 // ../../packages/node-runtime/src/cache/session-cache.ts
-import * as fs14 from "fs";
-import * as path14 from "path";
+import * as fs10 from "fs";
+import * as path15 from "path";
 function getCachePath(sessionId, cacheDir) {
-  return path14.join(cacheDir, `${sessionId}.cache.json`);
+  return path15.join(cacheDir, `${sessionId}.cache.json`);
 }
 function readCacheFile(cachePath) {
   try {
-    if (!fs14.existsSync(cachePath)) return null;
-    return JSON.parse(fs14.readFileSync(cachePath, "utf-8"));
+    if (!fs10.existsSync(cachePath)) return null;
+    return JSON.parse(fs10.readFileSync(cachePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeCacheFile(cachePath, content) {
   try {
-    const dir = path14.dirname(cachePath);
-    if (!fs14.existsSync(dir)) {
-      fs14.mkdirSync(dir, { recursive: true });
+    const dir = path15.dirname(cachePath);
+    if (!fs10.existsSync(dir)) {
+      fs10.mkdirSync(dir, { recursive: true });
     }
-    fs14.writeFileSync(cachePath, JSON.stringify(content), "utf-8");
+    fs10.writeFileSync(cachePath, JSON.stringify(content), "utf-8");
   } catch {
   }
 }
@@ -8165,7 +8465,7 @@ function invalidateCache(sessionId, cacheDir, key) {
   const cachePath = getCachePath(sessionId, cacheDir);
   try {
     if (!key) {
-      if (fs14.existsSync(cachePath)) fs14.unlinkSync(cachePath);
+      if (fs10.existsSync(cachePath)) fs10.unlinkSync(cachePath);
     } else {
       const file = readCacheFile(cachePath);
       if (file && file[key]) {
@@ -8179,7 +8479,7 @@ function invalidateCache(sessionId, cacheDir, key) {
 function deleteSessionCache(sessionId, cacheDir) {
   const cachePath = getCachePath(sessionId, cacheDir);
   try {
-    if (fs14.existsSync(cachePath)) fs14.unlinkSync(cachePath);
+    if (fs10.existsSync(cachePath)) fs10.unlinkSync(cachePath);
   } catch {
   }
 }
@@ -8233,8 +8533,8 @@ function computeAndSetMembersCache(db, sessionId, cacheDir) {
 }
 
 // ../../packages/node-runtime/src/data-dir-compat.ts
-import fs15 from "fs";
-import path15 from "path";
+import fs11 from "fs";
+import path16 from "path";
 var DataDirCompatibilityError = class extends Error {
   code;
   userDataDir;
@@ -8254,10 +8554,10 @@ var DataDirCompatibilityError = class extends Error {
 };
 function readDataDirCompatibilityMeta(userDataDir) {
   const metaPath = getMetaPath(userDataDir);
-  if (!fs15.existsSync(metaPath)) return null;
+  if (!fs11.existsSync(metaPath)) return null;
   let parsed;
   try {
-    parsed = JSON.parse(fs15.readFileSync(metaPath, "utf-8"));
+    parsed = JSON.parse(fs11.readFileSync(metaPath, "utf-8"));
   } catch (error) {
     throw createInvalidMetaError(userDataDir, metaPath, "Invalid data directory compatibility meta JSON.", error);
   }
@@ -8340,7 +8640,7 @@ function raiseDataDirMinRuntimeVersion(pathProvider, input) {
   return nextMeta;
 }
 function getMetaPath(userDataDir) {
-  return path15.join(userDataDir, ".chatlab-meta.json");
+  return path16.join(userDataDir, ".chatlab-meta.json");
 }
 function validateDataDirCompatibilityMeta(value, userDataDir, metaPath) {
   if (!isRecord2(value)) {
@@ -8411,15 +8711,15 @@ function mergeReasons(existing, next) {
   return [.../* @__PURE__ */ new Set([...existing, next])];
 }
 function writeMetaAtomic(userDataDir, metaPath, meta) {
-  fs15.mkdirSync(userDataDir, { recursive: true });
-  const tempPath = path15.join(userDataDir, `.chatlab-meta.json.${process.pid}.${Date.now()}.tmp`);
+  fs11.mkdirSync(userDataDir, { recursive: true });
+  const tempPath = path16.join(userDataDir, `.chatlab-meta.json.${process.pid}.${Date.now()}.tmp`);
   try {
-    fs15.writeFileSync(tempPath, `${JSON.stringify(meta, null, 2)}
+    fs11.writeFileSync(tempPath, `${JSON.stringify(meta, null, 2)}
 `, "utf-8");
-    fs15.renameSync(tempPath, metaPath);
+    fs11.renameSync(tempPath, metaPath);
   } catch (error) {
     try {
-      if (fs15.existsSync(tempPath)) fs15.unlinkSync(tempPath);
+      if (fs11.existsSync(tempPath)) fs11.unlinkSync(tempPath);
     } catch {
     }
     throw error;
@@ -8758,44 +9058,44 @@ function getChatDbMigrations(deps) {
 }
 
 // ../../packages/node-runtime/src/services/contacts/paths.ts
-import path16 from "path";
+import path17 from "path";
 var CONTACTS_DIR_NAME = "contacts";
 var CONTACTS_FACTS_DIR_NAME = "facts";
 function getContactsDir(userDataDir) {
-  return path16.join(userDataDir, CONTACTS_DIR_NAME);
+  return path17.join(userDataDir, CONTACTS_DIR_NAME);
 }
 function getContactsFactsCacheDir(userDataDir) {
-  return path16.join(getContactsDir(userDataDir), CONTACTS_FACTS_DIR_NAME);
+  return path17.join(getContactsDir(userDataDir), CONTACTS_FACTS_DIR_NAME);
 }
 
 // ../../packages/node-runtime/src/services/global-insight/paths.ts
-import path17 from "path";
+import path18 from "path";
 function getGlobalInsightDir(userDataDir) {
-  return path17.join(userDataDir, "insight", "annual-summary");
+  return path18.join(userDataDir, "insight", "annual-summary");
 }
 function getGlobalInsightFactsCacheDir(userDataDir) {
-  return path17.join(getGlobalInsightDir(userDataDir), "facts");
+  return path18.join(getGlobalInsightDir(userDataDir), "facts");
 }
 
 // ../../packages/node-runtime/src/services/people/relationships/paths.ts
-import path18 from "path";
+import path19 from "path";
 var PEOPLE_DIR_NAME = "people";
 var RELATIONSHIPS_DIR_NAME = "relationships";
 var RELATIONSHIPS_FACTS_DIR_NAME = "facts";
 function getPeopleRelationshipsDir(userDataDir) {
-  return path18.join(userDataDir, PEOPLE_DIR_NAME, RELATIONSHIPS_DIR_NAME);
+  return path19.join(userDataDir, PEOPLE_DIR_NAME, RELATIONSHIPS_DIR_NAME);
 }
 function getPeopleRelationshipsFactsCacheDir(userDataDir) {
-  return path18.join(getPeopleRelationshipsDir(userDataDir), RELATIONSHIPS_FACTS_DIR_NAME);
+  return path19.join(getPeopleRelationshipsDir(userDataDir), RELATIONSHIPS_FACTS_DIR_NAME);
 }
 
 // ../../packages/node-runtime/src/database-manager.ts
-import * as fs17 from "fs";
-import * as path20 from "path";
+import * as fs13 from "fs";
+import * as path21 from "path";
 
 // ../../packages/node-runtime/src/services/global-insight/snapshot.ts
-import fs16 from "fs";
-import path19 from "path";
+import fs12 from "fs";
+import path20 from "path";
 
 // ../../packages/node-runtime/src/services/global-insight/time-range.ts
 function normalizeAnnualSummaryRange(input, nowInput = /* @__PURE__ */ new Date()) {
@@ -8846,17 +9146,17 @@ function toAnnualSummaryLocalDate(range) {
 // ../../packages/node-runtime/src/services/global-insight/snapshot.ts
 var SNAPSHOT_TMP_PREFIX = "annual-summary.tmp-";
 function getAnnualSummarySnapshotPath(snapshotDir, range) {
-  return path19.join(snapshotDir, `annual-summary-${toAnnualSummaryRangeKey(range)}.json`);
+  return path20.join(snapshotDir, `annual-summary-${toAnnualSummaryRangeKey(range)}.json`);
 }
 function readAnnualSummarySnapshot(snapshotDir, range, options = {}) {
   const snapshotPath = getAnnualSummarySnapshotPath(snapshotDir, range);
-  if (!fs16.existsSync(snapshotPath)) return null;
+  if (!fs12.existsSync(snapshotPath)) return null;
   try {
-    return JSON.parse(fs16.readFileSync(snapshotPath, "utf-8"));
+    return JSON.parse(fs12.readFileSync(snapshotPath, "utf-8"));
   } catch (error) {
-    const backupPath = path19.join(snapshotDir, `annual-summary.corrupt-${options.now?.() ?? Date.now()}.json`);
+    const backupPath = path20.join(snapshotDir, `annual-summary.corrupt-${options.now?.() ?? Date.now()}.json`);
     try {
-      fs16.renameSync(snapshotPath, backupPath);
+      fs12.renameSync(snapshotPath, backupPath);
     } catch (renameError) {
       appLogger.warn("global-insight", "failed to backup corrupt annual summary snapshot", renameError);
     }
@@ -8865,28 +9165,28 @@ function readAnnualSummarySnapshot(snapshotDir, range, options = {}) {
   }
 }
 function writeAnnualSummarySnapshot(snapshotDir, snapshot) {
-  fs16.mkdirSync(snapshotDir, { recursive: true });
-  const tmpPath = path19.join(snapshotDir, `${SNAPSHOT_TMP_PREFIX}${process.pid}-${Date.now()}`);
-  fs16.writeFileSync(tmpPath, JSON.stringify(snapshot, null, 2), "utf-8");
-  fs16.renameSync(tmpPath, getAnnualSummarySnapshotPath(snapshotDir, snapshot.range));
+  fs12.mkdirSync(snapshotDir, { recursive: true });
+  const tmpPath = path20.join(snapshotDir, `${SNAPSHOT_TMP_PREFIX}${process.pid}-${Date.now()}`);
+  fs12.writeFileSync(tmpPath, JSON.stringify(snapshot, null, 2), "utf-8");
+  fs12.renameSync(tmpPath, getAnnualSummarySnapshotPath(snapshotDir, snapshot.range));
 }
 function cleanupAnnualSummarySnapshotTempFiles(snapshotDir) {
-  if (!fs16.existsSync(snapshotDir)) return;
-  for (const name of fs16.readdirSync(snapshotDir)) {
+  if (!fs12.existsSync(snapshotDir)) return;
+  for (const name of fs12.readdirSync(snapshotDir)) {
     if (!name.startsWith(SNAPSHOT_TMP_PREFIX)) continue;
     try {
-      fs16.rmSync(path19.join(snapshotDir, name), { force: true });
+      fs12.rmSync(path20.join(snapshotDir, name), { force: true });
     } catch (error) {
       appLogger.warn("global-insight", "failed to remove annual summary snapshot temp file", error);
     }
   }
 }
 function deleteAnnualSummarySnapshots(snapshotDir) {
-  if (!fs16.existsSync(snapshotDir)) return;
-  for (const name of fs16.readdirSync(snapshotDir)) {
+  if (!fs12.existsSync(snapshotDir)) return;
+  for (const name of fs12.readdirSync(snapshotDir)) {
     if (!name.startsWith("annual-summary-") && !name.startsWith("annual-summary.")) continue;
     try {
-      fs16.rmSync(path19.join(snapshotDir, name), { force: true });
+      fs12.rmSync(path20.join(snapshotDir, name), { force: true });
     } catch (error) {
       appLogger.warn("global-insight", "failed to remove annual summary snapshot", error);
     }
@@ -8924,7 +9224,7 @@ var DatabaseManager = class {
       return this.cache.get(sessionId);
     }
     const dbPath = this.getDbPath(sessionId);
-    if (!fs17.existsSync(dbPath)) return null;
+    if (!fs13.existsSync(dbPath)) return null;
     this.migrateIfNeeded(dbPath);
     this.assertCompatible();
     const adapter = openBetterSqliteDatabase(dbPath, {
@@ -8970,7 +9270,7 @@ var DatabaseManager = class {
       this.cache.delete(sessionId);
     }
     const dbPath = this.getDbPath(sessionId);
-    if (!fs17.existsSync(dbPath)) return null;
+    if (!fs13.existsSync(dbPath)) return null;
     const adapter = openBetterSqliteDatabase(dbPath, {
       readonly: false,
       nativeBinding: this.nativeBinding
@@ -9010,8 +9310,8 @@ var DatabaseManager = class {
   listSessionIds() {
     this.assertCompatible();
     const dbDir = this.pathProvider.getDatabaseDir();
-    if (!fs17.existsSync(dbDir)) return [];
-    return fs17.readdirSync(dbDir).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", "")).filter((id) => {
+    if (!fs13.existsSync(dbDir)) return [];
+    return fs13.readdirSync(dbDir).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", "")).filter((id) => {
       const db = this.open(id);
       if (!db) return false;
       return isChatSessionDb(db);
@@ -9023,8 +9323,8 @@ var DatabaseManager = class {
   listSessionIdsReadonly() {
     this.assertCompatible();
     const dbDir = this.pathProvider.getDatabaseDir();
-    if (!fs17.existsSync(dbDir)) return [];
-    return fs17.readdirSync(dbDir).filter((fileName) => fileName.endsWith(".db")).map((fileName) => fileName.replace(".db", "")).filter((sessionId) => {
+    if (!fs13.existsSync(dbDir)) return [];
+    return fs13.readdirSync(dbDir).filter((fileName) => fileName.endsWith(".db")).map((fileName) => fileName.replace(".db", "")).filter((sessionId) => {
       const db = this.openRawSessionDatabase(sessionId, { readonly: true });
       try {
         return isChatSessionDb(db);
@@ -9040,17 +9340,17 @@ var DatabaseManager = class {
    * 获取数据库文件路径
    */
   getDbPath(sessionId) {
-    return path20.join(this.pathProvider.getDatabaseDir(), `${sessionId}.db`);
+    return path21.join(this.pathProvider.getDatabaseDir(), `${sessionId}.db`);
   }
   openRawSessionDatabase(sessionId, options = {}) {
     this.assertCompatible();
     const dbPath = this.getDbPath(sessionId);
-    if (!options.create && !fs17.existsSync(dbPath)) {
+    if (!options.create && !fs13.existsSync(dbPath)) {
       throw new Error(`Session database not found: ${sessionId}`);
     }
     if (!options.readonly) {
       this.close(sessionId);
-      fs17.mkdirSync(path20.dirname(dbPath), { recursive: true });
+      fs13.mkdirSync(path21.dirname(dbPath), { recursive: true });
     }
     const adapter = openBetterSqliteDatabase(dbPath, {
       readonly: options.readonly ?? false,
@@ -9068,17 +9368,17 @@ var DatabaseManager = class {
   deleteSessionDatabaseFiles(sessionId) {
     this.close(sessionId);
     const dbPath = this.getDbPath(sessionId);
-    const existed = ["", "-wal", "-shm"].some((suffix) => fs17.existsSync(dbPath + suffix));
+    const existed = ["", "-wal", "-shm"].some((suffix) => fs13.existsSync(dbPath + suffix));
     for (const suffix of ["", "-wal", "-shm"]) {
       try {
         const filePath = dbPath + suffix;
-        if (fs17.existsSync(filePath)) fs17.unlinkSync(filePath);
+        if (fs13.existsSync(filePath)) fs13.unlinkSync(filePath);
       } catch {
       }
     }
     const cacheDir = this.pathProvider.getCacheDir();
     deleteSessionCache(sessionId, cacheDir);
-    deleteSessionCache(sessionId, path20.join(cacheDir, "query"));
+    deleteSessionCache(sessionId, path21.join(cacheDir, "query"));
     deleteSessionCache(sessionId, getContactsFactsCacheDir(this.pathProvider.getUserDataDir()));
     deleteSessionCache(sessionId, getGlobalInsightFactsCacheDir(this.pathProvider.getUserDataDir()));
     deleteAnnualSummarySnapshots(getGlobalInsightDir(this.pathProvider.getUserDataDir()));
@@ -9119,12 +9419,12 @@ function shouldRepairCompatibilityGate(schemaVersion) {
 }
 
 // ../../packages/node-runtime/src/cache/analytics-cache.ts
-import * as fs18 from "fs";
+import * as fs14 from "fs";
 function getDbFileVersion(dbPath) {
   const parts = [];
   for (const p of [dbPath, `${dbPath}-wal`]) {
     try {
-      const st = fs18.statSync(p);
+      const st = fs14.statSync(p);
       parts.push(`${Math.floor(st.mtimeMs)}:${st.size}`);
     } catch {
       parts.push("-");
@@ -9229,6 +9529,11 @@ export {
   writeConfigField,
   ConfigSetError,
   setConfigField,
+  withFileLock,
+  readJsonFile,
+  writeJsonFileAtomically,
+  deriveAuthProfileName,
+  loadAuthProfiles,
   resolveApiKey,
   writeAuthProfile,
   deleteAuthProfile,
@@ -9324,6 +9629,7 @@ export {
   deleteMember,
   getCatchphraseAnalysis,
   getRelationshipStats,
+  getJourneyStats,
   getLanguagePreferenceAnalysis,
   getDragonKingAnalysis,
   getDivingAnalysis,
@@ -9338,8 +9644,10 @@ export {
   CHART_CAPABILITY_SKILL_ID,
   BUILTIN_TOOL_CATALOG,
   BUILTIN_PROVIDERS,
+  getBuiltinProviderById,
   BUILTIN_MODELS,
   getBuiltinModelsByProvider,
+  getBuiltinModelById,
   stripAvatarFields,
   StreamingThinkTagParser,
   needsStreamingThinkParsing,
@@ -9412,4 +9720,4 @@ export {
   StaticPathProvider,
   createDatabaseManagerAdapter
 };
-//# sourceMappingURL=chunk-C3B7RXES.mjs.map
+//# sourceMappingURL=chunk-OLE2USEN.mjs.map