codesesh 0.1.0

package/dist/chunk-H3D3GNQK.js

@@ -0,0 +1,3574 @@
+#!/usr/bin/env node
+
+// ../core/dist/index.mjs
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join2, basename as basename2 } from "path";
+import { existsSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+import { readFileSync } from "fs";
+import { basename } from "path";
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { join as join3 } from "path";
+import { createRequire } from "module";
+import { createHash } from "crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
+import { join as join4, basename as basename3, dirname } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
+import { join as join5, basename as basename4 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync5 } from "fs";
+import { join as join6, normalize } from "path";
+import { resolve, sep } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync, mkdirSync } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir2 } from "os";
+var registrations = [];
+function registerAgent(reg) {
+  registrations.push(reg);
+}
+function createRegisteredAgents() {
+  return registrations.map((r) => r.create());
+}
+function getRegisteredAgents() {
+  return registrations;
+}
+function getAgentInfoMap(sessionsByAgent) {
+  return registrations.map((r) => ({
+    name: r.name,
+    displayName: r.displayName,
+    icon: r.icon,
+    count: sessionsByAgent[r.name] ?? 0
+  }));
+}
+function getAgentByName(name) {
+  return registrations.find((r) => r.name === name);
+}
+var BaseAgent = class {
+  getUri(sessionId) {
+    return `${this.name}://${sessionId}`;
+  }
+};
+function envPath(name) {
+  const value = process.env[name];
+  if (!value) return null;
+  return value;
+}
+function firstExisting(...paths) {
+  for (const p of paths) {
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+function getDataHome() {
+  const xdg = envPath("XDG_DATA_HOME");
+  if (xdg) return xdg;
+  const p = platform();
+  if (p === "win32") {
+    return envPath("LOCALAPPDATA") ?? envPath("APPDATA") ?? join(homedir(), "AppData", "Local");
+  }
+  return join(homedir(), ".local", "share");
+}
+function resolveProviderRoots() {
+  const home = homedir();
+  return {
+    codexRoot: envPath("CODEX_HOME") ?? join(home, ".codex"),
+    claudeRoot: envPath("CLAUDE_CONFIG_DIR") ?? join(home, ".claude"),
+    kimiRoot: envPath("KIMI_SHARE_DIR") ?? join(home, ".kimi"),
+    opencodeRoot: join(getDataHome(), "opencode")
+  };
+}
+function getCursorDataPath() {
+  const override = envPath("CURSOR_DATA_PATH");
+  if (override) return override;
+  const p = platform();
+  if (p === "darwin") {
+    return firstExisting(join(homedir(), "Library", "Application Support", "Cursor", "User"));
+  }
+  if (p === "linux") {
+    const xdg = envPath("XDG_CONFIG_HOME") ?? join(homedir(), ".config");
+    return firstExisting(join(xdg, "Cursor", "User"));
+  }
+  if (p === "win32") {
+    const appData = envPath("APPDATA") ?? join(homedir(), "AppData", "Roaming");
+    return firstExisting(join(appData, "Cursor", "User"));
+  }
+  return null;
+}
+function* parseJsonlLines(content) {
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      yield JSON.parse(trimmed);
+    } catch {
+    }
+  }
+}
+function readJsonlFile(filePath) {
+  const content = readFileSync(filePath, "utf-8");
+  return parseJsonlLines(content);
+}
+var TITLE_MAX_LENGTH = 100;
+var UNTITLED_SESSION = "Untitled Session";
+function normalizeTitleText(text) {
+  const cleaned = text.replace(/\s+/g, " ").trim();
+  if (!cleaned) return null;
+  return cleaned.slice(0, TITLE_MAX_LENGTH);
+}
+function basenameTitle(path) {
+  if (!path) return null;
+  const normalized = path.trim().replace(/[/\\]+$/, "");
+  if (!normalized) return null;
+  const name = basename(normalized).trim();
+  return name || null;
+}
+function resolveSessionTitle(explicit, message, directory) {
+  for (const candidate of [explicit, message, directory]) {
+    if (candidate) {
+      const normalized = normalizeTitleText(candidate);
+      if (normalized) return normalized;
+    }
+  }
+  return UNTITLED_SESSION;
+}
+var PerfTracer = class {
+  rootMarkers = [];
+  activeStack = [];
+  enabled = false;
+  enable() {
+    this.enabled = true;
+  }
+  start(name) {
+    const marker = {
+      name,
+      startTime: performance.now(),
+      children: []
+    };
+    if (!this.enabled) return marker;
+    const parent = this.activeStack[this.activeStack.length - 1];
+    if (parent) {
+      marker.parent = parent;
+      parent.children.push(marker);
+    } else {
+      this.rootMarkers.push(marker);
+    }
+    this.activeStack.push(marker);
+    return marker;
+  }
+  end(marker) {
+    if (!this.enabled) return;
+    const target = marker ?? this.activeStack[this.activeStack.length - 1];
+    if (!target) return;
+    target.endTime = performance.now();
+    target.duration = target.endTime - target.startTime;
+    while (this.activeStack.length > 0) {
+      const popped = this.activeStack.pop();
+      if (popped === target) break;
+    }
+  }
+  measure(name, fn) {
+    const marker = this.start(name);
+    try {
+      return fn();
+    } finally {
+      this.end(marker);
+    }
+  }
+  async measureAsync(name, fn) {
+    const marker = this.start(name);
+    try {
+      return await fn();
+    } finally {
+      this.end(marker);
+    }
+  }
+  getReport() {
+    if (!this.enabled) return "Performance tracing disabled";
+    const lines = [];
+    lines.push("\n=== Performance Report ===\n");
+    for (const marker of this.rootMarkers) {
+      this.formatMarker(marker, 0, lines);
+    }
+    return lines.join("\n");
+  }
+  formatMarker(marker, depth, lines) {
+    const indent = "  ".repeat(depth);
+    const duration = marker.duration?.toFixed(2) ?? "?";
+    lines.push(`${indent}${marker.name}: ${duration}ms`);
+    for (const child of marker.children) {
+      this.formatMarker(child, depth + 1, lines);
+    }
+  }
+  reset() {
+    this.rootMarkers = [];
+    this.activeStack = [];
+  }
+};
+var perf = new PerfTracer();
+function parseTimestampMs(data) {
+  const raw = String(data["timestamp"] ?? "").trim();
+  if (!raw) return 0;
+  try {
+    return new Date(raw.includes("Z") ? raw : raw + "Z").getTime();
+  } catch {
+    return 0;
+  }
+}
+function normalizeTitleText2(text) {
+  const line = text.split("\n").find((l) => l.trim());
+  return line?.trim().slice(0, 80) || "";
+}
+var ClaudeCodeAgent = class extends BaseAgent {
+  name = "claudecode";
+  displayName = "Claude Code";
+  basePath = null;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  sessionsIndexCache = {};
+  sessionMetaMap = /* @__PURE__ */ new Map();
+  findBasePath() {
+    const roots = resolveProviderRoots();
+    return firstExisting(join2(roots.claudeRoot, "projects"), "data/claudecode");
+  }
+  isAvailable() {
+    this.basePath = this.findBasePath();
+    if (!this.basePath) return false;
+    try {
+      for (const entry of readdirSync(this.basePath)) {
+        const dir = join2(this.basePath, entry);
+        if (existsSync2(dir) && readdirSync(dir).some((f) => f.endsWith(".jsonl"))) {
+          return true;
+        }
+      }
+    } catch {
+    }
+    return false;
+  }
+  scan() {
+    if (!this.basePath) return [];
+    const scanMarker = perf.start("claudecode:scan");
+    const heads = [];
+    const listMarker = perf.start("listProjectDirs");
+    const projectDirs = this.listProjectDirs();
+    perf.end(listMarker);
+    for (const projectDir of projectDirs) {
+      const fileMarker = perf.start(`listJsonlFiles:${basename2(projectDir)}`);
+      const files = this.listJsonlFiles(projectDir);
+      perf.end(fileMarker);
+      for (const file of files) {
+        try {
+          const parseMarker = perf.start(`parseSessionHead:${basename2(file)}`);
+          const head = this.parseSessionHead(file, projectDir);
+          perf.end(parseMarker);
+          if (head) {
+            heads.push(head);
+            this.sessionMetaMap.set(head.id, {
+              id: head.id,
+              title: head.title,
+              sourcePath: file,
+              directory: head.directory,
+              model: head.stats.total_tokens ? "unknown" : void 0,
+              messageCount: head.stats.message_count,
+              createdAt: head.time_created,
+              updatedAt: head.time_updated ?? head.time_created
+            });
+          }
+        } catch {
+        }
+      }
+    }
+    perf.end(scanMarker);
+    return heads;
+  }
+  getSessionMetaMap() {
+    return this.sessionMetaMap;
+  }
+  setSessionMetaMap(meta) {
+    this.sessionMetaMap = meta;
+  }
+  getSessionData(sessionId) {
+    const meta = this.sessionMetaMap.get(sessionId);
+    if (!meta) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    if (!existsSync2(meta.sourcePath)) {
+      throw new Error(`Session file missing: ${meta.sourcePath}`);
+    }
+    const content = readFileSync2(meta.sourcePath, "utf-8");
+    const messages = [];
+    const pendingToolCalls = /* @__PURE__ */ new Map();
+    const ignoredToolCallIds = /* @__PURE__ */ new Set();
+    const assistantUuidToToolCalls = /* @__PURE__ */ new Map();
+    const assistantState = {
+      currentIndex: null,
+      latestTextIndex: null
+    };
+    let totalCost = 0;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    for (const record of parseJsonlLines(content)) {
+      try {
+        this.convertRecord(
+          record,
+          messages,
+          pendingToolCalls,
+          ignoredToolCallIds,
+          assistantUuidToToolCalls,
+          assistantState
+        );
+      } catch {
+      }
+    }
+    for (const msg of messages) {
+      totalCost += msg.cost ?? 0;
+      totalInputTokens += msg.tokens?.input ?? 0;
+      totalOutputTokens += msg.tokens?.output ?? 0;
+    }
+    return {
+      id: meta.id,
+      title: meta.title,
+      slug: `claudecode/${meta.id}`,
+      directory: meta.directory,
+      version: void 0,
+      time_created: meta.createdAt,
+      time_updated: meta.updatedAt,
+      stats: {
+        message_count: messages.length,
+        total_input_tokens: totalInputTokens,
+        total_output_tokens: totalOutputTokens,
+        total_cost: totalCost
+      },
+      messages
+    };
+  }
+  /**
+   * 检测文件系统变更
+   * 通过比较文件修改时间判断是否有新内容
+   */
+  checkForChanges(sinceTimestamp, cachedSessions) {
+    if (!this.basePath) {
+      return { hasChanges: false, timestamp: Date.now() };
+    }
+    const changedIds = [];
+    for (const session of cachedSessions) {
+      const meta = this.sessionMetaMap.get(session.id);
+      if (!meta) continue;
+      try {
+        const stat = statSync(meta.sourcePath);
+        if (stat.mtimeMs > sinceTimestamp) {
+          changedIds.push(session.id);
+        }
+      } catch {
+        changedIds.push(session.id);
+      }
+    }
+    try {
+      let totalFiles = 0;
+      for (const dir of this.listProjectDirs()) {
+        totalFiles += this.listJsonlFiles(dir).length;
+      }
+      const hasNewFiles = totalFiles > cachedSessions.length;
+      return {
+        hasChanges: changedIds.length > 0 || hasNewFiles,
+        changedIds,
+        timestamp: Date.now()
+      };
+    } catch {
+      return {
+        hasChanges: changedIds.length > 0,
+        changedIds,
+        timestamp: Date.now()
+      };
+    }
+  }
+  /**
+   * 增量扫描 - 只扫描变更的会话
+   */
+  incrementalScan(cachedSessions, changedIds) {
+    if (!this.basePath) return cachedSessions;
+    const sessionMap = new Map(cachedSessions.map((s) => [s.id, s]));
+    for (const projectDir of this.listProjectDirs()) {
+      for (const file of this.listJsonlFiles(projectDir)) {
+        try {
+          const sessionId = basename2(file, ".jsonl");
+          if (changedIds.includes(sessionId)) {
+            const head = this.parseSessionHead(file, projectDir);
+            if (head) {
+              sessionMap.set(head.id, head);
+              this.sessionMetaMap.set(head.id, {
+                id: head.id,
+                title: head.title,
+                sourcePath: file,
+                directory: head.directory,
+                model: head.stats.total_tokens ? "unknown" : void 0,
+                messageCount: head.stats.message_count,
+                createdAt: head.time_created,
+                updatedAt: head.time_updated ?? head.time_created
+              });
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    for (const projectDir of this.listProjectDirs()) {
+      for (const file of this.listJsonlFiles(projectDir)) {
+        try {
+          const sessionId = basename2(file, ".jsonl");
+          if (!sessionMap.has(sessionId)) {
+            const head = this.parseSessionHead(file, projectDir);
+            if (head) {
+              sessionMap.set(head.id, head);
+              this.sessionMetaMap.set(head.id, {
+                id: head.id,
+                title: head.title,
+                sourcePath: file,
+                directory: head.directory,
+                model: head.stats.total_tokens ? "unknown" : void 0,
+                messageCount: head.stats.message_count,
+                createdAt: head.time_created,
+                updatedAt: head.time_updated ?? head.time_created
+              });
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    return Array.from(sessionMap.values());
+  }
+  // --- Private helpers ---
+  listProjectDirs() {
+    if (!this.basePath) return [];
+    try {
+      return readdirSync(this.basePath).map((e) => join2(this.basePath, e)).filter((p) => existsSync2(p));
+    } catch {
+      return [];
+    }
+  }
+  listJsonlFiles(dir) {
+    try {
+      return readdirSync(dir).filter((f) => f.endsWith(".jsonl") && f !== "sessions-index.json").map((f) => join2(dir, f));
+    } catch {
+      return [];
+    }
+  }
+  loadSessionsIndex(projectDir) {
+    const cacheKey = basename2(projectDir);
+    if (cacheKey in this.sessionsIndexCache) {
+      return this.sessionsIndexCache[cacheKey];
+    }
+    const indexPath = join2(projectDir, "sessions-index.json");
+    const map = /* @__PURE__ */ new Map();
+    if (existsSync2(indexPath)) {
+      try {
+        const data = JSON.parse(readFileSync2(indexPath, "utf-8"));
+        const entries = data?.entries ?? [];
+        for (const entry of entries) {
+          const sid = entry?.sessionId;
+          if (typeof sid === "string") {
+            map.set(sid, entry);
+          }
+        }
+      } catch {
+      }
+    }
+    this.sessionsIndexCache[cacheKey] = map;
+    return map;
+  }
+  parseSessionHead(filePath, projectDir) {
+    const content = readFileSync2(filePath, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+    if (lines.length === 0) return null;
+    const sessionId = basename2(filePath, ".jsonl");
+    let firstRecord;
+    try {
+      firstRecord = JSON.parse(lines[0]);
+    } catch {
+      return null;
+    }
+    const createdAt = parseTimestampMs(firstRecord) || statSync(filePath).mtimeMs;
+    const index = this.loadSessionsIndex(projectDir);
+    const indexEntry = index.get(sessionId);
+    const explicitTitle = indexEntry?.summary ? String(indexEntry.summary) : null;
+    let updatedAt = createdAt;
+    let messageCount = 0;
+    let model = null;
+    let cwd = null;
+    for (const line of lines) {
+      try {
+        const data = JSON.parse(line);
+        const ts = parseTimestampMs(data);
+        if (ts > updatedAt) updatedAt = ts;
+        if (!cwd && data["cwd"] && typeof data["cwd"] === "string") {
+          cwd = data["cwd"];
+        }
+        const msg = data["message"];
+        if (msg && typeof msg === "object") {
+          const role = msg["role"];
+          if (typeof role === "string" && role.trim()) {
+            messageCount++;
+          }
+          if (!model) {
+            const m = msg["model"];
+            if (typeof m === "string" && m.trim()) model = m.trim();
+          }
+        }
+      } catch {
+      }
+    }
+    const directory = cwd ?? projectDir;
+    const messageTitle = this.extractTitle(lines);
+    const directoryTitle = basenameTitle(directory) || basenameTitle(projectDir);
+    const title = resolveSessionTitle(explicitTitle, messageTitle, directoryTitle);
+    return {
+      id: sessionId,
+      slug: `claudecode/${sessionId}`,
+      title,
+      directory,
+      time_created: createdAt,
+      time_updated: updatedAt,
+      stats: {
+        message_count: messageCount,
+        total_input_tokens: 0,
+        total_output_tokens: 0,
+        total_cost: 0
+      }
+    };
+  }
+  extractTitle(lines) {
+    for (const line of lines.slice(0, 20)) {
+      try {
+        const data = JSON.parse(line);
+        const msg = data["message"];
+        if (!msg || typeof msg !== "object") continue;
+        if (msg["role"] !== "user") continue;
+        const content = msg["content"];
+        if (!content) continue;
+        if (typeof content === "string") {
+          return normalizeTitleText2(content);
+        }
+        if (Array.isArray(content)) {
+          const texts = content.filter((item) => typeof item === "object" && item !== null && "text" in item).map((item) => String(item["text"] ?? "")).join(" ");
+          return normalizeTitleText2(texts);
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  // --- Record conversion ---
+  convertRecord(data, messages, pendingToolCalls, ignoredToolCallIds, assistantUuidToToolCalls, assistantState) {
+    if (data["isMeta"] === true) return;
+    const msgType = String(data["type"] ?? "");
+    if (msgType === "assistant") {
+      this.convertAssistantRecord(
+        data,
+        messages,
+        pendingToolCalls,
+        ignoredToolCallIds,
+        assistantUuidToToolCalls,
+        assistantState
+      );
+    } else if (msgType === "user") {
+      this.convertUserRecord(
+        data,
+        messages,
+        pendingToolCalls,
+        ignoredToolCallIds,
+        assistantUuidToToolCalls,
+        assistantState
+      );
+    } else if (msgType === "tool_result") {
+      this.convertToolResultRecord(data, messages, assistantState);
+    }
+  }
+  convertAssistantRecord(data, messages, pendingToolCalls, ignoredToolCallIds, assistantUuidToToolCalls, assistantState) {
+    const msg = data["message"] ?? {};
+    const timestampMs = parseTimestampMs(data);
+    const rawContent = msg["content"] ?? [];
+    const uuid = String(data["uuid"] ?? "");
+    const toolCallIds = [];
+    let currentAssistantIndex = assistantState.currentIndex;
+    let latestAssistantTextIndex = assistantState.latestTextIndex;
+    if (Array.isArray(rawContent)) {
+      for (const item of rawContent) {
+        if (!item || typeof item !== "object") continue;
+        const part = item;
+        const partType = String(part["type"] ?? "");
+        if (partType === "thinking") {
+          const text = String(part["thinking"] ?? "");
+          if (text.trim()) {
+            currentAssistantIndex = this.appendAssistantReasoning(
+              messages,
+              { messageId: uuid, msg, timestampMs, text },
+              currentAssistantIndex
+            );
+          }
+          continue;
+        }
+        if (partType === "text") {
+          const text = String(part["text"] ?? "");
+          if (text.trim()) {
+            currentAssistantIndex = this.appendAssistantText(
+              messages,
+              { messageId: uuid, msg, timestampMs, text },
+              currentAssistantIndex
+            );
+            latestAssistantTextIndex = currentAssistantIndex;
+          }
+          continue;
+        }
+        if (partType !== "tool_use") continue;
+        const toolName = String(part["name"] ?? "").trim();
+        const toolCallId = String(part["id"] ?? "").trim();
+        if (toolName && toolCallId && this.shouldIgnoreTool(toolName)) {
+          ignoredToolCallIds.add(toolCallId);
+          continue;
+        }
+        const toolPart = this.buildToolPart(part, timestampMs);
+        const [msgIndex, partIndex] = this.attachToolCallToLatestAssistant(messages, {
+          messageId: uuid,
+          msg,
+          timestampMs,
+          toolPart,
+          latestTextIndex: latestAssistantTextIndex
+        });
+        currentAssistantIndex = msgIndex;
+        if (toolCallId) {
+          pendingToolCalls.set(toolCallId, [msgIndex, partIndex]);
+          toolCallIds.push(toolCallId);
+        }
+      }
+    }
+    if (toolCallIds.length > 0) {
+      assistantUuidToToolCalls.set(uuid, toolCallIds);
+    }
+    assistantState.currentIndex = currentAssistantIndex;
+    assistantState.latestTextIndex = latestAssistantTextIndex;
+  }
+  convertUserRecord(data, messages, pendingToolCalls, ignoredToolCallIds, assistantUuidToToolCalls, assistantState) {
+    const msg = data["message"] ?? {};
+    const timestampMs = parseTimestampMs(data);
+    const content = msg["content"] ?? "";
+    const uuid = String(data["uuid"] ?? "");
+    if (typeof content === "string") {
+      const parts = this.normalizeUserTextParts(content, timestampMs);
+      if (parts.length === 0) {
+        assistantState.currentIndex = null;
+        assistantState.latestTextIndex = null;
+        return;
+      }
+      messages.push(this.buildMessage({ messageId: uuid, role: "user", timestampMs, parts }));
+      assistantState.currentIndex = null;
+      assistantState.latestTextIndex = null;
+      return;
+    }
+    if (!Array.isArray(content)) {
+      assistantState.currentIndex = null;
+      assistantState.latestTextIndex = null;
+      return;
+    }
+    const visibleParts = this.normalizeUserTextParts(content, timestampMs);
+    const toolStateUpdates = this.extractToolStateUpdates(data["toolUseResult"]);
+    for (const item of content) {
+      if (!item || typeof item !== "object") continue;
+      const ci = item;
+      if (ci["type"] !== "tool_result") continue;
+      const toolCallId = this.resolveToolCallId(data, ci, assistantUuidToToolCalls);
+      if (toolCallId && ignoredToolCallIds.has(toolCallId)) continue;
+      const outputParts = this.normalizeClaudeToolOutput(ci["content"], timestampMs);
+      if (this.backfillToolOutput(
+        messages,
+        pendingToolCalls,
+        toolCallId,
+        outputParts,
+        toolStateUpdates
+      )) {
+        continue;
+      }
+      const fallback = this.buildFallbackToolMessage({
+        messageId: uuid,
+        timestampMs,
+        toolCallId,
+        outputParts
+      });
+      if (fallback) messages.push(fallback);
+    }
+    if (visibleParts.length > 0) {
+      messages.push(
+        this.buildMessage({ messageId: uuid, role: "user", timestampMs, parts: visibleParts })
+      );
+    }
+    assistantState.currentIndex = null;
+    assistantState.latestTextIndex = null;
+  }
+  convertToolResultRecord(data, messages, assistantState) {
+    const timestampMs = parseTimestampMs(data);
+    const msg = data["message"] ?? {};
+    const outputParts = this.normalizeClaudeToolOutput(msg["content"], timestampMs);
+    const uuid = String(data["uuid"] ?? "");
+    const fallback = this.buildFallbackToolMessage({
+      messageId: uuid,
+      timestampMs,
+      toolCallId: null,
+      outputParts
+    });
+    if (fallback) messages.push(fallback);
+    assistantState.currentIndex = null;
+    assistantState.latestTextIndex = null;
+  }
+  // --- Message building ---
+  buildMessage(opts) {
+    return {
+      id: opts.messageId,
+      role: opts.role,
+      agent: opts.agent ?? null,
+      time_created: opts.timestampMs,
+      mode: opts.mode ?? null,
+      model: opts.model ?? null,
+      provider: opts.provider ?? null,
+      tokens: opts.tokens ? opts.tokens : void 0,
+      cost: opts.cost ?? 0,
+      parts: opts.parts
+    };
+  }
+  buildTextPart(text, timestampMs) {
+    return { type: "text", text, time_created: timestampMs };
+  }
+  buildReasoningPart(text, timestampMs) {
+    return { type: "reasoning", text, time_created: timestampMs };
+  }
+  buildToolPart(part, timestampMs) {
+    const toolName = String(part["name"] ?? "");
+    return {
+      type: "tool",
+      tool: toolName,
+      callID: String(part["id"] ?? ""),
+      title: `Tool: ${toolName}`,
+      state: {
+        input: part["input"] ?? {},
+        output: null
+      },
+      time_created: timestampMs
+    };
+  }
+  applyAssistantMetadata(message, msg) {
+    const model = msg["model"];
+    if (model && typeof model === "string" && !message.model) {
+      message.model = model;
+    }
+    const usage = msg["usage"];
+    if (usage && typeof usage === "object" && !message.tokens) {
+      const u = usage;
+      message.tokens = {
+        input: (u["input_tokens"] ?? 0) + (u["cache_creation_input_tokens"] ?? 0) + (u["cache_read_input_tokens"] ?? 0),
+        output: u["output_tokens"] ?? 0
+      };
+    }
+  }
+  // --- Assistant message grouping ---
+  appendAssistantReasoning(messages, opts, currentIndex) {
+    const part = this.buildReasoningPart(opts.text, opts.timestampMs);
+    if (currentIndex !== null) {
+      const message2 = messages[currentIndex];
+      const hasText = message2.parts.some((p) => p.type === "text");
+      const hasTool = message2.parts.some((p) => p.type === "tool");
+      if (!hasText && !hasTool) {
+        this.appendPartIfNew(message2, part);
+        this.applyAssistantMetadata(message2, opts.msg);
+        return currentIndex;
+      }
+    }
+    const message = this.buildMessage({
+      messageId: opts.messageId,
+      role: "assistant",
+      timestampMs: opts.timestampMs,
+      parts: [part],
+      agent: "claude"
+    });
+    this.applyAssistantMetadata(message, opts.msg);
+    messages.push(message);
+    return messages.length - 1;
+  }
+  appendAssistantText(messages, opts, currentIndex) {
+    const part = this.buildTextPart(opts.text, opts.timestampMs);
+    if (currentIndex !== null) {
+      const message2 = messages[currentIndex];
+      const hasTool = message2.parts.some((p) => p.type === "tool");
+      if (!hasTool) {
+        this.appendPartIfNew(message2, part);
+        this.applyAssistantMetadata(message2, opts.msg);
+        return currentIndex;
+      }
+    }
+    const message = this.buildMessage({
+      messageId: opts.messageId,
+      role: "assistant",
+      timestampMs: opts.timestampMs,
+      parts: [part],
+      agent: "claude"
+    });
+    this.applyAssistantMetadata(message, opts.msg);
+    messages.push(message);
+    return messages.length - 1;
+  }
+  attachToolCallToLatestAssistant(messages, opts) {
+    if (opts.latestTextIndex !== null) {
+      const message2 = messages[opts.latestTextIndex];
+      message2.parts.push(opts.toolPart);
+      this.applyAssistantMetadata(message2, opts.msg);
+      return [opts.latestTextIndex, message2.parts.length - 1];
+    }
+    const message = this.buildMessage({
+      messageId: opts.messageId,
+      role: "assistant",
+      timestampMs: opts.timestampMs,
+      parts: [opts.toolPart],
+      agent: "claude",
+      mode: "tool"
+    });
+    this.applyAssistantMetadata(message, opts.msg);
+    messages.push(message);
+    return [messages.length - 1, 0];
+  }
+  // --- User content normalization ---
+  normalizeUserTextParts(content, timestampMs) {
+    if (typeof content === "string") {
+      return content.trim() ? [this.buildTextPart(content, timestampMs)] : [];
+    }
+    if (!Array.isArray(content)) return [];
+    const parts = [];
+    for (const item of content) {
+      if (typeof item === "object" && item !== null) {
+        const ci = item;
+        if (ci["type"] === "tool_result") continue;
+        const text = String(ci["text"] ?? "");
+        if (text.trim()) parts.push(this.buildTextPart(text, timestampMs));
+      } else if (typeof item === "string" && item.trim()) {
+        parts.push(this.buildTextPart(item, timestampMs));
+      }
+    }
+    return parts;
+  }
+  normalizeClaudeToolOutput(content, timestampMs) {
+    if (typeof content === "string") {
+      return content.trim() ? [this.buildTextPart(content, timestampMs)] : [];
+    }
+    if (content === null || content === void 0) return [];
+    if (Array.isArray(content)) {
+      const parts = [];
+      for (const item of content) {
+        if (typeof item === "object" && item !== null) {
+          const text2 = String(
+            item["text"] ?? item["content"] ?? ""
+          );
+          if (text2.trim()) parts.push(this.buildTextPart(text2, timestampMs));
+        } else if (typeof item === "string" && item.trim()) {
+          parts.push(this.buildTextPart(item, timestampMs));
+        }
+      }
+      return parts;
+    }
+    const text = String(content);
+    return text.trim() ? [this.buildTextPart(text, timestampMs)] : [];
+  }
+  // --- Tool backfill ---
+  backfillToolOutput(messages, pendingToolCalls, callId, outputParts, stateUpdates) {
+    if (!callId) return false;
+    const location = pendingToolCalls.get(callId);
+    if (location === void 0) return false;
+    const [msgIndex, partIndex] = location;
+    const state = messages[msgIndex].parts[partIndex].state ?? (messages[msgIndex].parts[partIndex].state = {});
+    if (outputParts.length > 0) {
+      const existing = state.output;
+      if (Array.isArray(existing)) {
+        existing.push(...outputParts);
+      } else if (existing === null || existing === void 0) {
+        state.output = [...outputParts];
+      } else {
+        state.output = [existing, ...outputParts];
+      }
+    }
+    if (stateUpdates) {
+      Object.assign(state, stateUpdates);
+    }
+    if (outputParts.length > 0 && !state.status) {
+      state.status = "completed";
+    }
+    return outputParts.length > 0 || !!stateUpdates;
+  }
+  resolveToolCallId(data, item, assistantUuidToToolCalls) {
+    const directId = String(item["tool_use_id"] ?? "").trim();
+    if (directId) return directId;
+    const sourceUuid = String(data["sourceToolAssistantUUID"] ?? "").trim();
+    if (!sourceUuid) return "";
+    const ids = assistantUuidToToolCalls.get(sourceUuid);
+    if (ids && ids.length === 1) return ids[0];
+    return "";
+  }
+  extractToolStateUpdates(toolUseResult) {
+    if (!toolUseResult || typeof toolUseResult !== "object") return {};
+    const result = toolUseResult;
+    const updates = {};
+    const success = result["success"];
+    if (typeof success === "boolean") {
+      updates["status"] = success ? "success" : "error";
+    }
+    const commandName = result["commandName"];
+    if (commandName) {
+      updates["meta"] = { commandName };
+    }
+    return updates;
+  }
+  // --- Fallback ---
+  buildFallbackToolMessage(opts) {
+    if (opts.outputParts.length === 0) return null;
+    return this.buildMessage({
+      messageId: opts.messageId,
+      role: "tool",
+      timestampMs: opts.timestampMs,
+      parts: opts.outputParts
+    });
+  }
+  // --- Utilities ---
+  shouldIgnoreTool(toolName) {
+    return toolName === "TodoWrite";
+  }
+  appendPartIfNew(message, part) {
+    const parts = message.parts;
+    if (parts.length > 0 && parts[parts.length - 1].type === part.type) {
+      const tail = parts[parts.length - 1];
+      if (tail.text === part.text) return;
+    }
+    parts.push(part);
+  }
+};
+var DatabaseConstructor = null;
+try {
+  const require2 = createRequire(import.meta.url);
+  const mod = require2("better-sqlite3");
+  DatabaseConstructor = typeof mod === "function" ? mod : mod.default;
+} catch {
+}
+function openDbReadOnly(dbPath) {
+  if (!DatabaseConstructor) return null;
+  try {
+    const db = DatabaseConstructor(dbPath, { readonly: true });
+    return db;
+  } catch {
+    return null;
+  }
+}
+function isSqliteAvailable() {
+  return DatabaseConstructor !== null;
+}
+var OpenCodeAgent = class extends BaseAgent {
+  name = "opencode";
+  displayName = "OpenCode";
+  dbPath = null;
+  // Session metadata for caching
+  sessionMetaMap = /* @__PURE__ */ new Map();
+  findDbPath() {
+    if (!isSqliteAvailable()) return null;
+    const roots = resolveProviderRoots();
+    return firstExisting(join3(roots.opencodeRoot, "opencode.db"), "data/opencode/opencode.db");
+  }
+  isAvailable() {
+    this.dbPath = this.findDbPath();
+    return this.dbPath !== null;
+  }
+  scan() {
+    if (!this.dbPath) return [];
+    const db = openDbReadOnly(this.dbPath);
+    if (!db) return [];
+    try {
+      const cutoffTime = Date.now() - 3650 * 24 * 60 * 60 * 1e3;
+      const hasMessageTable = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'message'").get();
+      let rows;
+      if (hasMessageTable) {
+        rows = db.prepare(`
+          SELECT
+            s.id, s.title, s.time_created, s.time_updated, s.slug, s.directory,
+            s.version, s.summary_files,
+            (SELECT COUNT(*) FROM message m WHERE m.session_id = s.id) AS message_count,
+            (SELECT m.data FROM message m
+             WHERE m.session_id = s.id AND m.data LIKE '%"modelID"%'
+             ORDER BY m.time_created DESC LIMIT 1) AS model_message_data
+          FROM session s
+          WHERE s.time_created >= ?
+          ORDER BY s.time_created DESC
+        `).all(cutoffTime);
+      } else {
+        rows = db.prepare(`
+          SELECT s.id, s.title, s.time_created, s.time_updated, s.slug, s.directory,
+            s.version, s.summary_files, 0 AS message_count, NULL AS model_message_data
+          FROM session s
+          WHERE s.time_created >= ?
+          ORDER BY s.time_created DESC
+        `).all(cutoffTime);
+      }
+      const heads = [];
+      for (const row of rows) {
+        const id = String(row.id ?? "");
+        const title = String(row.title ?? "").trim() || "Untitled";
+        const timeCreated = Number(row.time_created ?? 0);
+        const timeUpdated = Number(row.time_updated ?? timeCreated);
+        const slug = `opencode/${id}`;
+        const directory = String(row.directory ?? "");
+        heads.push({
+          id,
+          slug,
+          title,
+          directory,
+          time_created: timeCreated,
+          time_updated: timeUpdated,
+          stats: {
+            message_count: Number(row.message_count ?? 0),
+            total_input_tokens: 0,
+            total_output_tokens: 0,
+            total_cost: 0
+          }
+        });
+        if (this.dbPath) {
+          this.sessionMetaMap.set(id, {
+            id,
+            sourcePath: this.dbPath
+          });
+        }
+      }
+      return heads;
+    } catch {
+      return [];
+    } finally {
+      db.close();
+    }
+  }
+  getSessionMetaMap() {
+    return this.sessionMetaMap;
+  }
+  setSessionMetaMap(meta) {
+    this.sessionMetaMap = meta;
+  }
+  /**
+   * 检测数据库变更
+   * 对于 SQLite，检测数据库文件修改时间
+   */
+  checkForChanges(sinceTimestamp, cachedSessions) {
+    if (!this.dbPath) {
+      this.dbPath = this.findDbPath();
+    }
+    if (!this.dbPath || !existsSync3(this.dbPath)) {
+      return { hasChanges: false, timestamp: Date.now() };
+    }
+    try {
+      const stat = statSync2(this.dbPath);
+      const hasChanges = stat.mtimeMs > sinceTimestamp;
+      const changedIds = hasChanges ? cachedSessions.map((s) => s.id) : [];
+      return {
+        hasChanges,
+        changedIds,
+        timestamp: Date.now()
+      };
+    } catch {
+      return { hasChanges: false, timestamp: Date.now() };
+    }
+  }
+  /**
+   * 增量扫描 - 重新查询数据库
+   */
+  incrementalScan(_cachedSessions, _changedIds) {
+    return this.scan();
+  }
+  getSessionData(sessionId) {
+    if (!this.dbPath) {
+      this.dbPath = this.findDbPath();
+    }
+    if (!this.dbPath) {
+      throw new Error("OpenCode database is missing");
+    }
+    const db = openDbReadOnly(this.dbPath);
+    if (!db) {
+      throw new Error("OpenCode database is missing");
+    }
+    try {
+      const sessionRow = db.prepare("SELECT * FROM session WHERE id = ?").get(sessionId);
+      if (!sessionRow) {
+        throw new Error(`Session not found: ${sessionId}`);
+      }
+      const id = String(sessionRow.id ?? sessionId);
+      const title = String(sessionRow.title ?? "Untitled");
+      const slug = `opencode/${id}`;
+      const directory = String(sessionRow.directory ?? "");
+      const timeCreated = Number(sessionRow.time_created ?? 0);
+      const timeUpdated = Number(sessionRow.time_updated ?? timeCreated);
+      const messages = [];
+      let totalCost = 0;
+      let totalInputTokens = 0;
+      let totalOutputTokens = 0;
+      const msgRows = db.prepare("SELECT * FROM message WHERE session_id = ? ORDER BY time_created ASC").all(sessionId);
+      for (const msgRow of msgRows) {
+        const msgData = JSON.parse(String(msgRow.data ?? "{}"));
+        const parts = [];
+        const cost = Number(msgData.cost ?? 0);
+        const tokens = msgData.tokens;
+        const inputTokens = Number(tokens?.input ?? 0);
+        const outputTokens = Number(tokens?.output ?? 0);
+        totalCost += cost;
+        totalInputTokens += inputTokens;
+        totalOutputTokens += outputTokens;
+        const partRows = db.prepare("SELECT * FROM part WHERE message_id = ? ORDER BY time_created ASC").all(msgRow.id);
+        for (const partRow of partRows) {
+          const partData = JSON.parse(String(partRow.data ?? "{}"));
+          const partType = String(partData.type ?? "");
+          if (partType === "text" || partType === "reasoning") {
+            parts.push({
+              type: partType,
+              text: partData.text ?? "",
+              time_created: Number(partRow.time_created ?? 0)
+            });
+          } else if (partType === "tool") {
+            parts.push({
+              type: "tool",
+              tool: String(partData.tool ?? ""),
+              callID: String(partData.callID ?? ""),
+              title: String(partData.title ?? ""),
+              state: partData.state ?? {},
+              time_created: Number(partRow.time_created ?? 0)
+            });
+          }
+        }
+        messages.push({
+          id: String(msgRow.id ?? ""),
+          role: String(msgData.role ?? "assistant"),
+          agent: msgData.agent ?? null,
+          mode: msgData.mode ?? null,
+          model: msgData.modelID ?? null,
+          provider: msgData.providerID ?? null,
+          time_created: Number(msgRow.time_created ?? 0),
+          tokens: tokens ? { input: inputTokens, output: outputTokens } : void 0,
+          cost,
+          parts
+        });
+      }
+      return {
+        id,
+        title,
+        slug,
+        directory,
+        version: sessionRow.version ?? void 0,
+        time_created: timeCreated,
+        time_updated: timeUpdated,
+        summary_files: sessionRow.summary_files ?? void 0,
+        stats: {
+          message_count: messages.length,
+          total_input_tokens: totalInputTokens,
+          total_output_tokens: totalOutputTokens,
+          total_cost: totalCost
+        },
+        messages
+      };
+    } finally {
+      db.close();
+    }
+  }
+};
+var KIMI_TOOL_TITLE_MAP = {
+  ReadFile: "read",
+  Glob: "glob",
+  StrReplaceFile: "edit",
+  Grep: "grep",
+  WriteFile: "write",
+  Shell: "bash"
+};
+var KIMI_IGNORED_TOOLS = /* @__PURE__ */ new Set(["SetTodoList"]);
+function mapToolTitle(toolName) {
+  return KIMI_TOOL_TITLE_MAP[toolName] ?? toolName;
+}
+function normalizeToolArguments(raw) {
+  if (typeof raw === "string") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+function normalizeToolOutputParts(content, timestampMs) {
+  if (typeof content === "string") {
+    return content.trim() ? [{ type: "text", text: content, time_created: timestampMs }] : [];
+  }
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const item of content) {
+      if (typeof item === "object" && item !== null && "text" in item) {
+        const text2 = String(item.text ?? "");
+        if (text2.trim()) parts.push({ type: "text", text: text2, time_created: timestampMs });
+      } else if (typeof item === "string" && item.trim()) {
+        parts.push({ type: "text", text: item, time_created: timestampMs });
+      }
+    }
+    return parts;
+  }
+  if (content == null) return [];
+  const text = String(content);
+  return text.trim() ? [{ type: "text", text, time_created: timestampMs }] : [];
+}
+function normalizeWireToolOutputParts(returnValue, timestampMs) {
+  if (returnValue == null) return [];
+  if (typeof returnValue === "string") {
+    return returnValue.trim() ? [{ type: "text", text: returnValue, time_created: timestampMs }] : [];
+  }
+  if (typeof returnValue === "object") {
+    return [
+      { type: "text", text: JSON.stringify(returnValue, null, 2), time_created: timestampMs }
+    ];
+  }
+  const text = String(returnValue);
+  return text.trim() ? [{ type: "text", text, time_created: timestampMs }] : [];
+}
+var KimiAgent = class extends BaseAgent {
+  name = "kimi";
+  displayName = "Kimi-Cli";
+  basePath = null;
+  sessionMetaMap = /* @__PURE__ */ new Map();
+  projectMap = /* @__PURE__ */ new Map();
+  findBasePath() {
+    const roots = resolveProviderRoots();
+    return firstExisting(join4(roots.kimiRoot, "sessions"), "data/kimi");
+  }
+  /** Parse kimi.json and build md5(project_path) → cwd mapping */
+  loadKimiConfig() {
+    const roots = resolveProviderRoots();
+    const configPath = join4(roots.kimiRoot, "kimi.json");
+    if (!existsSync4(configPath)) return;
+    try {
+      const raw = JSON.parse(readFileSync3(configPath, "utf-8"));
+      const workDirs = raw?.work_dirs;
+      if (!Array.isArray(workDirs)) return;
+      for (const wd of workDirs) {
+        const path = wd.path;
+        if (typeof path !== "string") continue;
+        const hash = createHash("md5").update(path).digest("hex");
+        this.projectMap.set(hash, path);
+      }
+    } catch {
+    }
+  }
+  isAvailable() {
+    this.basePath = this.findBasePath();
+    if (!this.basePath) return false;
+    this.loadKimiConfig();
+    try {
+      return this.listSessionDirs().length > 0;
+    } catch {
+    }
+    return false;
+  }
+  /** Walk sessions/{project_hash}/{session_id}/ and find valid session dirs */
+  listSessionDirs() {
+    if (!this.basePath) return [];
+    const dirs = [];
+    try {
+      for (const hashEntry of readdirSync2(this.basePath, { withFileTypes: true })) {
+        if (!hashEntry.isDirectory()) continue;
+        const hashPath = join4(this.basePath, hashEntry.name);
+        try {
+          for (const sessionEntry of readdirSync2(hashPath, { withFileTypes: true })) {
+            if (!sessionEntry.isDirectory()) continue;
+            const sessionPath = join4(hashPath, sessionEntry.name);
+            if (existsSync4(join4(sessionPath, "metadata.json")) || existsSync4(join4(sessionPath, "state.json"))) {
+              dirs.push(sessionPath);
+            }
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return dirs;
+  }
+  /** Parse session directory, preferring state.json over metadata.json */
+  parseSessionDir(sessionDir) {
+    try {
+      const sessionId = basename3(sessionDir);
+      const projectHash = basename3(dirname(sessionDir));
+      const contextFile = join4(sessionDir, "context.jsonl");
+      const wireFile = join4(sessionDir, "wire.jsonl");
+      if (!existsSync4(contextFile) && !existsSync4(wireFile)) return null;
+      const statePath = join4(sessionDir, "state.json");
+      const metaPath = join4(sessionDir, "metadata.json");
+      let title = "";
+      let wireMtime = null;
+      let metaFile = "";
+      if (existsSync4(statePath)) {
+        const state = JSON.parse(readFileSync3(statePath, "utf-8"));
+        title = String(state.custom_title ?? "");
+        wireMtime = typeof state.wire_mtime === "number" ? state.wire_mtime : null;
+        metaFile = statePath;
+      } else if (existsSync4(metaPath)) {
+        const meta = JSON.parse(readFileSync3(metaPath, "utf-8"));
+        title = String(meta.title ?? "");
+        wireMtime = typeof meta.wire_mtime === "number" ? meta.wire_mtime : null;
+        metaFile = metaPath;
+      }
+      const cwd = this.projectMap.get(projectHash) || "";
+      const createdAt = wireMtime !== null ? wireMtime * 1e3 : metaFile ? statSync3(metaFile).mtimeMs : statSync3(sessionDir).mtimeMs;
+      return {
+        id: sessionId,
+        title: title || "Untitled Session",
+        sourcePath: sessionDir,
+        cwd,
+        contextFile: existsSync4(contextFile) ? contextFile : null,
+        wireFile: existsSync4(wireFile) ? wireFile : null,
+        createdAt,
+        metaFile
+      };
+    } catch {
+      return null;
+    }
+  }
+  scan() {
+    if (!this.basePath) return [];
+    const scanMarker = perf.start("kimi:scan");
+    const listMarker = perf.start("listSessionDirs");
+    const sessionDirs = this.listSessionDirs();
+    perf.end(listMarker);
+    const heads = [];
+    for (const dir of sessionDirs) {
+      try {
+        const parseMarker = perf.start(`parseSessionDir:${basename3(dir)}`);
+        const meta = this.parseSessionDir(dir);
+        perf.end(parseMarker);
+        if (!meta) continue;
+        this.sessionMetaMap.set(meta.id, meta);
+        heads.push({
+          id: meta.id,
+          slug: `kimi/${meta.id}`,
+          title: meta.title,
+          directory: meta.cwd,
+          time_created: meta.createdAt,
+          time_updated: meta.createdAt,
+          stats: {
+            message_count: 0,
+            total_input_tokens: 0,
+            total_output_tokens: 0,
+            total_cost: 0
+          }
+        });
+      } catch {
+      }
+    }
+    perf.end(scanMarker);
+    return heads;
+  }
+  getSessionMetaMap() {
+    return this.sessionMetaMap;
+  }
+  setSessionMetaMap(meta) {
+    this.sessionMetaMap = meta;
+  }
+  /**
+   * 检测文件系统变更
+   */
+  checkForChanges(sinceTimestamp, cachedSessions) {
+    const changedIds = [];
+    for (const session of cachedSessions) {
+      const meta = this.sessionMetaMap.get(session.id);
+      if (!meta) continue;
+      try {
+        if (meta.metaFile) {
+          const stat = statSync3(meta.metaFile);
+          if (stat.mtimeMs > sinceTimestamp) {
+            changedIds.push(session.id);
+            continue;
+          }
+        }
+        const dataFile = meta.wireFile || meta.contextFile;
+        if (dataFile) {
+          const dataStat = statSync3(dataFile);
+          if (dataStat.mtimeMs > sinceTimestamp) {
+            changedIds.push(session.id);
+          }
+        }
+      } catch {
+        changedIds.push(session.id);
+      }
+    }
+    return {
+      hasChanges: changedIds.length > 0,
+      changedIds,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * 增量扫描
+   */
+  incrementalScan(cachedSessions, changedIds) {
+    const sessionMap = new Map(cachedSessions.map((s) => [s.id, s]));
+    for (const dir of this.listSessionDirs()) {
+      try {
+        const meta = this.parseSessionDir(dir);
+        if (!meta) continue;
+        if (changedIds.includes(meta.id)) {
+          this.sessionMetaMap.set(meta.id, meta);
+          sessionMap.set(meta.id, {
+            id: meta.id,
+            slug: `kimi/${meta.id}`,
+            title: meta.title,
+            directory: meta.cwd,
+            time_created: meta.createdAt,
+            time_updated: meta.createdAt,
+            stats: {
+              message_count: 0,
+              total_input_tokens: 0,
+              total_output_tokens: 0,
+              total_cost: 0
+            }
+          });
+        }
+      } catch {
+      }
+    }
+    return Array.from(sessionMap.values());
+  }
+  getSessionData(sessionId) {
+    const meta = this.sessionMetaMap.get(sessionId);
+    if (!meta) throw new Error(`Session not found: ${sessionId}`);
+    if (meta.contextFile) {
+      return this.getSessionDataFromContext(meta);
+    }
+    return this.getSessionDataFromWire(meta);
+  }
+  getSessionDataFromContext(meta) {
+    if (!meta.contextFile) throw new Error("context.jsonl is missing");
+    const content = readFileSync3(meta.contextFile, "utf-8");
+    const messages = [];
+    const pendingToolCalls = /* @__PURE__ */ new Map();
+    const ignoredToolCallIds = /* @__PURE__ */ new Set();
+    let seq = 0;
+    for (const record of parseJsonlLines(content)) {
+      seq++;
+      try {
+        const role = String(record.role ?? "");
+        if (role === "_checkpoint" || role === "_usage") continue;
+        if (role === "user") {
+          const text = String(record.content ?? "");
+          if (text.trim()) {
+            messages.push(
+              this.buildMessage({
+                messageId: `context-${seq}`,
+                role: "user",
+                timestampMs: 0,
+                parts: [{ type: "text", text, time_created: 0 }]
+              })
+            );
+          }
+          continue;
+        }
+        if (role === "assistant") {
+          const { message, toolIndexes } = this.buildContextAssistantMessage(
+            record,
+            seq,
+            ignoredToolCallIds
+          );
+          if (!message) continue;
+          const msgIndex = messages.length;
+          messages.push(message);
+          for (const [callId, partIndex] of toolIndexes) {
+            pendingToolCalls.set(callId, [msgIndex, partIndex]);
+          }
+          continue;
+        }
+        if (role === "tool") {
+          const callId = String(record.tool_call_id ?? "").trim();
+          if (callId && ignoredToolCallIds.has(callId)) continue;
+          const outputParts = normalizeToolOutputParts(record.content, 0);
+          if (callId && this.backfillToolOutput(messages, pendingToolCalls, callId, outputParts)) {
+            continue;
+          }
+          if (outputParts.length > 0) {
+            messages.push(
+              this.buildMessage({
+                messageId: `context-${seq}`,
+                role: "tool",
+                timestampMs: 0,
+                parts: outputParts
+              })
+            );
+          }
+        }
+      } catch {
+      }
+    }
+    const stats = this.extractStats(meta.sourcePath);
+    return this.buildSessionData(meta, messages, stats);
+  }
+  getSessionDataFromWire(meta) {
+    const wirePath = meta.wireFile ?? join4(meta.sourcePath, "wire.jsonl");
+    if (!existsSync4(wirePath)) throw new Error("wire.jsonl is missing");
+    const content = readFileSync3(wirePath, "utf-8");
+    const messages = [];
+    const pendingToolCalls = /* @__PURE__ */ new Map();
+    const ignoredToolCallIds = /* @__PURE__ */ new Set();
+    const openToolArgumentBuffer = /* @__PURE__ */ new Map();
+    let currentAssistantIndex = null;
+    let openToolCallId = null;
+    let seq = 0;
+    for (const record of parseJsonlLines(content)) {
+      seq++;
+      try {
+        const message = record.message ?? {};
+        const msgType = String(message.type ?? "");
+        const payload = message.payload ?? {};
+        const timestamp = Number(record.timestamp ?? 0);
+        const timestampMs = Number.isFinite(timestamp) ? Math.floor(timestamp * 1e3) : 0;
+        if (msgType === "TurnBegin") {
+          const userInput = payload.user_input;
+          if (Array.isArray(userInput) && userInput.length > 0) {
+            const text = String(userInput[0]?.text ?? "");
+            if (text.trim()) {
+              messages.push(
+                this.buildMessage({
+                  messageId: `wire-${seq}`,
+                  role: "user",
+                  timestampMs,
+                  parts: [{ type: "text", text, time_created: timestampMs }]
+                })
+              );
+            }
+          }
+          currentAssistantIndex = null;
+          openToolCallId = null;
+          continue;
+        }
+        if (msgType === "ContentPart") {
+          currentAssistantIndex = this.getOrCreateWireAssistant(
+            messages,
+            currentAssistantIndex,
+            `wire-${seq}`
+          );
+          const assistant = messages[currentAssistantIndex];
+          const partType = String(payload.type ?? "");
+          if (partType === "think") {
+            const text = String(payload.think ?? "");
+            if (text.trim()) {
+              assistant.parts.push({ type: "reasoning", text, time_created: timestampMs });
+            }
+          } else if (partType === "text") {
+            const text = String(payload.text ?? "");
+            if (text.trim()) {
+              assistant.parts.push({ type: "text", text, time_created: timestampMs });
+            }
+          }
+          continue;
+        }
+        if (msgType === "ToolCall") {
+          const function_ = payload.function;
+          const toolName = String(function_?.name ?? "").trim();
+          const callId = String(payload.id ?? "").trim();
+          if (toolName && callId && KIMI_IGNORED_TOOLS.has(toolName)) {
+            ignoredToolCallIds.add(callId);
+            openToolCallId = callId;
+            continue;
+          }
+          if (!function_ || !callId || !toolName) continue;
+          currentAssistantIndex = this.getOrCreateWireAssistant(
+            messages,
+            currentAssistantIndex,
+            `wire-${seq}`
+          );
+          const assistant = messages[currentAssistantIndex];
+          const rawArgs = function_.arguments;
+          const normalizedArgs = normalizeToolArguments(rawArgs);
+          const buffer = typeof rawArgs === "string" && typeof normalizedArgs !== "string" ? rawArgs : null;
+          const toolPart = {
+            type: "tool",
+            tool: toolName,
+            callID: callId,
+            title: mapToolTitle(toolName),
+            state: { arguments: normalizedArgs, output: null },
+            time_created: timestampMs
+          };
+          const partIndex = assistant.parts.length;
+          assistant.parts.push(toolPart);
+          assistant.mode = "tool";
+          pendingToolCalls.set(callId, [currentAssistantIndex, partIndex]);
+          openToolCallId = callId;
+          if (buffer !== null) {
+            openToolArgumentBuffer.set(callId, buffer);
+          }
+          continue;
+        }
+        if (msgType === "ToolCallPart") {
+          if (openToolCallId && ignoredToolCallIds.has(openToolCallId)) continue;
+          const argumentsPart = String(payload.arguments_part ?? "");
+          this.appendWireToolCallPart(
+            argumentsPart,
+            openToolCallId,
+            openToolArgumentBuffer,
+            messages,
+            pendingToolCalls
+          );
+          continue;
+        }
+        if (msgType === "ToolResult") {
+          const callId = String(payload.tool_call_id ?? "").trim();
+          if (callId && ignoredToolCallIds.has(callId)) continue;
+          const outputParts = normalizeWireToolOutputParts(payload.return_value, timestampMs);
+          if (callId && this.backfillToolOutput(messages, pendingToolCalls, callId, outputParts)) {
+            continue;
+          }
+          if (outputParts.length > 0) {
+            messages.push(
+              this.buildMessage({
+                messageId: `wire-${seq}`,
+                role: "tool",
+                timestampMs,
+                parts: outputParts
+              })
+            );
+          }
+          continue;
+        }
+      } catch {
+      }
+    }
+    const filteredMessages = messages.filter((m) => m.parts.length > 0);
+    const stats = this.extractStats(meta.sourcePath);
+    return this.buildSessionData(meta, filteredMessages, stats);
+  }
+  // --- Helpers ---
+  buildMessage(opts) {
+    return {
+      id: opts.messageId,
+      role: opts.role,
+      agent: opts.agent ?? null,
+      time_created: opts.timestampMs,
+      mode: opts.mode ?? null,
+      model: opts.model ?? null,
+      provider: opts.provider ?? null,
+      tokens: opts.tokens ? opts.tokens : void 0,
+      cost: opts.cost ?? 0,
+      parts: opts.parts
+    };
+  }
+  buildContextAssistantMessage(record, seq, ignoredToolCallIds) {
+    const parts = [];
+    const toolIndexes = /* @__PURE__ */ new Map();
+    const content = record.content;
+    if (Array.isArray(content)) {
+      for (const item of content) {
+        if (typeof item !== "object" || item === null) continue;
+        const ci = item;
+        const partType = String(ci.type ?? "");
+        if (partType === "think") {
+          const text = String(ci.think ?? "");
+          if (text.trim()) parts.push({ type: "reasoning", text, time_created: 0 });
+        } else if (partType === "text") {
+          const text = String(ci.text ?? "");
+          if (text.trim()) parts.push({ type: "text", text, time_created: 0 });
+        }
+      }
+    }
+    const toolCalls = record.tool_calls;
+    if (Array.isArray(toolCalls)) {
+      for (const tc of toolCalls) {
+        if (typeof tc !== "object" || tc === null) continue;
+        const tcRecord = tc;
+        const function_ = tcRecord.function;
+        if (!function_) continue;
+        const toolName = String(function_.name ?? "").trim();
+        const callId = String(tcRecord.id ?? "").trim();
+        if (toolName && callId && KIMI_IGNORED_TOOLS.has(toolName)) {
+          ignoredToolCallIds.add(callId);
+          continue;
+        }
+        if (!toolName || !callId) continue;
+        const part = {
+          type: "tool",
+          tool: toolName,
+          callID: callId,
+          title: mapToolTitle(toolName),
+          state: { arguments: normalizeToolArguments(function_.arguments), output: null },
+          time_created: 0
+        };
+        toolIndexes.set(callId, parts.length);
+        parts.push(part);
+      }
+    }
+    if (parts.length === 0) {
+      return {
+        message: this.buildMessage({
+          messageId: `context-${seq}`,
+          role: "assistant",
+          timestampMs: 0,
+          parts: []
+        }),
+        toolIndexes
+      };
+    }
+    const allTools = parts.every((p) => p.type === "tool");
+    const message = this.buildMessage({
+      messageId: `context-${seq}`,
+      role: "assistant",
+      timestampMs: 0,
+      parts,
+      agent: "kimi",
+      mode: allTools ? "tool" : void 0
+    });
+    return { message, toolIndexes };
+  }
+  getOrCreateWireAssistant(messages, currentIndex, messageId) {
+    if (currentIndex !== null) return currentIndex;
+    messages.push(
+      this.buildMessage({
+        messageId,
+        role: "assistant",
+        timestampMs: 0,
+        parts: [],
+        agent: "kimi"
+      })
+    );
+    return messages.length - 1;
+  }
+  appendWireToolCallPart(argumentsPart, openCallId, buffer, messages, pendingToolCalls) {
+    if (!openCallId || !pendingToolCalls.has(openCallId)) return;
+    const existing = buffer.get(openCallId) ?? "";
+    const combined = existing + argumentsPart;
+    try {
+      const parsed = JSON.parse(combined);
+      const location = pendingToolCalls.get(openCallId);
+      if (!location) return;
+      const msgPart = messages[location[0]]?.parts[location[1]];
+      if (msgPart?.state) {
+        msgPart.state.arguments = parsed;
+      }
+      buffer.delete(openCallId);
+    } catch {
+      buffer.set(openCallId, combined);
+    }
+  }
+  backfillToolOutput(messages, pendingToolCalls, callId, outputParts) {
+    if (!outputParts.length || !callId) return false;
+    const location = pendingToolCalls.get(callId);
+    if (!location) return false;
+    const part = messages[location[0]]?.parts[location[1]];
+    if (!part) return false;
+    if (!part.state) part.state = {};
+    part.state.output = [...outputParts];
+    return true;
+  }
+  extractStats(sessionDir) {
+    const stats = {
+      total_cost: 0,
+      total_input_tokens: 0,
+      total_output_tokens: 0,
+      total_tokens: 0,
+      message_count: 0
+    };
+    const wirePath = join4(sessionDir, "wire.jsonl");
+    if (!existsSync4(wirePath)) return stats;
+    try {
+      const content = readFileSync3(wirePath, "utf-8");
+      for (const line of content.split("\n").filter((l) => l.trim())) {
+        try {
+          const data = JSON.parse(line);
+          const tokenUsage = data.message?.usage;
+          if (!tokenUsage) continue;
+          stats.total_input_tokens += Number(tokenUsage.input_tokens ?? 0);
+          stats.total_output_tokens += Number(tokenUsage.output_tokens ?? 0);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    const contextPath = join4(sessionDir, "context.jsonl");
+    const rawPath = existsSync4(contextPath) ? contextPath : wirePath;
+    if (!existsSync4(rawPath)) return stats;
+    try {
+      const rawContent = readFileSync3(rawPath, "utf-8");
+      for (const line of rawContent.split("\n").filter((l) => l.trim())) {
+        try {
+          const data = JSON.parse(line);
+          if (data.role === "_usage" && typeof data.token_count === "number") {
+            stats.total_tokens = data.token_count;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return stats;
+  }
+  buildSessionData(meta, messages, stats) {
+    stats.message_count = messages.length;
+    return {
+      id: meta.id,
+      title: meta.title,
+      slug: `kimi/${meta.id}`,
+      directory: meta.cwd,
+      time_created: meta.createdAt,
+      time_updated: meta.createdAt,
+      stats,
+      messages
+    };
+  }
+};
+var PROPOSED_PLAN_PATTERN = /<proposed_plan>\s*([\s\S]*?)\s*<\/proposed_plan>/;
+var PLAN_APPROVAL_PREFIX = "PLEASE IMPLEMENT THIS PLAN";
+var SUBAGENT_NOTIFICATION_PATTERN = /<subagent_notification>\s*([\s\S]*?)\s*<\/subagent_notification>/;
+var DEVELOPER_LIKE_USER_MARKERS = [
+  "agents.md instructions for",
+  "<instructions>",
+  "<environment_context>",
+  "<permissions instructions>",
+  "<collaboration_mode>"
+];
+function isDeveloperLikeUserMessage(text) {
+  const lower = text.toLowerCase();
+  return DEVELOPER_LIKE_USER_MARKERS.some((m) => lower.includes(m));
+}
+var CODEX_TOOL_TITLE_MAP = {
+  exec_command: "bash",
+  apply_patch: "patch",
+  patch: "patch",
+  spawn_agent: "subagent",
+  subagent: "subagent"
+};
+function extractSessionId(filename) {
+  const stem = basename4(filename, ".jsonl");
+  const parts = stem.split("-");
+  if (parts.length >= 5) {
+    return parts.slice(-5).join("-");
+  }
+  return stem;
+}
+function parseTimestampMs2(data) {
+  const ts = String(data["timestamp"] ?? "").trim();
+  if (!ts) return 0;
+  try {
+    return new Date(ts.includes("Z") ? ts : ts.replace(" ", "T") + "Z").getTime();
+  } catch {
+    return 0;
+  }
+}
+function normalizeTitleText3(text) {
+  const line = text.split("\n").find((l) => l.trim());
+  return line?.trim().slice(0, 80) || "";
+}
+function mapToolTitle2(name) {
+  return CODEX_TOOL_TITLE_MAP[name] ?? name;
+}
+function normalizeToolArguments2(raw) {
+  if (typeof raw === "string") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+function normalizeCustomToolArguments(toolName, input) {
+  if (toolName === "apply_patch") {
+    return parseApplyPatchInput(input);
+  }
+  return input;
+}
+var PATCH_BEGIN_RE = /\*\*\* Begin Patch/;
+var PATCH_END_RE = /\*\*\* End Patch/;
+var PATCH_HEADER_RE = /\*\*\*\s+(Add|Delete|Update|Move)\s+File:\s*(.+)/;
+var PATCH_MOVE_TO_RE = /\*\*\*\s+Move to:\s*(.+)/;
+function parseApplyPatchInput(input) {
+  const text = typeof input === "string" ? input : "";
+  if (!text) return [];
+  const blocks = [];
+  const lines = text.split("\n");
+  let inPatch = false;
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!inPatch && PATCH_BEGIN_RE.test(line)) {
+      inPatch = true;
+      i++;
+      continue;
+    }
+    if (inPatch && PATCH_END_RE.test(line)) {
+      inPatch = false;
+      i++;
+      continue;
+    }
+    if (inPatch) {
+      const headerMatch = line.match(PATCH_HEADER_RE);
+      if (headerMatch) {
+        const action = headerMatch[1];
+        const filePath = headerMatch[2].trim();
+        i++;
+        if (action === "Add") {
+          const content = extractPatchContent(lines, i);
+          i = content.nextLineIndex;
+          blocks.push({ type: "write_file", path: filePath, content: content.text });
+        } else if (action === "Update") {
+          let moveToTarget = null;
+          let contentStart = i;
+          for (let j = i; j < lines.length; j++) {
+            const l = lines[j];
+            if (!l.trim()) continue;
+            const moveMatch = l.match(PATCH_MOVE_TO_RE);
+            if (moveMatch) {
+              moveToTarget = moveMatch[1].trim();
+              contentStart = j + 1;
+              break;
+            }
+            break;
+          }
+          if (moveToTarget) {
+            const content = extractPatchContent(lines, contentStart);
+            i = content.nextLineIndex;
+            blocks.push({
+              type: "move_file",
+              path: filePath,
+              targetPath: moveToTarget,
+              content: content.text
+            });
+          } else {
+            const content = extractPatchContent(lines, i);
+            i = content.nextLineIndex;
+            blocks.push({ type: "edit_file", path: filePath, content: content.text });
+          }
+        } else if (action === "Delete") {
+          blocks.push({ type: "delete_file", path: filePath });
+        }
+        continue;
+      }
+    }
+    i++;
+  }
+  return blocks;
+}
+function extractPatchContent(lines, startIndex) {
+  const contentLines = [];
+  let i = startIndex;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (PATCH_HEADER_RE.test(line) || PATCH_END_RE.test(line)) break;
+    contentLines.push(line);
+    i++;
+  }
+  return { text: contentLines.join("\n"), nextLineIndex: i };
+}
+var CodexAgent = class extends BaseAgent {
+  name = "codex";
+  displayName = "Codex";
+  basePath = null;
+  sessionIndexCache = /* @__PURE__ */ new Map();
+  sessionMetaMap = /* @__PURE__ */ new Map();
+  // ---- BaseAgent implementation ----
+  findBasePath() {
+    const roots = resolveProviderRoots();
+    return firstExisting(join5(roots.codexRoot, "sessions"));
+  }
+  isAvailable() {
+    this.basePath = this.findBasePath();
+    if (!this.basePath) return false;
+    try {
+      const files = this.walkDirForRolloutFiles(this.basePath);
+      return files.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  scan() {
+    if (!this.basePath) return [];
+    const scanMarker = perf.start("codex:scan");
+    const indexMarker = perf.start("loadSessionIndex");
+    this.loadSessionIndex();
+    perf.end(indexMarker);
+    const heads = [];
+    const listMarker = perf.start("listRolloutFiles");
+    const files = this.listRolloutFiles();
+    perf.end(listMarker);
+    for (const file of files) {
+      try {
+        const parseMarker = perf.start(`parseSessionHead:${basename4(file)}`);
+        const head = this.parseSessionHead(file);
+        perf.end(parseMarker);
+        if (head) {
+          heads.push(head);
+          this.sessionMetaMap.set(head.id, {
+            id: head.id,
+            title: head.title,
+            sourcePath: file,
+            directory: head.directory,
+            model: null,
+            messageCount: head.stats.message_count,
+            createdAt: head.time_created,
+            updatedAt: head.time_updated ?? head.time_created
+          });
+        }
+      } catch {
+      }
+    }
+    perf.end(scanMarker);
+    return heads;
+  }
+  getSessionMetaMap() {
+    return this.sessionMetaMap;
+  }
+  setSessionMetaMap(meta) {
+    this.sessionMetaMap = meta;
+  }
+  /**
+   * 检测文件系统变更
+   */
+  checkForChanges(sinceTimestamp, cachedSessions) {
+    if (!this.basePath) {
+      return { hasChanges: false, timestamp: Date.now() };
+    }
+    const changedIds = [];
+    for (const session of cachedSessions) {
+      const meta = this.sessionMetaMap.get(session.id);
+      if (!meta) continue;
+      try {
+        const stat = statSync4(meta.sourcePath);
+        if (stat.mtimeMs > sinceTimestamp) {
+          changedIds.push(session.id);
+        }
+      } catch {
+        changedIds.push(session.id);
+      }
+    }
+    try {
+      const allFiles = this.listRolloutFiles();
+      const hasNewFiles = allFiles.length > cachedSessions.length;
+      return {
+        hasChanges: changedIds.length > 0 || hasNewFiles,
+        changedIds,
+        timestamp: Date.now()
+      };
+    } catch {
+      return {
+        hasChanges: changedIds.length > 0,
+        changedIds,
+        timestamp: Date.now()
+      };
+    }
+  }
+  /**
+   * 增量扫描
+   */
+  incrementalScan(cachedSessions, changedIds) {
+    if (!this.basePath) return cachedSessions;
+    const sessionMap = new Map(cachedSessions.map((s) => [s.id, s]));
+    for (const file of this.listRolloutFiles()) {
+      try {
+        const sessionId = extractSessionId(file);
+        if (changedIds.includes(sessionId)) {
+          const head = this.parseSessionHead(file);
+          if (head) {
+            sessionMap.set(head.id, head);
+            this.sessionMetaMap.set(head.id, {
+              id: head.id,
+              title: head.title,
+              sourcePath: file,
+              directory: head.directory,
+              model: null,
+              messageCount: head.stats.message_count,
+              createdAt: head.time_created,
+              updatedAt: head.time_updated ?? head.time_created
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    for (const file of this.listRolloutFiles()) {
+      try {
+        const sessionId = extractSessionId(file);
+        if (!sessionMap.has(sessionId)) {
+          const head = this.parseSessionHead(file);
+          if (head) {
+            sessionMap.set(head.id, head);
+            this.sessionMetaMap.set(head.id, {
+              id: head.id,
+              title: head.title,
+              sourcePath: file,
+              directory: head.directory,
+              model: null,
+              messageCount: head.stats.message_count,
+              createdAt: head.time_created,
+              updatedAt: head.time_updated ?? head.time_created
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    return Array.from(sessionMap.values());
+  }
+  getSessionData(sessionId) {
+    const meta = this.sessionMetaMap.get(sessionId);
+    if (!meta) throw new Error(`Session not found: ${sessionId}`);
+    if (!existsSync5(meta.sourcePath)) throw new Error(`Session file missing: ${meta.sourcePath}`);
+    const content = readFileSync4(meta.sourcePath, "utf-8");
+    const messages = [];
+    const pendingToolCalls = /* @__PURE__ */ new Map();
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let currentAssistantIndex = null;
+    let latestAssistantTextIndex = null;
+    let pendingPlan = null;
+    for (const record of parseJsonlLines(content)) {
+      try {
+        const result = this.convertRecord(
+          record,
+          messages,
+          pendingToolCalls,
+          meta.id,
+          currentAssistantIndex,
+          latestAssistantTextIndex,
+          pendingPlan
+        );
+        currentAssistantIndex = result.currentAssistantIndex;
+        latestAssistantTextIndex = result.latestAssistantTextIndex;
+        pendingPlan = result.pendingPlan;
+        this.extractTokenUsage(record, (input, output) => {
+          totalInputTokens += input;
+          totalOutputTokens += output;
+        });
+      } catch {
+      }
+    }
+    if (pendingPlan && currentAssistantIndex !== null) {
+      messages[currentAssistantIndex].parts.push(pendingPlan);
+    }
+    return {
+      id: meta.id,
+      title: meta.title,
+      slug: `codex/${meta.id}`,
+      directory: meta.directory,
+      time_created: meta.createdAt,
+      time_updated: meta.updatedAt,
+      stats: {
+        message_count: messages.length,
+        total_input_tokens: totalInputTokens,
+        total_output_tokens: totalOutputTokens,
+        total_cost: 0
+      },
+      messages
+    };
+  }
+  // ---- File listing ----
+  listRolloutFiles() {
+    if (!this.basePath) return [];
+    try {
+      return this.walkDirForRolloutFiles(this.basePath);
+    } catch {
+      return [];
+    }
+  }
+  walkDirForRolloutFiles(dir) {
+    const files = [];
+    try {
+      for (const entry of readdirSync3(dir)) {
+        const fullPath = join5(dir, entry);
+        const stat = statSync4(fullPath);
+        if (stat.isDirectory()) {
+          files.push(...this.walkDirForRolloutFiles(fullPath));
+        } else if (entry.endsWith(".jsonl") && entry.startsWith("rollout-")) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+    }
+    return files;
+  }
+  // ---- Session index ----
+  loadSessionIndex() {
+    if (this.sessionIndexCache.size > 0) return;
+    const roots = resolveProviderRoots();
+    const indexPath = join5(roots.codexRoot, "session_index.jsonl");
+    if (!existsSync5(indexPath)) return;
+    try {
+      const content = readFileSync4(indexPath, "utf-8");
+      for (const record of parseJsonlLines(content)) {
+        const sid = String(record["id"] ?? "").trim();
+        const threadName = String(record["thread_name"] ?? "").trim();
+        if (sid && threadName) {
+          this.sessionIndexCache.set(sid, threadName);
+        }
+      }
+    } catch {
+    }
+  }
+  getTitleForSession(sessionId) {
+    return this.sessionIndexCache.get(sessionId) ?? null;
+  }
+  // ---- Session head parsing ----
+  parseSessionHead(filePath) {
+    const content = readFileSync4(filePath, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+    if (lines.length === 0) return null;
+    const sessionId = extractSessionId(filePath);
+    let firstRecord;
+    try {
+      firstRecord = JSON.parse(lines[0]);
+    } catch {
+      return null;
+    }
+    const payload = firstRecord["payload"] ?? {};
+    const createdAt = parseTimestampMs2(payload) || statSync4(filePath).mtimeMs;
+    const indexTitle = this.getTitleForSession(sessionId);
+    const messageTitle = this.extractTitleFromLines(lines);
+    const directoryTitle = basenameTitle(payload["cwd"] ? String(payload["cwd"]) : null);
+    const title = resolveSessionTitle(indexTitle, messageTitle, directoryTitle);
+    let updatedAt = createdAt;
+    let messageCount = 0;
+    let model = null;
+    const COUNTED_TYPES = /* @__PURE__ */ new Set(["message", "function_call", "function_call_output"]);
+    for (const line of lines) {
+      try {
+        const data = JSON.parse(line);
+        const recordType = String(data["type"] ?? "");
+        if (recordType === "session_meta") {
+          const p = data["payload"] ?? {};
+          const ts = parseTimestampMs2(p);
+          if (ts > updatedAt) updatedAt = ts;
+          continue;
+        }
+        if (recordType === "response_item") {
+          const p = data["payload"] ?? {};
+          const pType = String(p["type"] ?? "");
+          if (COUNTED_TYPES.has(pType)) {
+            messageCount++;
+          }
+          if (!model) {
+            const info = p["info"];
+            const m = info?.["model"] ?? p["model"];
+            if (typeof m === "string" && m.trim()) model = m.trim();
+          }
+        }
+      } catch {
+      }
+    }
+    const directory = payload["cwd"] ? String(payload["cwd"]) : "";
+    return {
+      id: sessionId,
+      slug: `codex/${sessionId}`,
+      title,
+      directory,
+      time_created: createdAt,
+      time_updated: updatedAt,
+      stats: {
+        message_count: messageCount,
+        total_input_tokens: 0,
+        total_output_tokens: 0,
+        total_cost: 0
+      }
+    };
+  }
+  extractTitleFromLines(lines) {
+    let userMessageCount = 0;
+    for (const line of lines.slice(0, 20)) {
+      try {
+        const data = JSON.parse(line);
+        const recordType = String(data["type"] ?? "");
+        if (recordType !== "response_item") continue;
+        const payload = data["payload"] ?? {};
+        const pType = String(payload["type"] ?? "");
+        if (pType !== "message") continue;
+        if (String(payload["role"] ?? "") !== "user") continue;
+        userMessageCount++;
+        if (userMessageCount < 2) continue;
+        const content = payload["content"];
+        if (Array.isArray(content)) {
+          const texts = content.filter((item) => typeof item === "object" && item !== null && "text" in item).map((item) => String(item["text"] ?? "")).join(" ");
+          return normalizeTitleText3(texts);
+        }
+        if (typeof content === "string") {
+          return normalizeTitleText3(content);
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  // ---- Token usage extraction ----
+  extractTokenUsage(record, accumulate) {
+    const recordType = String(record["type"] ?? "");
+    if (recordType !== "response_item") return;
+    const payload = record["payload"] ?? {};
+    const info = payload["info"];
+    if (!info) return;
+    const totalUsage = info["total_token_usage"];
+    if (!totalUsage) return;
+    const inputTokens = Number(totalUsage["input_tokens"] ?? 0);
+    const outputTokens = Number(totalUsage["output_tokens"] ?? 0);
+    if (inputTokens || outputTokens) {
+      accumulate(inputTokens, outputTokens);
+    }
+  }
+  // ---- Record conversion ----
+  convertRecord(data, messages, pendingToolCalls, sessionId, currentAssistantIndex, latestAssistantTextIndex, pendingPlan) {
+    const recordType = String(data["type"] ?? "");
+    if (recordType === "session_meta" || recordType === "event_msg") {
+      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+    }
+    if (recordType !== "response_item") {
+      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+    }
+    const payload = data["payload"] ?? {};
+    const payloadType = String(payload["type"] ?? "");
+    const timestampMs = parseTimestampMs2(payload);
+    switch (payloadType) {
+      case "message": {
+        const role = String(payload["role"] ?? "");
+        if (role === "assistant") {
+          return this.convertAssistantMessage(
+            payload,
+            messages,
+            timestampMs,
+            currentAssistantIndex,
+            latestAssistantTextIndex,
+            pendingPlan
+          );
+        }
+        if (role === "user") {
+          return this.convertUserMessage(
+            payload,
+            messages,
+            timestampMs,
+            currentAssistantIndex,
+            latestAssistantTextIndex,
+            pendingPlan
+          );
+        }
+        break;
+      }
+      case "reasoning":
+        return this.convertReasoning(payload, messages, timestampMs, currentAssistantIndex);
+      case "function_call":
+        return this.convertFunctionCall(
+          payload,
+          messages,
+          pendingToolCalls,
+          timestampMs,
+          currentAssistantIndex,
+          latestAssistantTextIndex
+        );
+      case "function_call_output":
+        this.convertFunctionCallOutput(payload, messages, pendingToolCalls, timestampMs);
+        return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+      case "custom_tool_call":
+        return this.convertCustomToolCall(
+          payload,
+          messages,
+          pendingToolCalls,
+          timestampMs,
+          currentAssistantIndex,
+          latestAssistantTextIndex
+        );
+      case "custom_tool_call_output":
+        this.convertCustomToolCallOutput(payload, messages, pendingToolCalls, timestampMs);
+        return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+    }
+    return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+  }
+  // ---- Assistant message ----
+  convertAssistantMessage(payload, messages, timestampMs, currentAssistantIndex, latestAssistantTextIndex, pendingPlan) {
+    const content = payload["content"];
+    if (!Array.isArray(content)) {
+      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+    }
+    const textParts = [];
+    for (const item of content) {
+      if (typeof item !== "object" || item === null) continue;
+      const ci = item;
+      if (String(ci["type"] ?? "") === "output_text") {
+        const text = String(ci["text"] ?? "");
+        if (text.trim()) textParts.push(text);
+      }
+    }
+    if (textParts.length === 0) {
+      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+    }
+    const fullText = textParts.join("\n");
+    const planMatch = fullText.match(PROPOSED_PLAN_PATTERN);
+    if (planMatch) {
+      const planText = planMatch[1].trim();
+      const planPart = {
+        type: "plan",
+        text: planText,
+        approval_status: "success",
+        time_created: timestampMs
+      };
+      pendingPlan = planPart;
+    }
+    const displayText = fullText.replace(PROPOSED_PLAN_PATTERN, "").trim();
+    if (!displayText) {
+      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+    }
+    const textPart = { type: "text", text: displayText, time_created: timestampMs };
+    if (currentAssistantIndex !== null) {
+      const message = messages[currentAssistantIndex];
+      const hasTool = message.parts.some((p) => p.type === "tool");
+      if (!hasTool) {
+        message.parts.push(textPart);
+        latestAssistantTextIndex = currentAssistantIndex;
+        return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+      }
+    }
+    messages.push(
+      this.buildMessage({
+        messageId: "",
+        role: "assistant",
+        timestampMs,
+        parts: [textPart],
+        agent: "codex"
+      })
+    );
+    currentAssistantIndex = messages.length - 1;
+    latestAssistantTextIndex = currentAssistantIndex;
+    return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+  }
+  // ---- User message ----
+  convertUserMessage(payload, messages, timestampMs, currentAssistantIndex, latestAssistantTextIndex, pendingPlan) {
+    const content = payload["content"];
+    const text = Array.isArray(content) ? content.map(
+      (c) => typeof c === "object" && c !== null ? String(c["text"] ?? "") : String(c ?? "")
+    ).join(" ") : String(content ?? "");
+    if (!text.trim()) {
+      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+    }
+    if (isDeveloperLikeUserMessage(text)) {
+      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+    }
+    if (text.trimStart().startsWith(PLAN_APPROVAL_PREFIX)) {
+      if (pendingPlan && currentAssistantIndex !== null) {
+        messages[currentAssistantIndex].parts.push(pendingPlan);
+      }
+      pendingPlan = null;
+      messages.push(
+        this.buildMessage({
+          messageId: "",
+          role: "user",
+          timestampMs,
+          parts: [{ type: "text", text: text.trim(), time_created: timestampMs }]
+        })
+      );
+      currentAssistantIndex = null;
+      latestAssistantTextIndex = null;
+      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+    }
+    const subagentMatch = text.match(SUBAGENT_NOTIFICATION_PATTERN);
+    if (subagentMatch) {
+      try {
+        const notifPayload = JSON.parse(subagentMatch[1]);
+        const agentId = String(notifPayload["agent_id"] ?? "");
+        const nickname = String(notifPayload["nickname"] ?? "");
+        const completedText = String(notifPayload["completed"] ?? "");
+        const textPart = {
+          type: "text",
+          text: completedText || `Subagent ${nickname} completed`,
+          time_created: timestampMs
+        };
+        messages.push(
+          this.buildMessage({
+            messageId: "",
+            role: "assistant",
+            timestampMs,
+            parts: [textPart],
+            agent: "codex",
+            subagent_id: agentId || void 0,
+            nickname: nickname || void 0
+          })
+        );
+        currentAssistantIndex = null;
+        latestAssistantTextIndex = null;
+        return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+      } catch {
+      }
+    }
+    messages.push(
+      this.buildMessage({
+        messageId: "",
+        role: "user",
+        timestampMs,
+        parts: [{ type: "text", text: text.trim(), time_created: timestampMs }]
+      })
+    );
+    currentAssistantIndex = null;
+    latestAssistantTextIndex = null;
+    return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+  }
+  // ---- Reasoning ----
+  convertReasoning(payload, messages, timestampMs, currentAssistantIndex) {
+    const summary = payload["summary"];
+    if (!Array.isArray(summary)) {
+      return { currentAssistantIndex, latestAssistantTextIndex: null, pendingPlan: null };
+    }
+    const texts = [];
+    for (const item of summary) {
+      if (typeof item === "object" && item !== null) {
+        const ci = item;
+        if (String(ci["type"] ?? "") === "summary_text") {
+          const text = String(ci["text"] ?? "");
+          if (text.trim()) texts.push(text);
+        }
+      }
+    }
+    if (texts.length === 0) {
+      return { currentAssistantIndex, latestAssistantTextIndex: null, pendingPlan: null };
+    }
+    const reasoningText = texts.join("\n");
+    const part = { type: "reasoning", text: reasoningText, time_created: timestampMs };
+    if (currentAssistantIndex !== null) {
+      const message = messages[currentAssistantIndex];
+      const hasText = message.parts.some((p) => p.type === "text");
+      const hasTool = message.parts.some((p) => p.type === "tool");
+      if (!hasText && !hasTool) {
+        message.parts.push(part);
+        return { currentAssistantIndex, latestAssistantTextIndex: null, pendingPlan: null };
+      }
+    }
+    messages.push(
+      this.buildMessage({
+        messageId: "",
+        role: "assistant",
+        timestampMs,
+        parts: [part],
+        agent: "codex"
+      })
+    );
+    return {
+      currentAssistantIndex: messages.length - 1,
+      latestAssistantTextIndex: null,
+      pendingPlan: null
+    };
+  }
+  // ---- Function call ----
+  convertFunctionCall(payload, messages, pendingToolCalls, timestampMs, currentAssistantIndex, latestAssistantTextIndex) {
+    const callId = String(payload["call_id"] ?? "").trim();
+    const name = String(payload["name"] ?? "").trim();
+    if (!name) {
+      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan: null };
+    }
+    const mappedName = mapToolTitle2(name);
+    const arguments_ = normalizeToolArguments2(payload["arguments"]);
+    const toolPart = {
+      type: "tool",
+      tool: mappedName,
+      callID: callId,
+      title: `Tool: ${mappedName}`,
+      state: {
+        arguments: arguments_,
+        output: null
+      },
+      time_created: timestampMs
+    };
+    const targetIndex = latestAssistantTextIndex ?? currentAssistantIndex;
+    if (targetIndex !== null) {
+      const message = messages[targetIndex];
+      const partIndex = message.parts.length;
+      message.parts.push(toolPart);
+      message.mode = "tool";
+      if (callId) {
+        pendingToolCalls.set(callId, [targetIndex, partIndex]);
+      }
+      return {
+        currentAssistantIndex: targetIndex,
+        latestAssistantTextIndex: targetIndex,
+        pendingPlan: null
+      };
+    }
+    messages.push(
+      this.buildMessage({
+        messageId: "",
+        role: "assistant",
+        timestampMs,
+        parts: [toolPart],
+        agent: "codex",
+        mode: "tool"
+      })
+    );
+    const newIndex = messages.length - 1;
+    if (callId) {
+      pendingToolCalls.set(callId, [newIndex, 0]);
+    }
+    return { currentAssistantIndex: newIndex, latestAssistantTextIndex: null, pendingPlan: null };
+  }
+  // ---- Function call output ----
+  convertFunctionCallOutput(payload, messages, pendingToolCalls, timestampMs) {
+    const callId = String(payload["call_id"] ?? "").trim();
+    if (!callId) return;
+    const location = pendingToolCalls.get(callId);
+    if (!location) return;
+    const outputText = String(payload["output"] ?? "");
+    const outputParts = outputText.trim() ? [{ type: "text", text: outputText, time_created: timestampMs }] : [];
+    const [msgIndex, partIndex] = location;
+    const state = messages[msgIndex].parts[partIndex].state ?? (messages[msgIndex].parts[partIndex].state = {});
+    if (outputParts.length > 0) {
+      state.output = [...outputParts];
+      state.status = "completed";
+    }
+  }
+  // ---- Custom tool call ----
+  convertCustomToolCall(payload, messages, pendingToolCalls, timestampMs, currentAssistantIndex, latestAssistantTextIndex) {
+    const callId = String(payload["call_id"] ?? "").trim();
+    const name = String(payload["name"] ?? "").trim();
+    if (!name) {
+      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan: null };
+    }
+    const mappedName = mapToolTitle2(name);
+    const rawInput = payload["input"];
+    const normalizedInput = normalizeCustomToolArguments(name, rawInput);
+    const toolPart = {
+      type: "tool",
+      tool: mappedName,
+      callID: callId,
+      title: `Tool: ${mappedName}`,
+      state: {
+        arguments: normalizedInput,
+        output: null
+      },
+      time_created: timestampMs
+    };
+    const targetIndex = latestAssistantTextIndex ?? currentAssistantIndex;
+    if (targetIndex !== null) {
+      const message = messages[targetIndex];
+      const partIndex = message.parts.length;
+      message.parts.push(toolPart);
+      message.mode = "tool";
+      if (callId) {
+        pendingToolCalls.set(callId, [targetIndex, partIndex]);
+      }
+      return {
+        currentAssistantIndex: targetIndex,
+        latestAssistantTextIndex: targetIndex,
+        pendingPlan: null
+      };
+    }
+    messages.push(
+      this.buildMessage({
+        messageId: "",
+        role: "assistant",
+        timestampMs,
+        parts: [toolPart],
+        agent: "codex",
+        mode: "tool"
+      })
+    );
+    const newIndex = messages.length - 1;
+    if (callId) {
+      pendingToolCalls.set(callId, [newIndex, 0]);
+    }
+    return { currentAssistantIndex: newIndex, latestAssistantTextIndex: null, pendingPlan: null };
+  }
+  // ---- Custom tool call output ----
+  convertCustomToolCallOutput(payload, messages, pendingToolCalls, timestampMs) {
+    const callId = String(payload["call_id"] ?? "").trim();
+    if (!callId) return;
+    const location = pendingToolCalls.get(callId);
+    if (!location) return;
+    const outputText = String(payload["output"] ?? "");
+    const outputParts = outputText.trim() ? [{ type: "text", text: outputText, time_created: timestampMs }] : [];
+    const [msgIndex, partIndex] = location;
+    const state = messages[msgIndex].parts[partIndex].state ?? (messages[msgIndex].parts[partIndex].state = {});
+    if (outputParts.length > 0) {
+      state.output = [...outputParts];
+      state.status = "completed";
+    }
+  }
+  // ---- Message builder ----
+  buildMessage(opts) {
+    return {
+      id: opts.messageId,
+      role: opts.role,
+      agent: opts.agent ?? null,
+      time_created: opts.timestampMs,
+      mode: opts.mode ?? null,
+      model: opts.model ?? null,
+      provider: opts.provider ?? null,
+      tokens: opts.tokens ? opts.tokens : void 0,
+      cost: opts.cost ?? 0,
+      parts: opts.parts,
+      subagent_id: opts.subagent_id,
+      nickname: opts.nickname
+    };
+  }
+};
+var CURSOR_TOOL_TITLE_MAP = {
+  read_file_v2: "read",
+  edit_file_v2: "edit",
+  run_terminal_command_v2: "bash",
+  ripgrep_raw_search: "grep",
+  glob_file_search: "glob"
+};
+function mapToolTitle3(toolName) {
+  return CURSOR_TOOL_TITLE_MAP[toolName] ?? toolName;
+}
+function normalizeToolOutputParts2(output, timestampMs) {
+  if (output == null) return [];
+  if (typeof output === "string") {
+    return output.trim() ? [{ type: "text", text: output, time_created: timestampMs }] : [];
+  }
+  if (Array.isArray(output)) {
+    const parts = [];
+    for (const item of output) {
+      if (typeof item === "object" && item !== null) {
+        const text2 = String(
+          item.text ?? item.content ?? ""
+        );
+        if (text2.trim()) parts.push({ type: "text", text: text2, time_created: timestampMs });
+      } else if (typeof item === "string" && item.trim()) {
+        parts.push({ type: "text", text: item, time_created: timestampMs });
+      }
+    }
+    return parts;
+  }
+  const text = String(output);
+  return text.trim() ? [{ type: "text", text, time_created: timestampMs }] : [];
+}
+function extractTimestamp(msg) {
+  if (msg.createdAt && typeof msg.createdAt === "number" && msg.createdAt > 0) {
+    return msg.createdAt;
+  }
+  if (msg.timestamp && typeof msg.timestamp === "number" && msg.timestamp > 0) {
+    return msg.timestamp;
+  }
+  return 0;
+}
+function buildToolState(action) {
+  const state = {};
+  if (action.input) {
+    state.input = action.input;
+  }
+  if (action.output != null) {
+    const ts = 0;
+    const outputParts = normalizeToolOutputParts2(action.output, ts);
+    state.output = outputParts.length > 0 ? outputParts : action.output;
+  }
+  if (action.state) {
+    Object.assign(state, action.state);
+  }
+  if (!state.status) {
+    if (typeof action.output === "object" && action.output !== null) {
+      const out = action.output;
+      if (out.success === true) state.status = "completed";
+      else if (out.success === false) state.status = "error";
+      else state.status = "completed";
+    } else if (action.output != null) {
+      state.status = "completed";
+    }
+  }
+  return state;
+}
+function buildToolPart(action, timestampMs) {
+  const toolName = action.tool ?? "unknown";
+  return {
+    type: "tool",
+    tool: mapToolTitle3(toolName),
+    callID: action.type ? `${action.type}:${String(action.input?.id ?? "")}` : "",
+    title: `Tool: ${mapToolTitle3(toolName)}`,
+    state: buildToolState(action),
+    time_created: timestampMs
+  };
+}
+function buildTerminalToolPart(action, timestampMs) {
+  const command = String(action.input?.command ?? "");
+  const description = String(action.input?.commandDescription ?? "");
+  return {
+    type: "tool",
+    tool: "bash",
+    callID: "",
+    title: description || `bash: ${command.slice(0, 60)}`,
+    state: {
+      input: { command },
+      output: typeof action.output === "string" ? [{ type: "text", text: action.output, time_created: timestampMs }] : normalizeToolOutputParts2(action.output, timestampMs)
+    },
+    time_created: timestampMs
+  };
+}
+function convertActionToPart(action, timestampMs) {
+  const toolName = action.tool ?? "";
+  if (toolName === "run_terminal_command_v2") {
+    return buildTerminalToolPart(action, timestampMs);
+  }
+  if (toolName && action.type === "tool") {
+    return buildToolPart(action, timestampMs);
+  }
+  return null;
+}
+var CursorAgent = class extends BaseAgent {
+  name = "cursor";
+  displayName = "Cursor";
+  dbPath = null;
+  // Cache composer data from scan so getSessionData can reuse it
+  composerCache = /* @__PURE__ */ new Map();
+  // Session metadata for caching
+  sessionMetaMap = /* @__PURE__ */ new Map();
+  findDbPath() {
+    if (!isSqliteAvailable()) return null;
+    const dataPath = getCursorDataPath();
+    if (!dataPath) return null;
+    return join6(dataPath, "globalStorage", "state.vscdb");
+  }
+  /**
+   * Build a map of composerId → workspace folder path by reading
+   * workspaceStorage/{id}/workspace.json and the corresponding state.vscdb.
+   */
+  buildWorkspacePathMap() {
+    const map = /* @__PURE__ */ new Map();
+    const dataPath = getCursorDataPath();
+    if (!dataPath) return map;
+    const wsStoragePath = join6(dataPath, "workspaceStorage");
+    if (!existsSync6(wsStoragePath)) return map;
+    let entryNames;
+    try {
+      entryNames = readdirSync4(wsStoragePath);
+    } catch {
+      return map;
+    }
+    for (const name of entryNames) {
+      const wsDir = join6(wsStoragePath, name);
+      try {
+        if (!statSync5(wsDir).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      const wsJsonPath = join6(wsDir, "workspace.json");
+      if (!existsSync6(wsJsonPath)) continue;
+      let workspacePath;
+      try {
+        const data = JSON.parse(readFileSync5(wsJsonPath, "utf-8"));
+        const uri = data.folder ?? data.workspace ?? "";
+        if (!uri) continue;
+        workspacePath = normalize(decodeURIComponent(uri.replace(/^file:\/\//, "")));
+      } catch {
+        continue;
+      }
+      const wsDbPath = join6(wsDir, "state.vscdb");
+      if (!existsSync6(wsDbPath)) continue;
+      const wsDb = openDbReadOnly(wsDbPath);
+      if (!wsDb) continue;
+      try {
+        const row = wsDb.prepare("SELECT value FROM ItemTable WHERE key = 'composer.composerData'").get();
+        if (!row?.value) continue;
+        const parsed = JSON.parse(row.value);
+        let composers;
+        if (parsed !== null && typeof parsed === "object" && "allComposers" in parsed && Array.isArray(parsed["allComposers"])) {
+          composers = parsed.allComposers;
+        } else if (Array.isArray(parsed)) {
+          composers = parsed;
+        } else {
+          continue;
+        }
+        for (const c of composers) {
+          const id = c.composerId ?? c.id;
+          if (id) map.set(id, workspacePath);
+        }
+      } catch {
+      } finally {
+        wsDb.close();
+      }
+    }
+    return map;
+  }
+  isAvailable() {
+    this.dbPath = this.findDbPath();
+    return this.dbPath !== null && existsSync6(this.dbPath);
+  }
+  scan() {
+    if (!this.dbPath) return [];
+    const scanMarker = perf.start("cursor:scan");
+    const dbMarker = perf.start("openDatabase");
+    const db = this.openDatabase();
+    perf.end(dbMarker);
+    if (!db) return [];
+    const wsMarker = perf.start("buildWorkspacePathMap");
+    const workspacePathMap = this.buildWorkspacePathMap();
+    perf.end(wsMarker);
+    try {
+      const rows = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'").all();
+      const heads = [];
+      for (const row of rows) {
+        try {
+          const composer = JSON.parse(row.value);
+          if (!composer.id && !composer.composerId) continue;
+          const composerId = composer.id || composer.composerId || "";
+          const requestId = this.extractRequestIdFromBubbles(db, composerId);
+          const sessionId = requestId || composerId;
+          const title = this.extractTitle(composer);
+          const createdAt = composer.createdAt ?? 0;
+          const updatedAt = composer.updatedAt ?? createdAt;
+          const messageCount = this.countMessagesFromBubbles(db, composerId);
+          const directory = workspacePathMap.get(composerId) ?? "";
+          heads.push({
+            id: sessionId,
+            slug: `cursor/${sessionId}`,
+            title,
+            directory,
+            time_created: createdAt,
+            time_updated: updatedAt || void 0,
+            stats: {
+              message_count: messageCount,
+              total_input_tokens: composer.inputTokenCount ?? 0,
+              total_output_tokens: composer.outputTokenCount ?? 0,
+              total_cost: 0
+            }
+          });
+          this.composerCache.set(sessionId, composer);
+          this.composerCache.set(`__mapping__${composerId}`, {
+            sessionId
+          });
+          if (directory) {
+            this.composerCache.set(`__dir__${composerId}`, {
+              directory
+            });
+          }
+          this.sessionMetaMap.set(sessionId, {
+            id: sessionId,
+            sourcePath: this.dbPath || ""
+          });
+        } catch {
+        }
+      }
+      perf.end(scanMarker);
+      return heads;
+    } catch {
+      return [];
+    } finally {
+      db.close();
+    }
+  }
+  getSessionMetaMap() {
+    return this.sessionMetaMap;
+  }
+  setSessionMetaMap(meta) {
+    this.sessionMetaMap = meta;
+  }
+  /**
+   * 检测数据库变更
+   * 对于 SQLite，检测数据库文件修改时间
+   */
+  checkForChanges(sinceTimestamp, cachedSessions) {
+    if (!this.dbPath) {
+      this.dbPath = this.findDbPath();
+    }
+    if (!this.dbPath || !existsSync6(this.dbPath)) {
+      return { hasChanges: false, timestamp: Date.now() };
+    }
+    try {
+      const stat = statSync5(this.dbPath);
+      const hasChanges = stat.mtimeMs > sinceTimestamp;
+      const changedIds = hasChanges ? cachedSessions.map((s) => s.id) : [];
+      return {
+        hasChanges,
+        changedIds,
+        timestamp: Date.now()
+      };
+    } catch {
+      return { hasChanges: false, timestamp: Date.now() };
+    }
+  }
+  /**
+   * 增量扫描 - 重新查询数据库
+   */
+  incrementalScan(_cachedSessions, _changedIds) {
+    return this.scan();
+  }
+  getSessionData(sessionId) {
+    if (!this.dbPath) {
+      this.dbPath = this.findDbPath();
+    }
+    if (!this.dbPath) {
+      throw new Error("Cursor database is missing");
+    }
+    const db = this.openDatabase();
+    if (!db) {
+      throw new Error("Cursor database is missing");
+    }
+    try {
+      let composer = this.composerCache.get(sessionId);
+      let resolvedSessionId = sessionId;
+      if (!composer) {
+        composer = this.loadComposer(db, sessionId) ?? void 0;
+      }
+      if (!composer) {
+        const composerId2 = this.findComposerIdByRequestId(db, sessionId);
+        if (composerId2) {
+          composer = this.loadComposer(db, composerId2) ?? void 0;
+          resolvedSessionId = sessionId;
+        }
+      }
+      if (!composer) {
+        throw new Error(`Session not found: ${sessionId}`);
+      }
+      const composerId = composer.id || composer.composerId || "";
+      const title = this.extractTitle(composer);
+      const createdAt = composer.createdAt ?? 0;
+      const updatedAt = composer.updatedAt ?? createdAt;
+      const messages = this.loadMessagesFromBubbles(db, composerId, resolvedSessionId);
+      let totalInputTokens = 0;
+      let totalOutputTokens = 0;
+      for (const msg of messages) {
+        totalInputTokens += msg.tokens?.input ?? 0;
+        totalOutputTokens += msg.tokens?.output ?? 0;
+      }
+      if (totalInputTokens === 0) totalInputTokens = composer.inputTokenCount ?? 0;
+      if (totalOutputTokens === 0) totalOutputTokens = composer.outputTokenCount ?? 0;
+      this.appendSubagentMessages(db, composer, messages);
+      const cachedDir = this.composerCache.get(`__dir__${composerId}`);
+      const directory = cachedDir?.directory ?? this.buildWorkspacePathMap().get(composerId) ?? "";
+      return {
+        id: resolvedSessionId,
+        title,
+        slug: `cursor/${resolvedSessionId}`,
+        directory,
+        time_created: createdAt,
+        time_updated: updatedAt || void 0,
+        stats: {
+          message_count: messages.length,
+          total_input_tokens: totalInputTokens,
+          total_output_tokens: totalOutputTokens,
+          total_cost: 0
+        },
+        messages
+      };
+    } finally {
+      db.close();
+    }
+  }
+  // --- Private helpers ---
+  openDatabase() {
+    if (!this.dbPath) return null;
+    return openDbReadOnly(this.dbPath);
+  }
+  /** Extract requestId from bubbles for a composer (like agent-dump) */
+  extractRequestIdFromBubbles(db, composerId) {
+    try {
+      const rows = db.prepare("SELECT value FROM cursorDiskKV WHERE key LIKE ? ORDER BY key").all(`bubbleId:${composerId}:%`);
+      for (const row of rows) {
+        try {
+          const bubble = JSON.parse(row.value);
+          if (bubble.requestId && typeof bubble.requestId === "string" && bubble.requestId.trim()) {
+            return bubble.requestId.trim();
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  /** Find composerId by requestId (reverse lookup) */
+  findComposerIdByRequestId(db, requestId) {
+    try {
+      const rows = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'bubbleId:%' AND value LIKE ?").all(`%"requestId":"${requestId}"%`);
+      for (const row of rows) {
+        try {
+          const bubble = JSON.parse(row.value);
+          if (bubble.requestId === requestId) {
+            const keyParts = row.key.split(":");
+            if (keyParts.length >= 2 && keyParts[1]) {
+              return keyParts[1];
+            }
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  /** Extract title from composer (like agent-dump) */
+  extractTitle(composer) {
+    if (composer.name && typeof composer.name === "string" && composer.name.trim()) {
+      return composer.name.trim();
+    }
+    if (composer.title && typeof composer.title === "string" && composer.title.trim()) {
+      return composer.title.trim();
+    }
+    if (composer.text && typeof composer.text === "string" && composer.text.trim()) {
+      const firstLine = composer.text.split("\n").find((l) => l.trim())?.trim().slice(0, 80);
+      if (firstLine) return firstLine;
+    }
+    const composerId = composer.composerId || composer.id || "";
+    return `Cursor Session ${composerId.slice(0, 8)}`;
+  }
+  /** Count messages from bubbles */
+  countMessagesFromBubbles(db, composerId) {
+    try {
+      const rows = db.prepare("SELECT value FROM cursorDiskKV WHERE key LIKE ?").all(`bubbleId:${composerId}:%`);
+      let count = 0;
+      for (const row of rows) {
+        try {
+          const bubble = JSON.parse(row.value);
+          if (bubble.type === 1 || bubble.type === 2) {
+            count++;
+          }
+        } catch {
+        }
+      }
+      return count;
+    } catch {
+      return 0;
+    }
+  }
+  /** Load messages from bubbles (like agent-dump) */
+  loadMessagesFromBubbles(db, composerId, _sessionId) {
+    const messages = [];
+    try {
+      const rows = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE ? ORDER BY rowid ASC").all(`bubbleId:${composerId}:%`);
+      let activeModelName = null;
+      let messageIndex = 0;
+      for (const row of rows) {
+        try {
+          const bubble = JSON.parse(row.value);
+          const bubbleId = row.key.split(":").pop() || String(messageIndex);
+          const role = bubble.type === 2 ? "assistant" : "user";
+          let timestampMs = 0;
+          if (bubble.timingInfo?.clientRpcSendTime) {
+            timestampMs = Math.floor(bubble.timingInfo.clientRpcSendTime);
+          } else if (bubble.createdAt) {
+            timestampMs = bubble.createdAt;
+          } else if (bubble.timestamp) {
+            timestampMs = bubble.timestamp;
+          }
+          if (role === "user" && bubble.modelInfo?.modelName) {
+            activeModelName = bubble.modelInfo.modelName;
+          }
+          const inputTokens = bubble.tokenCount?.inputTokens ?? 0;
+          const outputTokens = bubble.tokenCount?.outputTokens ?? 0;
+          const parts = [];
+          const text = bubble.text?.trim();
+          if (text) {
+            parts.push({ type: "text", text, time_created: timestampMs });
+          }
+          if (bubble.toolFormerData) {
+            const toolPart = this.convertToolFormerData(bubble.toolFormerData, timestampMs);
+            if (toolPart) {
+              parts.push(toolPart);
+            }
+          }
+          if (parts.length === 0) continue;
+          messages.push({
+            id: `cursor-${composerId}-${bubbleId}`,
+            role,
+            agent: "cursor",
+            time_created: timestampMs,
+            time_completed: null,
+            mode: role === "assistant" && parts.some((p) => p.type === "tool") ? "tool" : null,
+            model: activeModelName,
+            provider: null,
+            tokens: { input: inputTokens, output: outputTokens },
+            cost: 0,
+            parts
+          });
+          messageIndex++;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return messages;
+  }
+  /** Convert toolFormerData to MessagePart */
+  convertToolFormerData(toolData, timestampMs) {
+    if (!toolData || !toolData.name) return null;
+    const toolName = toolData.name;
+    const normalizedName = toolName === "create_plan" ? "plan" : mapToolTitle3(toolName);
+    const state = {
+      status: toolData.status === "completed" ? "completed" : "running"
+    };
+    if (toolData.params) {
+      if (typeof toolData.params === "string") {
+        try {
+          state.input = JSON.parse(toolData.params);
+        } catch {
+          state.input = { _raw: toolData.params };
+        }
+      } else {
+        state.input = toolData.params;
+      }
+    }
+    if (toolData.result !== void 0) {
+      if (typeof toolData.result === "string") {
+        try {
+          const parsed = JSON.parse(toolData.result);
+          state.output = parsed;
+          if (parsed.error || parsed.message || parsed.stderr) {
+            state.error = parsed.error || parsed.message || parsed.stderr;
+            state.status = "error";
+          }
+        } catch {
+          state.output = toolData.result;
+        }
+      } else {
+        state.output = toolData.result;
+      }
+    }
+    if (toolName === "create_plan") {
+      const planText = typeof state.input === "object" && state.input !== null ? state.input.plan : void 0;
+      return {
+        type: "plan",
+        title: "Plan",
+        input: planText,
+        approval_status: state.status === "completed" ? "success" : "fail",
+        state,
+        time_created: timestampMs
+      };
+    }
+    return {
+      type: "tool",
+      tool: normalizedName,
+      callID: toolData.toolCallId || "",
+      title: `Tool: ${toolName}`,
+      state,
+      time_created: timestampMs
+    };
+  }
+  loadComposer(db, sessionId) {
+    const row = db.prepare("SELECT value FROM cursorDiskKV WHERE key = ?").get(`composerData:${sessionId}`);
+    if (!row) return null;
+    try {
+      return JSON.parse(row.value);
+    } catch {
+      return null;
+    }
+  }
+  loadBubble(db, sessionId) {
+    const row = db.prepare("SELECT value FROM cursorDiskKV WHERE key = ?").get(`bubble:${sessionId}`);
+    if (!row) return null;
+    try {
+      return JSON.parse(row.value);
+    } catch {
+      return null;
+    }
+  }
+  appendSubagentMessages(db, composer, messages) {
+    const subagentInfos = composer.subagentInfos;
+    if (!Array.isArray(subagentInfos) || subagentInfos.length === 0) return;
+    for (const subInfo of subagentInfos) {
+      if (!subInfo.id) continue;
+      const bubble = this.loadBubble(db, subInfo.id);
+      if (!bubble || !Array.isArray(bubble.chatMessages)) continue;
+      for (const chatMsg of bubble.chatMessages) {
+        const role = chatMsg.role?.trim().toLowerCase();
+        if (role !== "user" && role !== "assistant") continue;
+        const timestampMs = extractTimestamp(chatMsg);
+        const parts = [];
+        const text = chatMsg.text ?? "";
+        if (text.trim()) {
+          parts.push({ type: "text", text, time_created: timestampMs });
+        }
+        if (role === "assistant" && Array.isArray(chatMsg.actions)) {
+          for (const action of chatMsg.actions) {
+            const part = convertActionToPart(action, timestampMs);
+            if (part) parts.push(part);
+          }
+        }
+        if (parts.length === 0) continue;
+        messages.push({
+          id: `cursor-sub-${subInfo.id}`,
+          role,
+          agent: "cursor",
+          time_created: timestampMs,
+          time_completed: null,
+          mode: null,
+          model: null,
+          provider: null,
+          tokens: void 0,
+          cost: 0,
+          subagent_id: subInfo.id,
+          nickname: subInfo.nickname ?? subInfo.title,
+          parts
+        });
+      }
+    }
+  }
+};
+registerAgent({
+  name: "claudecode",
+  displayName: "Claude Code",
+  icon: "/icon/agent/claudecode.svg",
+  create: () => new ClaudeCodeAgent()
+});
+registerAgent({
+  name: "opencode",
+  displayName: "OpenCode",
+  icon: "/icon/agent/opencode.svg",
+  create: () => new OpenCodeAgent()
+});
+registerAgent({
+  name: "kimi",
+  displayName: "Kimi-Cli",
+  icon: "/icon/agent/kimi.svg",
+  create: () => new KimiAgent()
+});
+registerAgent({
+  name: "codex",
+  displayName: "Codex",
+  icon: "/icon/agent/codex.svg",
+  create: () => new CodexAgent()
+});
+registerAgent({
+  name: "cursor",
+  displayName: "Cursor",
+  icon: "/icon/agent/cursor.svg",
+  create: () => new CursorAgent()
+});
+var CACHE_VERSION = 2;
+var CACHE_FILENAME = "scan-cache.json";
+function getCachePath() {
+  return join7(homedir2(), ".cache", "codesesh", CACHE_FILENAME);
+}
+function ensureCacheDir() {
+  const cacheDir = join7(homedir2(), ".cache", "codesesh");
+  if (!existsSync7(cacheDir)) {
+    mkdirSync(cacheDir, { recursive: true });
+  }
+}
+function loadCachedSessions(agentName) {
+  try {
+    const cachePath = getCachePath();
+    if (!existsSync7(cachePath)) return null;
+    const data = JSON.parse(readFileSync6(cachePath, "utf-8"));
+    if (data.version !== CACHE_VERSION) return null;
+    const entry = data.entries[agentName];
+    if (!entry) return null;
+    const CACHE_TTL = 7 * 24 * 60 * 60 * 1e3;
+    if (Date.now() - entry.timestamp > CACHE_TTL) return null;
+    return { sessions: entry.sessions, meta: entry.meta || {}, timestamp: entry.timestamp };
+  } catch {
+    return null;
+  }
+}
+function saveCachedSessions(agentName, sessions, meta = {}) {
+  try {
+    ensureCacheDir();
+    const cachePath = getCachePath();
+    let data;
+    if (existsSync7(cachePath)) {
+      try {
+        data = JSON.parse(readFileSync6(cachePath, "utf-8"));
+        if (data.version !== CACHE_VERSION) {
+          data = { version: CACHE_VERSION, entries: {}, lastScanTime: 0 };
+        }
+      } catch {
+        data = { version: CACHE_VERSION, entries: {}, lastScanTime: 0 };
+      }
+    } else {
+      data = { version: CACHE_VERSION, entries: {}, lastScanTime: 0 };
+    }
+    data.entries[agentName] = {
+      sessions,
+      meta,
+      timestamp: Date.now(),
+      version: CACHE_VERSION
+    };
+    data.lastScanTime = Date.now();
+    writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+  } catch {
+  }
+}
+function clearCache() {
+  try {
+    const cachePath = getCachePath();
+    if (existsSync7(cachePath)) {
+      const data = {
+        version: CACHE_VERSION,
+        entries: {},
+        lastScanTime: 0
+      };
+      writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+    }
+  } catch {
+  }
+}
+function getCacheInfo() {
+  try {
+    const cachePath = getCachePath();
+    if (!existsSync7(cachePath)) {
+      return { lastScanTime: null, size: 0 };
+    }
+    const data = JSON.parse(readFileSync6(cachePath, "utf-8"));
+    const size = Object.values(data.entries).reduce((sum, entry) => sum + entry.sessions.length, 0);
+    return {
+      lastScanTime: data.lastScanTime || null,
+      size
+    };
+  } catch {
+    return { lastScanTime: null, size: 0 };
+  }
+}
+function isPathScopeMatch(queryPath, sessionPath) {
+  if (!sessionPath) return false;
+  const q = resolve(queryPath);
+  const s = resolve(sessionPath);
+  const sepNorm = (p) => p.replaceAll(sep, "/");
+  const sn = sepNorm(s);
+  const qn = sepNorm(q);
+  return sn === qn || sn.startsWith(qn + "/") || qn.startsWith(sn + "/");
+}
+function filterSessions(sessions, options) {
+  let result = sessions;
+  if (options.cwd) {
+    const cwd = options.cwd;
+    result = result.filter((s) => isPathScopeMatch(cwd, s.directory));
+  }
+  if (options.from != null) {
+    result = result.filter((s) => s.time_created >= options.from);
+  }
+  if (options.to != null) {
+    result = result.filter((s) => s.time_created <= options.to);
+  }
+  return result;
+}
+async function scanAgentSmart(agent, options, onProgress) {
+  const useCache = options.useCache ?? true;
+  const smartRefresh = options.smartRefresh ?? true;
+  if (useCache) {
+    const cached = loadCachedSessions(agent.name);
+    if (cached !== null) {
+      if (agent.setSessionMetaMap) {
+        const metaMap = /* @__PURE__ */ new Map();
+        for (const [id, meta] of Object.entries(cached.meta)) {
+          metaMap.set(id, meta);
+        }
+        agent.setSessionMetaMap(metaMap);
+      }
+      onProgress?.({
+        agent: agent.name,
+        phase: "cache",
+        cachedCount: cached.sessions.length
+      });
+      if (smartRefresh && agent.checkForChanges) {
+        setTimeout(async () => {
+          await refreshAgentAsync(agent, cached.sessions, cached.timestamp, onProgress);
+        }, 0);
+      }
+      const filtered = filterSessions(cached.sessions, options);
+      return { agent, heads: filtered, fromCache: true };
+    }
+  }
+  return scanAgentFull(agent, options, onProgress);
+}
+async function refreshAgentAsync(agent, cachedSessions, cacheTimestamp, onProgress) {
+  try {
+    onProgress?.({ agent: agent.name, phase: "checking" });
+    const checkResult = await Promise.resolve(
+      agent.checkForChanges(cacheTimestamp, cachedSessions)
+    );
+    if (!checkResult.hasChanges) {
+      onProgress?.({ agent: agent.name, phase: "complete" });
+      return;
+    }
+    onProgress?.({
+      agent: agent.name,
+      phase: "incremental",
+      changedCount: checkResult.changedIds?.length
+    });
+    const updatedSessions = await Promise.resolve(
+      agent.incrementalScan(cachedSessions, checkResult.changedIds || [])
+    );
+    const metaMap = agent.getSessionMetaMap?.();
+    const meta = {};
+    if (metaMap) {
+      for (const [id, data] of metaMap.entries()) {
+        meta[id] = { id, ...data };
+      }
+    }
+    saveCachedSessions(agent.name, updatedSessions, meta);
+    onProgress?.({
+      agent: agent.name,
+      phase: "complete",
+      newCount: updatedSessions.length
+    });
+  } catch (err) {
+    console.error(`[${agent.name}] Background refresh failed:`, err);
+  }
+}
+async function scanAgentFull(agent, options, onProgress) {
+  const availMarker = perf.start(`agent:${agent.name}:isAvailable`);
+  const isAvail = agent.isAvailable();
+  perf.end(availMarker);
+  if (!isAvail) {
+    return null;
+  }
+  try {
+    const scanMarker = perf.start(`agent:${agent.name}:scan`);
+    const heads = agent.scan();
+    perf.end(scanMarker);
+    const metaMap = agent.getSessionMetaMap?.();
+    const meta = {};
+    if (metaMap) {
+      for (const [id, data] of metaMap.entries()) {
+        meta[id] = { id, ...data };
+      }
+    }
+    saveCachedSessions(agent.name, heads, meta);
+    onProgress?.({ agent: agent.name, phase: "complete", newCount: heads.length });
+    const filtered = filterSessions(heads, options);
+    return { agent, heads: filtered, fromCache: false };
+  } catch (err) {
+    console.error(`Error scanning ${agent.name}:`, err);
+    return { agent, heads: [], fromCache: false };
+  }
+}
+async function scanSessions(options = {}, onProgress) {
+  const scanMarker = perf.start("scanSessions");
+  const agents = createRegisteredAgents();
+  const byAgent = {};
+  const allSessions = [];
+  const availableAgents = [];
+  const agentFilter = options.agents?.length ? new Set(options.agents.map((a) => a.toLowerCase())) : null;
+  const agentsToScan = agents.filter((agent) => {
+    if (agentFilter && !agentFilter.has(agent.name.toLowerCase())) {
+      return false;
+    }
+    return true;
+  });
+  const scanPromises = agentsToScan.map((agent) => scanAgentSmart(agent, options, onProgress));
+  const results = await Promise.all(scanPromises);
+  for (const result of results) {
+    if (result) {
+      availableAgents.push(result.agent);
+      byAgent[result.agent.name] = result.heads;
+      allSessions.push(...result.heads);
+    }
+  }
+  perf.end(scanMarker);
+  return { sessions: allSessions, byAgent, agents: availableAgents };
+}
+async function scanSessionsAsync(options = {}, onProgress) {
+  return scanSessions(options, onProgress);
+}
+
+export {
+  registerAgent,
+  createRegisteredAgents,
+  getRegisteredAgents,
+  getAgentInfoMap,
+  getAgentByName,
+  BaseAgent,
+  firstExisting,
+  resolveProviderRoots,
+  getCursorDataPath,
+  parseJsonlLines,
+  readJsonlFile,
+  normalizeTitleText,
+  basenameTitle,
+  resolveSessionTitle,
+  perf,
+  openDbReadOnly,
+  isSqliteAvailable,
+  loadCachedSessions,
+  saveCachedSessions,
+  clearCache,
+  getCacheInfo,
+  scanSessions,
+  scanSessionsAsync
+};
+//# sourceMappingURL=chunk-H3D3GNQK.js.map