codesesh 1.0.8 → 1.0.10

package/dist/{chunk-RBCCNCDO.js → chunk-WRVILHZR.js}

@@ -32,14 +32,14 @@ import {
   reportFieldMismatch,
   resolveSessionTitle,
   safeParseJsonRecord
-} from "./chunk-YLXHGL4S.js";
+} from "./chunk-2LXZFMSH.js";
 
-// ../core/dist/chunk-V6GZEKLJ.mjs
+// ../core/dist/chunk-XW3NUJH2.mjs
 import { statSync } from "fs";
 import { readdirSync, statSync as statSync2 } from "fs";
 import { join } from "path";
 import { existsSync as existsSync2, readFileSync, statSync as statSync3 } from "fs";
-import { join as join3, basename, dirname } from "path";
+import { join as join3, basename, dirname, isAbsolute as isAbsolute2, relative, sep } from "path";
 import { existsSync } from "fs";
 import { homedir, platform } from "os";
 import { isAbsolute, join as join2, resolve } from "path";
@@ -68,6 +68,15 @@ import * as zlib from "zlib";
 import { createHash as createHash2 } from "crypto";
 import { readFileSync as readFileSync8 } from "fs";
 import { join as join13 } from "path";
+import { createHash as createHash3 } from "crypto";
+import { homedir as homedir4, platform as platform4 } from "os";
+import { join as join15 } from "path";
+import { createHash as createHash4 } from "crypto";
+import { homedir as homedir5, platform as platform5 } from "os";
+import { join as join16 } from "path";
+import { createHash as createHash5 } from "crypto";
+import { homedir as homedir6 } from "os";
+import { join as join17 } from "path";
 function fingerprintMatches(ref, cached) {
   return typeof cached?.sourceFingerprint === "string" && cached.sourceFingerprint === ref.fingerprint;
 }
@@ -913,9 +922,9 @@ var ClaudeRecordConverter = class {
       if (partType !== "tool_use") continue;
       const toolCallId = String(part["id"] ?? "").trim();
       const subagentId = childSessionIdByToolUseId.get(toolCallId);
-      const toolPart2 = this.buildToolPart(part, timestampMs);
+      const toolPart3 = this.buildToolPart(part, timestampMs);
       const message = builder.appendToolCall(
-        toolPart2,
+        toolPart3,
         { id: uuid, timestampMs, agent: "claude", subagentId, model },
         { modeOnCreate: "tool" }
       );
@@ -1423,6 +1432,16 @@ var ClaudeCodeAgent = class extends SingleFileSessionSource {
     }
     return false;
   }
+  filterCachedSessions(sessions) {
+    const basePath = this.basePath ?? this.findBasePath();
+    if (!basePath) return sessions;
+    return sessions.filter((session) => {
+      const sourcePath = this.sessionMetaMap.get(session.reference.sessionId)?.sourcePath;
+      if (!sourcePath) return true;
+      const path = relative(basePath, sourcePath);
+      return path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute2(path);
+    });
+  }
   listSessionSources(options) {
     if (!this.basePath) return [];
     const projectDirs = this.listProjectDirs();
@@ -2421,12 +2440,12 @@ var KimiUsageAccumulator = class {
   totalCost = 0;
   applyContextRecord(record) {
     if (record.role !== "_usage") return;
-    const tokenCount2 = asNumber(record.token_count);
-    if (tokenCount2 === void 0) {
+    const tokenCount3 = asNumber(record.token_count);
+    if (tokenCount3 === void 0) {
       reportFieldMismatch("kimi", "usage.token_count");
       return;
     }
-    this.stats.total_tokens = tokenCount2;
+    this.stats.total_tokens = tokenCount3;
   }
   applyWireRecord(record) {
     if (this.usesWireTotalFallback) this.applyContextRecord(record);
@@ -2843,7 +2862,7 @@ var KimiAgent = class extends FileSystemSessionSource {
           const rawArgs = function_.arguments;
           const normalizedArgs = normalizeToolArguments(rawArgs);
           const buffer = typeof rawArgs === "string" && typeof normalizedArgs !== "string" ? rawArgs : null;
-          const toolPart2 = {
+          const toolPart3 = {
             type: "tool",
             tool: toolName,
             callID: callId,
@@ -2852,7 +2871,7 @@ var KimiAgent = class extends FileSystemSessionSource {
             time_created: timestampMs
           };
           builder.appendToolCall(
-            toolPart2,
+            toolPart3,
             { id: `wire-${seq}`, timestampMs, agent: "kimi" },
             { markModeAsTool: true, target: "current" }
           );
@@ -4176,7 +4195,7 @@ var CodexRecordConverter = class {
     if (!name) return;
     const toolIdentity = resolveToolIdentity(name, payload["namespace"]);
     const arguments_ = normalizeToolArguments(payload["arguments"]);
-    const toolPart2 = {
+    const toolPart3 = {
       type: "tool",
       tool: toolIdentity.tool,
       callID: callId,
@@ -4190,7 +4209,7 @@ var CodexRecordConverter = class {
       time_created: timestampMs
     };
     transcript.appendToolCall(
-      toolPart2,
+      toolPart3,
       { id: "", timestampMs, agent: "codex", model: activeModel },
       { markModeAsTool: true }
     );
@@ -4222,7 +4241,7 @@ var CodexRecordConverter = class {
     const toolIdentity = resolveToolIdentity(name, payload["namespace"]);
     const rawInput = payload["input"];
     const normalizedInput = normalizeCustomToolArguments(name, rawInput);
-    const toolPart2 = {
+    const toolPart3 = {
       type: "tool",
       tool: toolIdentity.tool,
       callID: callId,
@@ -4236,7 +4255,7 @@ var CodexRecordConverter = class {
       time_created: timestampMs
     };
     transcript.appendToolCall(
-      toolPart2,
+      toolPart3,
       { id: "", timestampMs, agent: "codex", model: activeModel },
       { markModeAsTool: true }
     );
@@ -4253,7 +4272,7 @@ var CodexRecordConverter = class {
     const { name, namespace } = splitExecToolName(call.name);
     const toolIdentity = resolveToolIdentity(name, namespace);
     const arguments_ = name === "apply_patch" ? parseApplyPatchInput(getExecPatchText(call.args)) : call.args;
-    const toolPart2 = {
+    const toolPart3 = {
       type: "tool",
       tool: toolIdentity.tool,
       callID: callId,
@@ -4267,7 +4286,7 @@ var CodexRecordConverter = class {
       time_created: timestampMs
     };
     transcript.appendToolCall(
-      toolPart2,
+      toolPart3,
       { id: "", timestampMs, agent: "codex", model: activeModel },
       { markModeAsTool: true }
     );
@@ -5109,7 +5128,7 @@ function parseBubbleRow(value) {
   const record = safeParseJsonRecord(value);
   if (!record) return null;
   const timingInfo = asRecord(record.timingInfo);
-  const tokenCount2 = asRecord(record.tokenCount);
+  const tokenCount3 = asRecord(record.tokenCount);
   const modelInfo = asRecord(record.modelInfo);
   const toolFormerData = asRecord(record.toolFormerData);
   return {
@@ -5133,9 +5152,9 @@ function parseBubbleRow(value) {
       ),
       clientEndTime: narrowNumber("bubble.timingInfo.clientEndTime", timingInfo.clientEndTime)
     } : void 0,
-    tokenCount: tokenCount2 ? {
-      inputTokens: narrowNumber("bubble.tokenCount.inputTokens", tokenCount2.inputTokens),
-      outputTokens: narrowNumber("bubble.tokenCount.outputTokens", tokenCount2.outputTokens)
+    tokenCount: tokenCount3 ? {
+      inputTokens: narrowNumber("bubble.tokenCount.inputTokens", tokenCount3.inputTokens),
+      outputTokens: narrowNumber("bubble.tokenCount.outputTokens", tokenCount3.outputTokens)
     } : void 0,
     modelInfo: modelInfo ? { modelName: narrowString("bubble.modelInfo.modelName", modelInfo.modelName) } : void 0,
     toolFormerData: toolFormerData ? {
@@ -5717,9 +5736,9 @@ var CursorAgent = class extends DatabaseSessionSource {
             parts.push({ type: "text", text, time_created: timestampMs });
           }
           if (bubble.toolFormerData) {
-            const toolPart2 = this.convertToolFormerData(bubble.toolFormerData, timestampMs);
-            if (toolPart2) {
-              parts.push(toolPart2);
+            const toolPart3 = this.convertToolFormerData(bubble.toolFormerData, timestampMs);
+            if (toolPart3) {
+              parts.push(toolPart3);
             }
           }
           if (parts.length === 0) continue;
@@ -6193,7 +6212,7 @@ var PiAgent = class extends SingleFileSessionSource {
       if (type === "toolCall") {
         const callId = String(item["id"] ?? "").trim();
         const toolName = String(item["name"] ?? "").trim() || "tool";
-        const toolPart2 = {
+        const toolPart3 = {
           type: "tool",
           tool: toolName,
           title: `Tool: ${toolName}`,
@@ -6204,7 +6223,7 @@ var PiAgent = class extends SingleFileSessionSource {
             input: item["arguments"] ?? {}
           }
         };
-        parts.push(toolPart2);
+        parts.push(toolPart3);
       }
     }
     return parts;
@@ -8305,7 +8324,1013 @@ function isMissingDirectory(error) {
   const code = error.code;
   return code === "ENOENT" || code === "ENOTDIR";
 }
+function parseDeepChatJson(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function deepChatTokens(metadata) {
+  const input = asNumber(metadata.inputTokens);
+  const output = asNumber(metadata.outputTokens);
+  if (input === void 0 && output === void 0) return void 0;
+  const cacheRead = Math.max(0, asNumber(metadata.cachedInputTokens) ?? 0);
+  const cacheCreate = Math.max(0, asNumber(metadata.cacheWriteInputTokens) ?? 0);
+  return {
+    input: Math.max(0, input ?? 0),
+    output: Math.max(0, output ?? 0),
+    cache_read: Math.min(cacheRead, Math.max(0, input ?? 0)),
+    cache_create: Math.min(cacheCreate, Math.max(0, (input ?? 0) - cacheRead))
+  };
+}
+function deepChatAssistantPart(block) {
+  const time_created = asNumber(block.timestamp);
+  const content = asString(block.content);
+  if (block.type === "tool_call") {
+    const tool = asRecord(block.tool_call);
+    if (!tool) return null;
+    const status = block.status === "pending" || block.status === "loading" ? "running" : block.status === "error" || block.status === "denied" ? "error" : "completed";
+    const output = parseDeepChatJson(tool.response);
+    return {
+      type: "tool",
+      tool: asString(tool.name) ?? "unknown",
+      callID: asString(tool.id),
+      time_created,
+      state: {
+        status,
+        input: parseDeepChatJson(tool.params),
+        output,
+        error: status === "error" ? output ?? content : void 0,
+        metadata: asRecord(block.extra)
+      }
+    };
+  }
+  if (block.type === "image") {
+    const image = asRecord(block.image_data);
+    const data = asString(image?.data);
+    const mime = asString(image?.mimeType);
+    if (data && mime) return { type: "image", data, mime_type: mime, time_created };
+  }
+  if (!content) return null;
+  return {
+    type: block.type === "reasoning_content" ? "reasoning" : "text",
+    text: content,
+    time_created
+  };
+}
+function deepChatStoredBlockPart(row) {
+  const extra = asRecord(parseDeepChatJson(row.extra_json));
+  return deepChatAssistantPart({
+    type: row.block_type,
+    content: row.text_content,
+    status: row.status,
+    timestamp: extra?.timestamp ?? row.updated_at,
+    extra: extra?.extra,
+    tool_call: {
+      id: row.tool_call_id,
+      name: row.tool_name,
+      params: row.tool_params,
+      response: row.tool_response
+    },
+    image_data: { data: extra?.imageData, mimeType: row.image_mime_type }
+  });
+}
+function deepChatUserParts(content) {
+  const parts = [];
+  const text = asString(content.text);
+  if (text) parts.push({ type: "text", text });
+  for (const file of asArray(content.files) ?? []) {
+    const record = asRecord(file);
+    const path = asString(record?.path);
+    const name = asString(record?.name);
+    if (path || name) parts.push({ type: "text", text: `Attachment: ${path ?? name}` });
+  }
+  for (const link of asArray(content.links) ?? []) {
+    if (typeof link === "string") parts.push({ type: "text", text: link });
+  }
+  return parts;
+}
+function deepChatRawParts(role, content) {
+  const parsed = parseDeepChatJson(content);
+  if (role === "user") {
+    const user = asRecord(parsed);
+    if (user) return deepChatUserParts(user);
+  }
+  if (Array.isArray(parsed)) {
+    const parts = [];
+    for (const value of parsed) {
+      const block = asRecord(value);
+      const part = block ? deepChatAssistantPart(block) : null;
+      if (part) parts.push(part);
+    }
+    return parts;
+  }
+  return typeof parsed === "string" && parsed ? [{ type: "text", text: parsed }] : [];
+}
+var AGENT_METADATA11 = getAgentCatalogEntry("deepchat");
+function resolveDeepChatDataRoot() {
+  const configured = readEnvPath("DEEPCHAT_USER_DATA_DIR");
+  if (configured) return configured;
+  if (platform4() === "darwin") return join15(homedir4(), "Library", "Application Support", "DeepChat");
+  if (platform4() === "win32") {
+    return join15(readEnvPath("APPDATA") ?? join15(homedir4(), "AppData", "Roaming"), "DeepChat");
+  }
+  return join15(readEnvPath("XDG_CONFIG_HOME") ?? join15(homedir4(), ".config"), "DeepChat");
+}
+function accumulateUsage(session, row) {
+  const model = asString(row.model) ?? session.model;
+  const provider = asString(row.provider) ?? session.provider;
+  const tokens = deepChatTokens(row);
+  if (!tokens && asNumber(row.totalTokens) === void 0) return;
+  const input = tokens?.input ?? 0;
+  const output = tokens?.output ?? 0;
+  const total = Math.max(0, asNumber(row.totalTokens) ?? input + output);
+  const { result: estimate, unpricedModels } = capturePricingMisses(
+    () => estimateTokenCost(model, tokens)
+  );
+  for (const missing of unpricedModels) session.unpricedModels.add(missing);
+  const cost = estimate ?? 0;
+  const stats = session.head.stats;
+  stats.total_input_tokens += input;
+  stats.total_output_tokens += output;
+  stats.total_tokens = (stats.total_tokens ?? 0) + total;
+  stats.total_cache_read_tokens = (stats.total_cache_read_tokens ?? 0) + (tokens?.cache_read ?? 0);
+  stats.total_cache_create_tokens = (stats.total_cache_create_tokens ?? 0) + (tokens?.cache_create ?? 0);
+  stats.total_cost += cost;
+  if (cost > 0) stats.cost_source = "estimated";
+  if (model && total > 0) {
+    const usage = session.head.model_usage ??= /* @__PURE__ */ Object.create(null);
+    usage[model] = (usage[model] ?? 0) + total;
+  }
+  const messageId = asString(row.message_id);
+  if (!messageId) return;
+  const previous = session.messageUsage.get(messageId);
+  session.messageUsage.set(messageId, {
+    model,
+    provider,
+    cost: (previous?.cost ?? 0) + cost,
+    tokens: {
+      input: (previous?.tokens.input ?? 0) + input,
+      output: (previous?.tokens.output ?? 0) + output,
+      cache_read: (previous?.tokens.cache_read ?? 0) + (tokens?.cache_read ?? 0),
+      cache_create: (previous?.tokens.cache_create ?? 0) + (tokens?.cache_create ?? 0)
+    }
+  });
+}
+var DeepChatAgent = class extends DatabaseSessionSource {
+  name = AGENT_METADATA11.name;
+  displayName = AGENT_METADATA11.displayName;
+  sourceRoot;
+  constructor(options = {}) {
+    super();
+    this.sourceRoot = options.sourceRoot ?? resolveDeepChatDataRoot();
+  }
+  getDatabasePath() {
+    return firstExisting(join15(this.sourceRoot, "app_db", "agent.db"));
+  }
+  isAvailable() {
+    return isSqliteAvailable() && this.getDatabasePath() !== null;
+  }
+  getSessionWatchPlan() {
+    return {
+      status: "supported",
+      targets: [{ root: this.sourceRoot, path: join15(this.sourceRoot, "app_db", "agent.db") }]
+    };
+  }
+  readDatabase(read) {
+    const path = this.getDatabasePath();
+    if (!path) throw new Error("DeepChat agent.db is missing");
+    return this.scanStep("reading unencrypted DeepChat agent.db", path, () => {
+      const db = openDbReadOnly(path);
+      if (!db)
+        throw new Error("Cannot open DeepChat agent.db; only unencrypted databases are supported");
+      try {
+        return db.transaction(() => read(db))();
+      } finally {
+        db.close();
+      }
+    });
+  }
+  scan(options) {
+    if (!this.getDatabasePath()) return [];
+    return this.readDatabase((db) => {
+      const projections = this.readProjections(db);
+      const selected = /* @__PURE__ */ new Set();
+      const children = /* @__PURE__ */ new Map();
+      for (const [id, projection] of projections) {
+        const parent = projection.head.parent_reference?.sessionId;
+        if (parent && projections.has(parent)) {
+          const siblings = children.get(parent) ?? [];
+          siblings.push(id);
+          children.set(parent, siblings);
+        } else if (matchesScanWindow(projection.head.time_updated ?? projection.head.time_created, options)) {
+          selected.add(id);
+        }
+      }
+      if (options?.includeRelatedSessions !== false) {
+        for (const id of selected) {
+          for (const child of children.get(id) ?? []) selected.add(child);
+        }
+      }
+      const sessions = [];
+      for (const id of selected) {
+        const projection = projections.get(id);
+        if (projection.head.stats.message_count === 0) continue;
+        this.rememberSession(id, {
+          sourceFingerprint: projection.signature.digest("hex"),
+          headParserVersion: "deepchat-v1",
+          unpricedModels: [...projection.unpricedModels]
+        });
+        sessions.push(projection.head);
+      }
+      sessions.sort(
+        (left, right) => (right.time_updated ?? 0) - (left.time_updated ?? 0) || left.reference.sessionId.localeCompare(right.reference.sessionId)
+      );
+      options?.onProgress?.({
+        total: selected.size,
+        processed: selected.size,
+        sessions: sessions.length
+      });
+      return sessions;
+    });
+  }
+  readProjections(db, sessionId) {
+    const filter = sessionId ? "AND s.id = ?" : "";
+    const bindings = sessionId ? [sessionId] : [];
+    const projections = /* @__PURE__ */ new Map();
+    const sessions = db.prepare(`
+      SELECT s.id, s.agent_id, s.title, s.project_dir, s.parent_session_id,
+        s.created_at, s.updated_at, s.revision, d.model_id, d.provider_id
+      FROM new_sessions s LEFT JOIN deepchat_sessions d ON d.id = s.id
+      WHERE s.is_draft = 0 ${filter}
+      ORDER BY s.id
+    `).iterate(...bindings);
+    for (const row of sessions) {
+      const id = String(row.id);
+      const parent = asString(row.parent_session_id);
+      projections.set(id, {
+        head: {
+          ...this.sessionIdentity(id),
+          title: resolveSessionTitle(asString(row.title), null, null),
+          directory: asString(row.project_dir) ?? "",
+          parent_reference: parent ? { agentName: this.name, sessionId: parent } : void 0,
+          time_created: Number(row.created_at),
+          time_updated: Number(row.updated_at),
+          stats: { message_count: 0, total_input_tokens: 0, total_output_tokens: 0, total_cost: 0 }
+        },
+        agentId: String(row.agent_id),
+        model: asString(row.model_id) ?? null,
+        provider: asString(row.provider_id) ?? null,
+        signature: createHash3("sha256").update(JSON.stringify(row)),
+        unpricedModels: /* @__PURE__ */ new Set(),
+        messageUsage: /* @__PURE__ */ new Map()
+      });
+    }
+    const usageRows = db.prepare(`
+      SELECT u.session_id, u.message_id, u.usage_id, u.created_at, u.updated_at,
+        u.model_id AS model, u.provider_id AS provider,
+        u.input_tokens AS inputTokens, u.output_tokens AS outputTokens,
+        u.total_tokens AS totalTokens, u.cached_input_tokens AS cachedInputTokens,
+        u.cache_write_input_tokens AS cacheWriteInputTokens
+      FROM deepchat_usage_stats u JOIN new_sessions s ON s.id = u.session_id
+      WHERE s.is_draft = 0 ${filter}
+      ORDER BY u.session_id, u.usage_id
+    `).iterate(...bindings);
+    for (const row of usageRows) {
+      const projection = projections.get(String(row.session_id));
+      accumulateUsage(projection, row);
+      projection.signature.update(JSON.stringify(row));
+      projection.head.time_updated = Math.max(
+        projection.head.time_updated ?? 0,
+        Number(row.created_at)
+      );
+    }
+    const messageRows = db.prepare(`
+      SELECT m.id, m.session_id, m.order_seq, m.role, m.status, m.metadata, m.updated_at
+      FROM deepchat_messages m JOIN new_sessions s ON s.id = m.session_id
+      WHERE s.is_draft = 0 ${filter}
+      ORDER BY m.session_id, m.order_seq, m.id
+    `).iterate(...bindings);
+    for (const row of messageRows) {
+      const projection = projections.get(String(row.session_id));
+      projection.signature.update(JSON.stringify(row));
+      projection.head.stats.message_count += 1;
+      projection.head.time_updated = Math.max(
+        projection.head.time_updated ?? 0,
+        Number(row.updated_at)
+      );
+      const metadata = asRecord(parseDeepChatJson(row.metadata));
+      if (row.role === "assistant" && metadata && !projection.messageUsage.has(String(row.id))) {
+        accumulateUsage(projection, { ...metadata, message_id: row.id });
+      }
+    }
+    const blockActivity = db.prepare(`
+      SELECT m.session_id, COUNT(*) AS block_count, MAX(b.updated_at) AS updated_at,
+        SUM(b.updated_at) AS block_revision
+      FROM deepchat_assistant_blocks b
+      JOIN deepchat_messages m ON m.id = b.message_id
+      JOIN new_sessions s ON s.id = m.session_id
+      WHERE s.is_draft = 0 ${filter}
+      GROUP BY m.session_id ORDER BY m.session_id
+    `).iterate(...bindings);
+    for (const row of blockActivity) {
+      const projection = projections.get(String(row.session_id));
+      projection.signature.update(JSON.stringify(row));
+      projection.head.time_updated = Math.max(
+        projection.head.time_updated ?? 0,
+        Number(row.updated_at)
+      );
+    }
+    return projections;
+  }
+  getSessionData(sessionId) {
+    return this.readDatabase((db) => {
+      const projection = this.readProjections(db, sessionId).get(sessionId);
+      if (!projection) throw new Error(`DeepChat session not found: ${sessionId}`);
+      const partsByMessage = this.readStructuredParts(db, sessionId);
+      const rows = db.prepare(`
+        SELECT id, role, content, metadata, status, created_at, updated_at
+        FROM deepchat_messages WHERE session_id = ? ORDER BY order_seq, id
+      `).iterate(sessionId);
+      const messages = [];
+      for (const row of rows) {
+        if (row.role !== "user" && row.role !== "assistant") continue;
+        const id = String(row.id);
+        const metadata = asRecord(parseDeepChatJson(row.metadata));
+        const usage = projection.messageUsage.get(id);
+        messages.push({
+          id,
+          role: row.role,
+          agent: row.role === "assistant" ? projection.agentId : void 0,
+          time_created: Number(row.created_at),
+          time_completed: row.status === "pending" ? void 0 : Number(row.updated_at),
+          model: usage?.model ?? asString(metadata?.model) ?? projection.model,
+          provider: usage?.provider ?? asString(metadata?.provider) ?? projection.provider,
+          tokens: usage?.tokens,
+          cost: usage?.cost,
+          cost_source: usage && usage.cost > 0 ? "estimated" : void 0,
+          parts: partsByMessage.get(id) ?? deepChatRawParts(row.role, String(row.content))
+        });
+      }
+      return { ...projection.head, messages };
+    });
+  }
+  readStructuredParts(db, sessionId) {
+    const parts = /* @__PURE__ */ new Map();
+    const blocks = db.prepare(`
+      SELECT b.* FROM deepchat_assistant_blocks b
+      JOIN deepchat_messages m ON m.id = b.message_id
+      WHERE m.session_id = ? ORDER BY b.message_id, b.block_index
+    `).iterate(sessionId);
+    for (const block of blocks) {
+      const id = String(block.message_id);
+      const messageParts = parts.get(id) ?? [];
+      const part = deepChatStoredBlockPart(block);
+      if (part) messageParts.push(part);
+      parts.set(id, messageParts);
+    }
+    const users = db.prepare(`
+      SELECT u.message_id, u.text FROM deepchat_user_messages u
+      JOIN deepchat_messages m ON m.id = u.message_id WHERE m.session_id = ?
+    `).iterate(sessionId);
+    for (const user of users) parts.set(String(user.message_id), deepChatUserParts(user));
+    const attachments = db.prepare(`
+      SELECT f.message_id, f.path, f.name FROM deepchat_user_message_files f
+      JOIN deepchat_messages m ON m.id = f.message_id
+      WHERE m.session_id = ? ORDER BY f.message_id, f.ordinal
+    `).iterate(sessionId);
+    for (const attachment of attachments) {
+      parts.get(String(attachment.message_id))?.push(...deepChatUserParts({ files: [attachment] }));
+    }
+    const links = db.prepare(`
+      SELECT l.message_id, l.url FROM deepchat_user_message_links l
+      JOIN deepchat_messages m ON m.id = l.message_id
+      WHERE m.session_id = ? ORDER BY l.message_id, l.ordinal
+    `).iterate(sessionId);
+    for (const link of links)
+      parts.get(String(link.message_id))?.push(...deepChatUserParts({ links: [link.url] }));
+    return parts;
+  }
+};
+function jsonRecord(value) {
+  return asRecord(typeof value === "string" ? JSON.parse(value) : value);
+}
+function nonnegative(value) {
+  return Math.max(0, asNumber(value) ?? 0);
+}
+function tokensFromStats(stats) {
+  if (!stats) return void 0;
+  const input = asRecord(stats.inputTokenDetails);
+  const output = asRecord(stats.outputTokenDetails);
+  return {
+    input: asNumber(stats.inputTokens) ?? nonnegative(input?.noCacheTokens) + nonnegative(input?.cacheReadTokens) + nonnegative(input?.cacheWriteTokens),
+    output: asNumber(stats.outputTokens) ?? nonnegative(output?.textTokens) + nonnegative(output?.reasoningTokens),
+    cache_read: nonnegative(input?.cacheReadTokens),
+    cache_create: nonnegative(input?.cacheWriteTokens),
+    reasoning: nonnegative(output?.reasoningTokens)
+  };
+}
+function messageCost(stats, model, tokens) {
+  const costs = (asArray(stats?.costs) ?? []).flatMap((value) => {
+    const cost2 = asRecord(value);
+    return cost2 ? [cost2] : [];
+  });
+  if (costs.length > 0 && costs.every((cost2) => cost2.currency === "USD")) {
+    return {
+      cost: costs.reduce((sum, cost2) => sum + nonnegative(cost2.amount), 0),
+      costSource: costs.some((cost2) => nonnegative(cost2.computedRequestCount) > 0) ? "estimated" : "recorded"
+    };
+  }
+  const cost = estimateTokenCost(model, tokens ? { ...tokens, reasoning: 0 } : void 0);
+  return {
+    cost: cost ?? void 0,
+    costSource: cost === null ? void 0 : "estimated"
+  };
+}
+function convertPart(part) {
+  const type = asString(part.type);
+  const text = asString(part.text);
+  if ((type === "text" || type === "reasoning") && text) return { type, text };
+  if (type === "dynamic-tool" || type?.startsWith("tool-")) {
+    const state = asString(part.state);
+    const failed = state === "output-error" || state === "output-denied";
+    return {
+      type: "tool",
+      tool: asString(part.toolName) ?? (type === "dynamic-tool" ? "unknown" : type.slice(5)),
+      callID: asString(part.toolCallId),
+      title: asString(part.title),
+      state: {
+        status: failed ? "error" : state === "output-available" ? "completed" : "running",
+        input: part.input,
+        output: part.output,
+        error: failed ? part.errorText ?? "Tool execution failed" : void 0,
+        metadata: part.providerMetadata
+      }
+    };
+  }
+  if (type === "file") {
+    const url = asString(part.url);
+    const mime = asString(part.mediaType);
+    if (url && mime?.startsWith("image/")) return { type: "image", url, mime_type: mime };
+    const label = asString(part.filename) ?? url;
+    return label ? { type: "text", text: `Attachment: ${label}` } : null;
+  }
+  const data = asRecord(part.data);
+  if (type === "data-error") {
+    const message = asString(data?.message);
+    return message ? { type: "text", text: message } : null;
+  }
+  if (type === "data-compact" || type === "data-code" || type === "data-translation") {
+    const content = asString(data?.content);
+    return content ? { type: "text", text: content } : null;
+  }
+  return null;
+}
+function cherryStudioTranscript(rows) {
+  const builder = new TranscriptBuilder();
+  const modelUsage = /* @__PURE__ */ Object.create(null);
+  let totalTokens = 0;
+  for (const row of rows) {
+    if (row.role !== "user" && row.role !== "assistant") continue;
+    const data = jsonRecord(row.data);
+    const snapshot = jsonRecord(row.message_snapshot);
+    const modelSnapshot = asRecord(snapshot?.model);
+    const uniqueModel = asString(row.model_id);
+    const separator = uniqueModel?.indexOf("::") ?? -1;
+    const model = asString(modelSnapshot?.id) ?? (separator >= 0 ? uniqueModel?.slice(separator + 2) : uniqueModel);
+    const provider = asString(modelSnapshot?.provider) ?? (separator >= 0 ? uniqueModel?.slice(0, separator) : void 0);
+    const stats = row.role === "assistant" ? jsonRecord(row.stats) : void 0;
+    const tokens = tokensFromStats(stats);
+    const total = nonnegative(stats?.totalTokens ?? (tokens?.input ?? 0) + (tokens?.output ?? 0));
+    totalTokens += total;
+    if (model && total > 0) modelUsage[model] = (modelUsage[model] ?? 0) + total;
+    const message = builder.appendMessage({
+      id: String(row.id),
+      role: row.role,
+      timestampMs: Number(row.created_at),
+      agent: asString(snapshot?.name),
+      model,
+      provider,
+      tokens,
+      ...messageCost(stats, model, tokens),
+      parts: (asArray(data?.parts) ?? []).flatMap((value) => {
+        const part = asRecord(value);
+        const converted = part ? convertPart(part) : null;
+        return converted ? [converted] : [];
+      })
+    });
+    if (row.status !== "pending") message.time_completed = Number(row.updated_at);
+  }
+  const transcript = builder.finish();
+  return {
+    ...transcript,
+    stats: { ...transcript.stats, total_tokens: totalTokens },
+    modelUsage
+  };
+}
+var AGENT_METADATA12 = getAgentCatalogEntry("cherrystudio");
+function resolveCherryStudioDataRoot() {
+  const configured = readEnvPath("CHERRYSTUDIO_USER_DATA_DIR");
+  if (configured) return configured;
+  if (platform5() === "darwin")
+    return join16(homedir5(), "Library", "Application Support", "CherryStudio");
+  if (platform5() === "win32") {
+    return join16(readEnvPath("APPDATA") ?? join16(homedir5(), "AppData", "Roaming"), "CherryStudio");
+  }
+  return join16(readEnvPath("XDG_CONFIG_HOME") ?? join16(homedir5(), ".config"), "CherryStudio");
+}
+function liveRows(db, table, alias) {
+  const columns = db.prepare(`PRAGMA table_info(${table})`).all();
+  return columns.some((column) => column.name === "deleted_at") ? `${alias}.deleted_at IS NULL` : "1 = 1";
+}
+function activeBranch(rows, activeId) {
+  const byId = new Map(rows.map((row) => [String(row.id), row]));
+  const selected = [];
+  const visited = /* @__PURE__ */ new Set();
+  let id = asString(activeId);
+  while (id) {
+    if (visited.has(id)) throw new Error("Cherry Studio message branch contains a cycle");
+    visited.add(id);
+    const row = byId.get(id);
+    if (!row) break;
+    selected.push(row);
+    id = asString(row.parent_id);
+  }
+  return selected.reverse();
+}
+var CherryStudioAgent = class extends DatabaseSessionSource {
+  name = AGENT_METADATA12.name;
+  displayName = AGENT_METADATA12.displayName;
+  sourceRoot;
+  constructor(options = {}) {
+    super();
+    this.sourceRoot = options.sourceRoot ?? resolveCherryStudioDataRoot();
+  }
+  getDatabasePath() {
+    return firstExisting(join16(this.sourceRoot, "Data", "cherrystudio.sqlite"));
+  }
+  isAvailable() {
+    return isSqliteAvailable() && this.getDatabasePath() !== null;
+  }
+  getSessionWatchPlan() {
+    return {
+      status: "supported",
+      targets: [
+        { root: this.sourceRoot, path: join16(this.sourceRoot, "Data", "cherrystudio.sqlite") }
+      ]
+    };
+  }
+  readDatabase(read) {
+    const path = this.getDatabasePath();
+    if (!path) throw new Error("Cherry Studio 2.x cherrystudio.sqlite is missing");
+    return this.scanStep("reading Cherry Studio 2.x cherrystudio.sqlite", path, () => {
+      const db = openDbReadOnly(path);
+      if (!db) throw new Error("Cannot open Cherry Studio database");
+      try {
+        return db.transaction(() => read(db))();
+      } finally {
+        db.close();
+      }
+    });
+  }
+  scan(options) {
+    if (!this.getDatabasePath()) return [];
+    return this.readDatabase((db) => {
+      const sessions = [];
+      for (const kind of ["agent", "topic"]) {
+        for (const projection of this.readConversations(db, kind)) {
+          const { messages: _messages, ...head } = projection.session;
+          if (!head.stats.message_count || !matchesScanWindow(head.time_updated ?? head.time_created, options))
+            continue;
+          this.rememberSession(head.reference.sessionId, {
+            sourceFingerprint: projection.fingerprint,
+            headParserVersion: "cherrystudio-v1",
+            unpricedModels: projection.unpricedModels
+          });
+          sessions.push(head);
+        }
+      }
+      sessions.sort(
+        (left, right) => (right.time_updated ?? 0) - (left.time_updated ?? 0) || left.reference.sessionId.localeCompare(right.reference.sessionId)
+      );
+      options?.onProgress?.({
+        total: sessions.length,
+        processed: sessions.length,
+        sessions: sessions.length
+      });
+      return sessions;
+    });
+  }
+  getSessionData(sessionId) {
+    const separator = sessionId.indexOf(":");
+    const kind = sessionId.slice(0, separator);
+    const id = sessionId.slice(separator + 1);
+    if (kind !== "agent" && kind !== "topic" || !id)
+      throw new Error(`Invalid Cherry Studio session: ${sessionId}`);
+    return this.readDatabase((db) => {
+      for (const projection of this.readConversations(db, kind, id)) return projection.session;
+      throw new Error(`Cherry Studio session not found: ${sessionId}`);
+    });
+  }
+  *readConversations(db, kind, id) {
+    const table = kind === "agent" ? "agent_session" : "topic";
+    const messageTable = kind === "agent" ? "agent_session_message" : "message";
+    const foreignKey = kind === "agent" ? "session_id" : "topic_id";
+    const filter = `${liveRows(db, table, "s")} ${id ? "AND s.id = ?" : ""}`;
+    const bindings = id ? [id] : [];
+    const headers = db.prepare(`
+      SELECT s.id, s.name, s.created_at, s.updated_at, s.last_activity_at,
+        ${kind === "agent" ? "w.path AS directory, NULL AS active_node_id" : "NULL AS directory, s.active_node_id"}
+      FROM ${table} s ${kind === "agent" ? "LEFT JOIN agent_workspace w ON w.id = s.workspace_id" : ""}
+      WHERE ${filter}
+    `).all(...bindings);
+    const byId = new Map(headers.map((row) => [String(row.id), row]));
+    const messages = db.prepare(`
+      SELECT m.id, m.${foreignKey} AS conversation_id, m.role, m.data, m.stats,
+        m.model_id, m.message_snapshot, m.status, m.created_at, m.updated_at,
+        ${kind === "topic" ? "m.parent_id" : "NULL AS parent_id"}
+      FROM ${messageTable} m JOIN ${table} s ON s.id = m.${foreignKey}
+      WHERE ${filter} AND ${liveRows(db, messageTable, "m")}
+      ORDER BY m.${foreignKey}, m.created_at, m.id
+    `).iterate(...bindings);
+    let currentId;
+    let rows = [];
+    for (const row of messages) {
+      const nextId = String(row.conversation_id);
+      if (currentId !== void 0 && nextId !== currentId) {
+        yield this.projectConversation(kind, byId.get(currentId), rows);
+        rows = [];
+      }
+      currentId = nextId;
+      rows.push(row);
+    }
+    if (currentId !== void 0) yield this.projectConversation(kind, byId.get(currentId), rows);
+  }
+  projectConversation(kind, row, rows) {
+    const selected = kind === "topic" ? activeBranch(rows, row.active_node_id) : rows;
+    const { result: transcript, unpricedModels } = capturePricingMisses(
+      () => cherryStudioTranscript(selected)
+    );
+    const signature = createHash4("sha256").update(JSON.stringify(row));
+    for (const message of selected) signature.update(JSON.stringify(message));
+    const session = {
+      ...this.sessionIdentity(`${kind}:${row.id}`),
+      title: resolveSessionTitle(
+        asString(row.name),
+        firstUserMessageTitle(transcript.messages),
+        "Cherry Studio"
+      ),
+      directory: asString(row.directory) || this.sourceRoot,
+      time_created: Number(row.created_at),
+      time_updated: Number(row.last_activity_at),
+      stats: transcript.stats,
+      model_usage: transcript.modelUsage,
+      messages: transcript.messages
+    };
+    return { session, fingerprint: signature.digest("hex"), unpricedModels };
+  }
+};
+function parseToolJson(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function toolPart2(value) {
+  const call = asRecord(value);
+  if (!call) return null;
+  const tool = asString(call.tool_name);
+  if (!tool) return null;
+  const input = parseToolJson(call.tool_call_args);
+  const output = parseToolJson(call.tool_call_result_data);
+  const result = asRecord(output);
+  const failed = call.tool_call_status === 3 || result?.isError === true || result?.error != null;
+  return {
+    type: "tool",
+    tool,
+    callID: asString(call.tool_call_id),
+    state: {
+      status: failed ? "error" : call.tool_call_status === 2 ? "completed" : "running",
+      input,
+      output,
+      error: failed ? result?.error ?? result?.text ?? output : void 0,
+      metadata: {
+        ...asRecord(result?.details),
+        minimax_status: call.tool_call_status
+      }
+    }
+  };
+}
+function attachmentPart(value) {
+  const attachment = asRecord(value);
+  if (!attachment) return null;
+  const path = asString(attachment.file_path) ?? asString(attachment.desktop_path);
+  const mime = asString(attachment.mime_type);
+  const name = path ?? asString(attachment.file_name) ?? asString(attachment.asset_id) ?? asString(attachment.url);
+  return name ? { type: "text", text: `Attachment: ${name}${mime ? ` (${mime})` : ""}` } : null;
+}
+var EVENT_LABELS = {
+  compaction_start: "Context compaction started",
+  compaction: "Context compacted",
+  compaction_failed: "Context compaction failed",
+  review_start: "Review started",
+  review_result: "Review result",
+  review_failed: "Review failed",
+  review_aborted: "Review aborted",
+  review_interrupted: "Review interrupted"
+};
+var AUTOMATED_SOURCES = /* @__PURE__ */ new Set(["cron", "thread-goal", "team", "background-task", "system"]);
+function miniMaxMessage(row, agent) {
+  const data = asRecord(JSON.parse(String(row.data_json)));
+  const id = asString(row.msg_id);
+  if (!data || !id || data.msg_id !== id) throw new Error("Invalid MiniMax display message");
+  const role = row.role ?? data.role ?? "assistant";
+  if (role !== "user" && role !== "assistant") throw new Error(`Invalid MiniMax role: ${role}`);
+  const kind = asString(data.kind);
+  const parts = [];
+  if (kind) parts.push({ type: "text", text: EVENT_LABELS[kind] ?? `Event: ${kind}` });
+  const thinking = asString(data.thinking_content);
+  if (thinking) parts.push({ type: "reasoning", text: thinking });
+  const text = asString(data.msg_content);
+  if (text) parts.push({ type: "text", text });
+  for (const value of Array.isArray(data.attachments) ? data.attachments : []) {
+    const part = attachmentPart(value);
+    if (part) parts.push(part);
+  }
+  const children = /* @__PURE__ */ new Set();
+  for (const value of Array.isArray(data.tool_calls) ? data.tool_calls : []) {
+    const part = toolPart2(value);
+    if (!part) continue;
+    parts.push(part);
+    if (part.tool === "task" || part.tool.startsWith("task_")) {
+      const metadata = asRecord(part.state.metadata);
+      const child = asString(metadata?.sub_session_id) ?? asString(metadata?.session_id);
+      if (child) children.add(child);
+    }
+  }
+  const error = asString(data.error);
+  if (error) parts.push({ type: "text", text: error });
+  const timestamp = asNumber(row.created_at_ms) ?? asNumber(data.timestamp) ?? 0;
+  return {
+    id,
+    role,
+    agent: role === "assistant" ? agent : void 0,
+    time_created: timestamp,
+    time_completed: data.finish_reason ? timestamp : void 0,
+    mode: kind,
+    automated: role === "user" && (Boolean(kind) || AUTOMATED_SOURCES.has(String(row.source))) ? true : void 0,
+    subagent_id: children.size === 1 ? children.values().next().value : void 0,
+    parts
+  };
+}
+function tokenCount2(value) {
+  return Math.max(0, asNumber(value) ?? 0);
+}
+function miniMaxUsage(row) {
+  const model = asString(row.model) || void 0;
+  const tokens = {
+    input: tokenCount2(row.input_tokens),
+    output: tokenCount2(row.output_tokens),
+    reasoning: tokenCount2(row.reasoning_tokens),
+    cache_read: tokenCount2(row.cache_read_tokens),
+    cache_create: tokenCount2(row.cache_write_tokens)
+  };
+  const recorded = asNumber(row.cost_usd);
+  const cost = recorded !== void 0 && recorded >= 0 ? recorded : estimateTokenCost(model, tokens);
+  return {
+    turnId: asString(row.turn_id),
+    model,
+    time: tokenCount2(row.ts),
+    tokens,
+    total: Object.values(tokens).reduce((sum, value) => sum + value, 0),
+    cost: cost ?? 0,
+    costSource: recorded !== void 0 && recorded >= 0 ? "recorded" : cost !== null ? "estimated" : void 0
+  };
+}
+function attachMiniMaxUsage(message, usages) {
+  const models = new Set(usages.map((usage) => usage.model));
+  if (models.size !== 1) return;
+  message.model = usages[0]?.model;
+  message.tokens = {};
+  message.cost = 0;
+  for (const usage of usages) {
+    for (const key of ["input", "output", "reasoning", "cache_read", "cache_create"]) {
+      message.tokens[key] = (message.tokens[key] ?? 0) + (usage.tokens[key] ?? 0);
+    }
+    message.cost += usage.cost;
+    if (usage.costSource === "estimated" || !message.cost_source)
+      message.cost_source = usage.costSource;
+  }
+}
+var AGENT_METADATA13 = getAgentCatalogEntry("minimax-code");
+var DATABASE_PATH = join17("v2", "sqlite", "runtime-state.sqlite");
+var SESSION_FILTER = "(s.visibility <> 'hidden' OR s.parent_session_id IS NOT NULL) AND s.session_kind NOT IN ('peek', 'cron', 'channel')";
+function dataRoots() {
+  const configured = readEnvPath("MINIMAX_DATA_DIR") ?? readEnvPath("MAVIS_DATA_DIR");
+  return configured ? [configured] : [join17(homedir6(), ".minimax"), join17(homedir6(), ".minimax-code")];
+}
+function resolveMiniMaxCodeDataRoot() {
+  const roots = dataRoots();
+  return roots.find((root) => firstExisting(join17(root, DATABASE_PATH))) ?? roots[0];
+}
+var MiniMaxCodeAgent = class extends DatabaseSessionSource {
+  name = AGENT_METADATA13.name;
+  displayName = AGENT_METADATA13.displayName;
+  roots;
+  constructor(options = {}) {
+    super();
+    this.roots = options.sourceRoot ? [options.sourceRoot] : dataRoots();
+  }
+  getDatabasePath() {
+    return firstExisting(...this.roots.map((root) => join17(root, DATABASE_PATH)));
+  }
+  isAvailable() {
+    return isSqliteAvailable() && this.getDatabasePath() !== null;
+  }
+  getSessionWatchPlan() {
+    return {
+      status: "supported",
+      targets: this.roots.flatMap(
+        (root) => ["", "-wal", "-journal"].map((suffix) => ({
+          path: `${join17(root, DATABASE_PATH)}${suffix}`,
+          pollForChanges: true
+        }))
+      )
+    };
+  }
+  readDatabase(read) {
+    const path = this.getDatabasePath();
+    if (!path) throw new Error("MiniMax Code runtime-state.sqlite is missing");
+    return this.scanStep("reading MiniMax Code 0.4.12 sessions", path, () => {
+      const db = openDbReadOnly(path);
+      if (!db) throw new Error("Cannot open MiniMax Code database");
+      try {
+        return db.transaction(() => read(db))();
+      } finally {
+        db.close();
+      }
+    });
+  }
+  scan(options) {
+    if (!this.getDatabasePath()) return [];
+    return this.readDatabase((db) => {
+      const projections = this.readProjections(db);
+      const selected = /* @__PURE__ */ new Set();
+      const children = /* @__PURE__ */ new Map();
+      for (const [id, { head }] of projections) {
+        const parent = head.parent_reference?.sessionId;
+        if (parent && projections.has(parent)) {
+          const siblings = children.get(parent) ?? [];
+          siblings.push(id);
+          children.set(parent, siblings);
+        } else if (matchesScanWindow(head.time_updated ?? head.time_created, options)) {
+          selected.add(id);
+        }
+      }
+      if (options?.includeRelatedSessions !== false) {
+        for (const id of selected) {
+          for (const child of children.get(id) ?? []) selected.add(child);
+        }
+      }
+      const sessions = [];
+      for (const id of selected) {
+        const projection = projections.get(id);
+        if (!projection.head.stats.message_count) continue;
+        this.rememberSession(id, {
+          sourceFingerprint: projection.signature.digest("hex"),
+          headParserVersion: "minimax-code-v1",
+          unpricedModels: [...projection.unpricedModels]
+        });
+        sessions.push(projection.head);
+      }
+      sessions.sort(
+        (left, right) => (right.time_updated ?? 0) - (left.time_updated ?? 0) || left.reference.sessionId.localeCompare(right.reference.sessionId)
+      );
+      options?.onProgress?.({
+        total: selected.size,
+        processed: selected.size,
+        sessions: sessions.length
+      });
+      return sessions;
+    });
+  }
+  getSessionData(sessionId) {
+    return this.readDatabase((db) => {
+      const projection = this.readProjections(db, sessionId).get(sessionId);
+      if (!projection) throw new Error(`MiniMax Code session not found: ${sessionId}`);
+      for (const [turnId, usage] of projection.usageByTurn) {
+        const message = projection.lastAssistantByTurn.get(turnId);
+        if (message) attachMiniMaxUsage(message, usage);
+      }
+      return { ...projection.head, messages: projection.messages };
+    });
+  }
+  readProjections(db, sessionId) {
+    const filter = `${SESSION_FILTER}${sessionId ? " AND s.session_id = ?" : ""}`;
+    const bindings = sessionId ? [sessionId] : [];
+    const projections = /* @__PURE__ */ new Map();
+    const sessions = db.prepare(`
+      SELECT s.session_id, s.columnar_version, s.title, s.workspace_dir, s.parent_session_id,
+        s.created_at_ms, s.updated_at_ms, s.agent_name, s.status, s.archived, s.extra_data_json
+      FROM local_runtime_sessions s WHERE ${filter} ORDER BY s.session_id
+    `).iterate(...bindings);
+    for (const row of sessions) {
+      if (row.columnar_version !== 3)
+        throw new Error("Unsupported MiniMax session columnar version");
+      const id = String(row.session_id);
+      const parent = asString(row.parent_session_id);
+      projections.set(id, {
+        head: {
+          ...this.sessionIdentity(id),
+          title: asString(row.title) ?? "",
+          directory: asString(row.workspace_dir) ?? "",
+          parent_reference: parent && parent !== id ? { agentName: this.name, sessionId: parent } : void 0,
+          time_created: Number(row.created_at_ms ?? row.updated_at_ms),
+          time_updated: Number(row.updated_at_ms),
+          stats: { message_count: 0, total_input_tokens: 0, total_output_tokens: 0, total_cost: 0 }
+        },
+        agent: asString(row.agent_name) ?? this.displayName,
+        signature: createHash5("sha256").update(JSON.stringify(row)),
+        unpricedModels: /* @__PURE__ */ new Set(),
+        messages: [],
+        lastAssistantByTurn: /* @__PURE__ */ new Map(),
+        usageByTurn: /* @__PURE__ */ new Map()
+      });
+    }
+    const messages = db.prepare(`
+      SELECT m.id, m.session_id, m.msg_id, m.role, m.turn_id, m.source, m.created_at_ms, m.data_json
+      FROM local_runtime_message_rows m JOIN local_runtime_sessions s ON s.session_id = m.session_id
+      WHERE ${filter} ORDER BY m.session_id, m.id
+    `).iterate(...bindings);
+    for (const row of messages) {
+      const projection = projections.get(String(row.session_id));
+      projection.signature.update(JSON.stringify(row));
+      const message = miniMaxMessage(row, projection.agent);
+      projection.head.stats.message_count += 1;
+      projection.head.time_updated = Math.max(
+        projection.head.time_updated ?? 0,
+        message.time_created
+      );
+      if (message.role === "user" && !message.automated && !projection.firstUserText) {
+        projection.firstUserText = message.parts.find((part) => part.type === "text")?.text;
+      }
+      if (sessionId) {
+        projection.messages.push(message);
+        const turnId = asString(row.turn_id);
+        if (turnId && message.role === "assistant" && !message.mode)
+          projection.lastAssistantByTurn.set(turnId, message);
+      }
+    }
+    const usages = db.prepare(`
+      SELECT u.id, u.session_id, u.turn_id, u.model, u.ts, u.input_tokens, u.output_tokens,
+        u.reasoning_tokens, u.cache_read_tokens, u.cache_write_tokens, u.cost_usd
+      FROM local_runtime_token_usage u JOIN local_runtime_sessions s ON s.session_id = u.session_id
+      WHERE ${filter} ORDER BY u.session_id, u.id
+    `).iterate(...bindings);
+    for (const row of usages) {
+      const projection = projections.get(String(row.session_id));
+      projection.signature.update(JSON.stringify(row));
+      const { result: usage, unpricedModels } = capturePricingMisses(() => miniMaxUsage(row));
+      for (const model of unpricedModels) projection.unpricedModels.add(model);
+      const stats = projection.head.stats;
+      stats.total_input_tokens += usage.tokens.input ?? 0;
+      stats.total_output_tokens += usage.tokens.output ?? 0;
+      stats.total_tokens = (stats.total_tokens ?? 0) + usage.total;
+      stats.total_cache_read_tokens = (stats.total_cache_read_tokens ?? 0) + (usage.tokens.cache_read ?? 0);
+      stats.total_cache_create_tokens = (stats.total_cache_create_tokens ?? 0) + (usage.tokens.cache_create ?? 0);
+      stats.total_cost += usage.cost;
+      if (usage.costSource === "estimated" || !stats.cost_source)
+        stats.cost_source = usage.costSource;
+      if (usage.model) {
+        const modelUsage = projection.head.model_usage ??= /* @__PURE__ */ Object.create(null);
+        modelUsage[usage.model] = (modelUsage[usage.model] ?? 0) + usage.total;
+      }
+      projection.head.time_updated = Math.max(projection.head.time_updated ?? 0, usage.time);
+      if (sessionId && usage.turnId) {
+        const turnUsage = projection.usageByTurn.get(usage.turnId) ?? [];
+        turnUsage.push(usage);
+        projection.usageByTurn.set(usage.turnId, turnUsage);
+      }
+    }
+    for (const projection of projections.values()) {
+      projection.head.title = resolveSessionTitle(
+        projection.head.title,
+        projection.firstUserText ?? null,
+        null
+      );
+    }
+    return projections;
+  }
+};
 var RUNTIME_REGISTRATIONS = {
+  "minimax-code": {
+    create: () => new MiniMaxCodeAgent(),
+    resolveDataRoot: resolveMiniMaxCodeDataRoot
+  },
   claudecode: {
     create: () => new ClaudeCodeAgent(),
     resolveDataRoot: resolveClaudeCodeDataRoot
@@ -8345,6 +9370,14 @@ var RUNTIME_REGISTRATIONS = {
   dsh: {
     create: () => new DshAgent(),
     resolveDataRoot: resolveDshDataRoot
+  },
+  deepchat: {
+    create: () => new DeepChatAgent(),
+    resolveDataRoot: resolveDeepChatDataRoot
+  },
+  cherrystudio: {
+    create: () => new CherryStudioAgent(),
+    resolveDataRoot: resolveCherryStudioDataRoot
   }
 };
 var AGENT_REGISTRATIONS = Object.freeze(
@@ -8387,4 +9420,4 @@ export {
   createRegisteredAgents,
   getAgentInfoMap
 };
-//# sourceMappingURL=chunk-RBCCNCDO.js.map
+//# sourceMappingURL=chunk-WRVILHZR.js.map