@cookielab.io/klovi 1.1.0 → 2.0.0

package/dist/server.js

@@ -3,15 +3,78 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // index.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { dirname, join as join5 } from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
+import { dirname, join as join8 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/server/cli.ts
 import { readSync } from "node:fs";
 
-// src/server/parser/claude-dir.ts
-import { readdir, readFile, stat } from "node:fs/promises";
+// src/server/api/projects.ts
+async function handleProjects(registry) {
+  const projects = await registry.discoverAllProjects();
+  return Response.json({ projects });
+}
+
+// src/server/iso-time.ts
+function sortByIsoDesc(items, select) {
+  items.sort((a, b) => select(b).localeCompare(select(a)));
+}
+function maxIso(values) {
+  let latest = "";
+  for (const value of values) {
+    if (value > latest)
+      latest = value;
+  }
+  return latest;
+}
+function epochMsToIso(epochMs) {
+  return new Date(epochMs).toISOString();
+}
+function epochSecondsToIso(epochSeconds) {
+  return new Date(epochSeconds * 1000).toISOString();
+}
+
+// src/server/api/search.ts
+async function handleSearchSessions(registry) {
+  const projects = await registry.discoverAllProjects();
+  const allSessions = [];
+  for (const project of projects) {
+    const sessions = await registry.listAllSessions(project);
+    const projectName = projectNameFromPath(project.name);
+    for (const session of sessions) {
+      allSessions.push({
+        ...session,
+        encodedPath: project.encodedPath,
+        projectName
+      });
+    }
+  }
+  sortByIsoDesc(allSessions, (session) => session.timestamp);
+  return Response.json({ sessions: allSessions });
+}
+function projectNameFromPath(fullPath) {
+  const parts = fullPath.split("/").filter(Boolean);
+  return parts.slice(-2).join("/");
+}
+
+// src/shared/session-id.ts
+var SESSION_ID_SEPARATOR = "::";
+function encodeSessionId(pluginId, rawSessionId) {
+  return `${pluginId}${SESSION_ID_SEPARATOR}${rawSessionId}`;
+}
+function parseSessionId(sessionId) {
+  const separatorIdx = sessionId.indexOf(SESSION_ID_SEPARATOR);
+  if (separatorIdx === -1) {
+    return { pluginId: null, rawSessionId: sessionId };
+  }
+  return {
+    pluginId: sessionId.slice(0, separatorIdx),
+    rawSessionId: sessionId.slice(separatorIdx + SESSION_ID_SEPARATOR.length)
+  };
+}
+
+// src/server/plugins/claude-code/parser.ts
 import { join as join2 } from "node:path";
 
 // src/server/config.ts
@@ -27,8 +90,19 @@ function setClaudeCodeDir(dir) {
 function getProjectsDir() {
   return join(claudeCodeDir, "projects");
 }
-function getStatsCachePath() {
-  return join(claudeCodeDir, "stats-cache.json");
+var codexCliDir = join(homedir(), ".codex");
+function getCodexCliDir() {
+  return codexCliDir;
+}
+function setCodexCliDir(dir) {
+  codexCliDir = dir;
+}
+var openCodeDir = join(homedir(), ".local", "share", "opencode");
+function getOpenCodeDir() {
+  return openCodeDir;
+}
+function setOpenCodeDir(dir) {
+  openCodeDir = dir;
 }
 
 // src/server/parser/command-message.ts
@@ -55,200 +129,35 @@ function parseCommandMessage(text) {
   return { name, args };
 }
 
-// src/server/parser/claude-dir.ts
-async function discoverProjects() {
-  const entries = await readdir(getProjectsDir(), { withFileTypes: true });
-  const projects = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory())
-      continue;
-    const projectDir = join2(getProjectsDir(), entry.name);
-    const sessionFiles = (await readdir(projectDir)).filter((f) => f.endsWith(".jsonl"));
-    if (sessionFiles.length === 0)
-      continue;
-    let lastActivity = "";
-    let fullPath = "";
-    for (const sf of sessionFiles) {
-      const fileStat = await stat(join2(projectDir, sf));
-      const mtime = fileStat.mtime.toISOString();
-      if (mtime > lastActivity)
-        lastActivity = mtime;
-      if (!fullPath) {
-        fullPath = await extractCwd(join2(projectDir, sf));
-      }
-    }
-    const name = fullPath || decodeEncodedPath(entry.name);
-    projects.push({
-      encodedPath: entry.name,
-      name,
-      fullPath: fullPath || decodeEncodedPath(entry.name),
-      sessionCount: sessionFiles.length,
-      lastActivity
-    });
-  }
-  projects.sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
-  return projects;
-}
-var PLAN_PREFIX = "Implement the following plan";
-async function listSessions(encodedPath) {
-  const projectDir = join2(getProjectsDir(), encodedPath);
-  const files = (await readdir(projectDir)).filter((f) => f.endsWith(".jsonl"));
-  const sessions = [];
-  for (const file of files) {
-    const filePath = join2(projectDir, file);
-    const sessionId = file.replace(".jsonl", "");
-    const meta = await extractSessionMeta(filePath);
-    if (meta)
-      sessions.push({ sessionId, ...meta });
-  }
-  classifySessionTypes(sessions);
-  sessions.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
-  return sessions;
-}
-function classifySessionTypes(sessions) {
-  const implSlugs = new Set;
-  for (const session of sessions) {
-    if (session.firstMessage.startsWith(PLAN_PREFIX)) {
-      session.sessionType = "implementation";
-      if (session.slug)
-        implSlugs.add(session.slug);
-    }
-  }
-  for (const session of sessions) {
-    if (!session.sessionType && session.slug && implSlugs.has(session.slug)) {
-      session.sessionType = "plan";
-    }
-  }
-}
-async function extractCwd(filePath) {
-  const text = await readFile(filePath, "utf-8");
-  const lines = text.split(`
-`);
-  for (const line of lines.slice(0, 20)) {
-    if (!line.trim())
-      continue;
-    try {
-      const obj = JSON.parse(line);
-      if (obj.cwd)
-        return obj.cwd;
-    } catch {}
-  }
-  return "";
-}
-function extractTextFromContent(content) {
-  if (typeof content === "string")
-    return content;
-  if (Array.isArray(content)) {
-    for (const block of content) {
-      if (block.type === "text" && "text" in block)
-        return block.text;
-    }
-  }
-  return "";
-}
-function isInternalMessage(text) {
-  return text.startsWith("<local-command") || text.startsWith("<command-name") || /^\[.+\]$/.test(text.trim());
-}
-function isMetaComplete(meta) {
-  return !!(meta.timestamp && meta.slug && meta.firstMessage && meta.model && meta.gitBranch);
-}
-function processMetaLine(obj, meta) {
-  if (obj.timestamp && !meta.timestamp)
-    meta.timestamp = obj.timestamp;
-  if (obj.slug && !meta.slug)
-    meta.slug = obj.slug;
-  if (obj.gitBranch && !meta.gitBranch)
-    meta.gitBranch = obj.gitBranch;
-  if (obj.message?.model && !meta.model)
-    meta.model = obj.message.model;
-  if (!meta.firstMessage && obj.type === "user" && !obj.isMeta && obj.message) {
-    const raw = extractTextFromContent(obj.message.content);
-    if (raw && !isInternalMessage(raw)) {
-      meta.firstMessage = cleanCommandMessage(raw).slice(0, 200);
-    }
-  }
-}
-async function extractSessionMeta(filePath) {
-  const text = await readFile(filePath, "utf-8");
+// src/server/plugins/shared/jsonl-utils.ts
+function iterateJsonl(text, visitor, options = {}) {
   const lines = text.split(`
 `);
-  const meta = { timestamp: "", slug: "", firstMessage: "", model: "", gitBranch: "" };
-  for (const line of lines.slice(0, 50)) {
-    if (!line.trim())
+  const start = Math.max(0, options.startAt ?? 0);
+  const end = options.maxLines === undefined ? lines.length : Math.min(lines.length, start + options.maxLines);
+  for (let i = start;i < end; i++) {
+    const line = lines[i];
+    if (!line || !line.trim())
       continue;
     try {
-      const obj = JSON.parse(line);
-      processMetaLine(obj, meta);
-      if (isMetaComplete(meta))
-        break;
-    } catch {}
-  }
-  if (!meta.timestamp || !meta.firstMessage)
-    return null;
-  return {
-    timestamp: meta.timestamp,
-    slug: meta.slug || "unknown",
-    firstMessage: meta.firstMessage,
-    model: meta.model || "unknown",
-    gitBranch: meta.gitBranch || ""
-  };
-}
-function projectNameFromPath(fullPath) {
-  const parts = fullPath.split("/").filter(Boolean);
-  return parts.slice(-2).join("/");
-}
-function aggregateSessions(projects, sessionsByProject) {
-  const results = [];
-  for (const project of projects) {
-    const sessions = sessionsByProject.get(project.encodedPath) ?? [];
-    const projectName = projectNameFromPath(project.name);
-    for (const session of sessions) {
-      results.push({
-        ...session,
-        encodedPath: project.encodedPath,
-        projectName
+      const parsed = JSON.parse(line);
+      const shouldContinue = visitor({
+        parsed,
+        line,
+        lineIndex: i,
+        lineNumber: i + 1
       });
+      if (shouldContinue === false)
+        break;
+    } catch (error) {
+      options.onMalformed?.(line, i + 1, error);
     }
   }
-  results.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
-  return results;
-}
-async function listAllSessions() {
-  const projects = await discoverProjects();
-  const sessionsByProject = new Map;
-  for (const project of projects) {
-    const sessions = await listSessions(project.encodedPath);
-    sessionsByProject.set(project.encodedPath, sessions);
-  }
-  return aggregateSessions(projects, sessionsByProject);
-}
-function decodeEncodedPath(encoded) {
-  if (encoded.startsWith("-")) {
-    const withSlashes = encoded.slice(1).replace(/-/g, "/");
-    if (process.platform === "win32" && /^[A-Za-z]\//.test(withSlashes)) {
-      return `${withSlashes[0]}:${withSlashes.slice(1)}`;
-    }
-    return `/${withSlashes}`;
-  }
-  return encoded.replace(/-/g, "/");
-}
-
-// src/server/api/projects.ts
-async function handleProjects() {
-  const projects = await discoverProjects();
-  return Response.json({ projects });
-}
-
-// src/server/api/search.ts
-async function handleSearchSessions() {
-  const sessions = await listAllSessions();
-  return Response.json({ sessions });
 }
 
-// src/server/parser/session.ts
-import { join as join3 } from "node:path";
-async function parseSession(sessionId, encodedPath) {
-  const { rawLines, parseErrors } = await readJsonlLines(join3(getProjectsDir(), encodedPath, `${sessionId}.jsonl`));
+// src/server/plugins/claude-code/parser.ts
+async function loadClaudeSession(nativeId, sessionId) {
+  const { rawLines, parseErrors } = await readJsonlLines(join2(getProjectsDir(), nativeId, `${sessionId}.jsonl`));
   const subAgentMap = extractSubAgentMap(rawLines);
   const slug = extractSlug(rawLines);
   const turns = buildTurns(rawLines, parseErrors);
@@ -267,19 +176,20 @@ async function parseSession(sessionId, encodedPath) {
   return {
     session: {
       sessionId,
-      project: encodedPath,
-      turns
+      project: nativeId,
+      turns,
+      pluginId: "claude-code"
     },
     slug
   };
 }
 async function parseSubAgentSession(sessionId, encodedPath, agentId) {
-  const filePath = join3(getProjectsDir(), encodedPath, sessionId, "subagents", `agent-${agentId}.jsonl`);
+  const filePath = join2(getProjectsDir(), encodedPath, sessionId, "subagents", `agent-${agentId}.jsonl`);
   let parsed;
   try {
     parsed = await readJsonlLines(filePath);
   } catch {
-    return { sessionId, project: encodedPath, turns: [] };
+    return { sessionId, project: encodedPath, turns: [], pluginId: "claude-code" };
   }
   const subAgentMap = extractSubAgentMap(parsed.rawLines);
   const turns = buildTurns(parsed.rawLines, parsed.parseErrors);
@@ -295,7 +205,7 @@ async function parseSubAgentSession(sessionId, encodedPath, agentId) {
       }
     }
   }
-  return { sessionId, project: encodedPath, turns };
+  return { sessionId, project: encodedPath, turns, pluginId: "claude-code" };
 }
 var AGENT_ID_RE = /agentId:\s*(\w+)/;
 function extractFromProgressEvent(line, map) {
@@ -339,11 +249,11 @@ function extractSlug(lines) {
   }
   return;
 }
-var PLAN_PREFIX2 = "Implement the following plan";
+var PLAN_PREFIX = "Implement the following plan";
 var STATUS_RE = /^\[.+\]$/;
 function findPlanSessionId(turns, slug, sessions, currentSessionId) {
   const planTurn = turns.find((t) => t.kind === "user" && !STATUS_RE.test(t.text.trim()));
-  if (!planTurn || !planTurn.text.startsWith(PLAN_PREFIX2))
+  if (!planTurn || !planTurn.text.startsWith(PLAN_PREFIX))
     return;
   if (!slug)
     return;
@@ -353,34 +263,29 @@ function findPlanSessionId(turns, slug, sessions, currentSessionId) {
 function findImplSessionId(slug, sessions, currentSessionId) {
   if (!slug)
     return;
-  const match = sessions.find((s) => s.slug === slug && s.sessionId !== currentSessionId && s.firstMessage.startsWith(PLAN_PREFIX2));
+  const match = sessions.find((s) => s.slug === slug && s.sessionId !== currentSessionId && s.firstMessage.startsWith(PLAN_PREFIX));
   return match?.sessionId;
 }
 async function readJsonlLines(filePath) {
-  const { readFile: readFile2 } = await import("node:fs/promises");
-  const text = await readFile2(filePath, "utf-8");
-  const lines = text.split(`
-`);
+  const { readFile } = await import("node:fs/promises");
+  const text = await readFile(filePath, "utf-8");
   const rawLines = [];
   const parseErrors = [];
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i];
-    if (!line.trim())
-      continue;
-    try {
-      rawLines.push(JSON.parse(line));
-    } catch (err) {
+  iterateJsonl(text, ({ parsed }) => {
+    rawLines.push(parsed);
+  }, {
+    onMalformed: (line, lineNumber, error) => {
       parseErrors.push({
         kind: "parse_error",
-        uuid: `parse-error-line-${i + 1}`,
+        uuid: `parse-error-line-${lineNumber}`,
         timestamp: rawLines[rawLines.length - 1]?.timestamp ?? "",
-        lineNumber: i + 1,
+        lineNumber,
         rawLine: line.length > 500 ? `${line.slice(0, 500)}… (truncated)` : line,
         errorType: "json_parse",
-        errorDetails: err instanceof Error ? err.message : undefined
+        errorDetails: error instanceof Error ? error.message : undefined
       });
     }
-  }
+  });
   return { rawLines, parseErrors };
 }
 function isDisplayableLine(l) {
@@ -619,152 +524,1445 @@ function extractToolResult(tr) {
 }
 
 // src/server/api/session.ts
-async function handleSession(sessionId, encodedPath) {
-  const [{ session, slug }, sessions] = await Promise.all([
-    parseSession(sessionId, encodedPath),
-    listSessions(encodedPath)
-  ]);
-  session.planSessionId = findPlanSessionId(session.turns, slug, sessions, sessionId);
-  session.implSessionId = findImplSessionId(slug, sessions, sessionId);
+async function handleSession(sessionId, encodedPath, registry) {
+  const parsed = parseSessionId(sessionId);
+  if (!parsed.pluginId) {
+    return Response.json({ error: "sessionId must include plugin prefix (e.g. claude-code::<id>)" }, { status: 400 });
+  }
+  if (!parsed.rawSessionId) {
+    return Response.json({ error: "sessionId must include a raw session id after <plugin>::" }, { status: 400 });
+  }
+  const pluginId = parsed.pluginId;
+  const rawSessionId = parsed.rawSessionId;
+  const projects = await registry.discoverAllProjects();
+  const project = projects.find((p) => p.encodedPath === encodedPath);
+  if (!project)
+    return Response.json({ error: "Project not found" }, { status: 404 });
+  const source = project.sources.find((s) => s.pluginId === pluginId);
+  if (!source)
+    return Response.json({ error: "Plugin source not found" }, { status: 404 });
+  const plugin = registry.getPlugin(pluginId);
+  if (pluginId === "claude-code") {
+    const [{ session: session2, slug }, sessions] = await Promise.all([
+      loadClaudeSession(source.nativeId, rawSessionId),
+      plugin.listSessions(source.nativeId)
+    ]);
+    const planRawId = findPlanSessionId(session2.turns, slug, sessions, rawSessionId);
+    const implRawId = findImplSessionId(slug, sessions, rawSessionId);
+    session2.sessionId = encodeSessionId(pluginId, rawSessionId);
+    session2.planSessionId = planRawId ? encodeSessionId(pluginId, planRawId) : undefined;
+    session2.implSessionId = implRawId ? encodeSessionId(pluginId, implRawId) : undefined;
+    return Response.json({ session: session2 });
+  }
+  const session = await plugin.loadSession(source.nativeId, rawSessionId);
+  session.sessionId = encodeSessionId(pluginId, rawSessionId);
+  session.pluginId = pluginId;
   return Response.json({ session });
 }
 
 // src/server/api/sessions.ts
-async function handleSessions(encodedPath) {
-  const sessions = await listSessions(encodedPath);
+async function handleSessions(encodedPath, registry) {
+  const projects = await registry.discoverAllProjects();
+  const project = projects.find((p) => p.encodedPath === encodedPath);
+  if (!project)
+    return Response.json({ sessions: [] });
+  const sessions = await registry.listAllSessions(project);
   return Response.json({ sessions });
 }
 
-// src/server/parser/stats.ts
-import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "node:fs/promises";
+// src/server/registry.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join7 } from "node:path";
+
+// src/server/plugin-registry.ts
+function encodeResolvedPath(resolvedPath) {
+  if (resolvedPath.startsWith("/")) {
+    return resolvedPath.replace(/\//g, "-");
+  }
+  return resolvedPath.replace(/[/\\:]/g, "-");
+}
+
+class PluginRegistry {
+  plugins = new Map;
+  register(plugin) {
+    this.plugins.set(plugin.id, plugin);
+  }
+  getPlugin(id) {
+    const plugin = this.plugins.get(id);
+    if (!plugin)
+      throw new Error(`Plugin not found: ${id}`);
+    return plugin;
+  }
+  getAllPlugins() {
+    return [...this.plugins.values()];
+  }
+  async discoverAllProjects() {
+    const allProjects = [];
+    for (const plugin of this.plugins.values()) {
+      try {
+        const projects = await plugin.discoverProjects();
+        allProjects.push(...projects);
+      } catch {}
+    }
+    const byPath = new Map;
+    for (const p of allProjects) {
+      const existing = byPath.get(p.resolvedPath) ?? [];
+      existing.push(p);
+      byPath.set(p.resolvedPath, existing);
+    }
+    const merged = [];
+    for (const [resolvedPath, projects] of byPath) {
+      const totalSessions = projects.reduce((sum, p) => sum + p.sessionCount, 0);
+      const latestActivity = maxIso(projects.map((p) => p.lastActivity));
+      merged.push({
+        encodedPath: encodeResolvedPath(resolvedPath),
+        resolvedPath,
+        name: resolvedPath,
+        fullPath: resolvedPath,
+        sessionCount: totalSessions,
+        lastActivity: latestActivity,
+        sources: projects.map((p) => ({
+          pluginId: p.pluginId,
+          nativeId: p.nativeId
+        }))
+      });
+    }
+    sortByIsoDesc(merged, (project) => project.lastActivity);
+    return merged;
+  }
+  async listAllSessions(project) {
+    const allSessions = [];
+    for (const source of project.sources) {
+      const plugin = this.plugins.get(source.pluginId);
+      if (!plugin)
+        continue;
+      try {
+        const sessions = await plugin.listSessions(source.nativeId);
+        allSessions.push(...sessions.map((session) => ({
+          ...session,
+          sessionId: encodeSessionId(source.pluginId, session.sessionId),
+          pluginId: source.pluginId
+        })));
+      } catch {}
+    }
+    sortByIsoDesc(allSessions, (session) => session.timestamp);
+    return allSessions;
+  }
+}
+
+// src/server/plugins/claude-code/discovery.ts
 import { join as join4 } from "node:path";
-async function loadStatsCache() {
+
+// src/server/plugins/shared/discovery-utils.ts
+import { open, readdir, stat } from "node:fs/promises";
+import { join as join3 } from "node:path";
+async function readDirEntriesSafe(dir) {
   try {
-    const text = await readFile2(getStatsCachePath(), "utf-8");
-    const data = JSON.parse(text);
-    if (data.version !== 2)
-      return null;
-    return data;
+    return await readdir(dir, { withFileTypes: true });
   } catch {
-    return null;
+    return [];
   }
 }
-async function countProjects() {
+async function listFilesBySuffix(dir, suffix) {
   try {
-    const entries = await readdir2(getProjectsDir(), { withFileTypes: true });
-    return entries.filter((e) => e.isDirectory()).length;
+    const files = await readdir(dir);
+    return files.filter((file) => file.endsWith(suffix));
   } catch {
-    return 0;
+    return [];
   }
 }
-function toDateString(d) {
-  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
-}
-function todayDateString() {
-  return toDateString(new Date);
-}
-function isWithinLastWeek(dateStr) {
-  const now = new Date;
-  const weekAgo = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 7);
-  const weekAgoStr = `${weekAgo.getFullYear()}-${String(weekAgo.getMonth() + 1).padStart(2, "0")}-${String(weekAgo.getDate()).padStart(2, "0")}`;
-  return dateStr >= weekAgoStr;
-}
-async function countRecentSessions() {
-  const today = todayDateString();
-  const projectsDir = getProjectsDir();
-  let todaySessions = 0;
-  let thisWeekSessions = 0;
-  try {
-    const projectDirs = await readdir2(projectsDir, { withFileTypes: true });
-    for (const dir of projectDirs) {
-      if (!dir.isDirectory())
-        continue;
-      const projectPath = join4(projectsDir, dir.name);
-      const files = (await readdir2(projectPath)).filter((f) => f.endsWith(".jsonl"));
-      for (const file of files) {
-        const fileStat = await stat2(join4(projectPath, file));
-        const mtimeDate = toDateString(fileStat.mtime);
-        if (mtimeDate === today)
-          todaySessions++;
-        if (isWithinLastWeek(mtimeDate))
-          thisWeekSessions++;
-      }
+async function listFilesWithMtime(dir, suffix) {
+  const files = await listFilesBySuffix(dir, suffix);
+  const results = [];
+  for (const fileName of files) {
+    const fileStat = await stat(join3(dir, fileName)).catch(() => null);
+    const mtime = fileStat?.mtime.toISOString();
+    if (mtime) {
+      results.push({ fileName, mtime });
     }
-  } catch {}
-  return { todaySessions, thisWeekSessions };
+  }
+  sortByIsoDesc(results, (item) => item.mtime);
+  return results;
 }
-function buildFromCache(cache, projects) {
-  const today = todayDateString();
-  const todayEntry = cache.dailyActivity.find((d) => d.date === today);
-  const thisWeekEntries = cache.dailyActivity.filter((d) => isWithinLastWeek(d.date));
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let cacheReadTokens = 0;
-  let cacheCreationTokens = 0;
-  const models = {};
-  for (const [model, usage] of Object.entries(cache.modelUsage)) {
-    inputTokens += usage.inputTokens;
-    outputTokens += usage.outputTokens;
-    cacheReadTokens += usage.cacheReadInputTokens;
-    cacheCreationTokens += usage.cacheCreationInputTokens;
-    models[model] = {
-      inputTokens: usage.inputTokens,
-      outputTokens: usage.outputTokens,
-      cacheReadTokens: usage.cacheReadInputTokens,
-      cacheCreationTokens: usage.cacheCreationInputTokens
-    };
+async function readTextPrefix(filePath, maxBytes) {
+  const handle = await open(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(maxBytes);
+    const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+    return buffer.toString("utf-8", 0, bytesRead);
+  } finally {
+    await handle.close();
   }
-  const toolCalls = cache.dailyActivity.reduce((sum, d) => sum + d.toolCallCount, 0);
-  return {
-    projects,
-    sessions: cache.totalSessions,
-    messages: cache.totalMessages,
-    todaySessions: todayEntry?.sessionCount ?? 0,
-    thisWeekSessions: thisWeekEntries.reduce((sum, d) => sum + d.sessionCount, 0),
-    inputTokens,
-    outputTokens,
-    cacheReadTokens,
-    cacheCreationTokens,
-    toolCalls,
-    models
-  };
 }
-async function scanStats() {
-  const [cache, projects, recent] = await Promise.all([
-    loadStatsCache(),
-    countProjects(),
-    countRecentSessions()
-  ]);
-  const base = cache ? buildFromCache(cache, projects) : {
-    projects,
-    sessions: 0,
-    messages: 0,
-    todaySessions: 0,
-    thisWeekSessions: 0,
-    inputTokens: 0,
-    outputTokens: 0,
-    cacheReadTokens: 0,
-    cacheCreationTokens: 0,
-    toolCalls: 0,
-    models: {}
-  };
-  return {
-    ...base,
-    todaySessions: recent.todaySessions,
-    thisWeekSessions: recent.thisWeekSessions
-  };
+function decodeEncodedPath(encoded) {
+  if (encoded.startsWith("-")) {
+    const withSlashes = encoded.slice(1).replace(/-/g, "/");
+    if (process.platform === "win32" && /^[A-Za-z]\//.test(withSlashes)) {
+      return `${withSlashes[0]}:${withSlashes.slice(1)}`;
+    }
+    return `/${withSlashes}`;
+  }
+  return encoded.replace(/-/g, "/");
 }
 
-// src/server/api/stats.ts
-async function handleStats() {
-  const stats = await scanStats();
-  return Response.json({ stats });
+// src/server/plugins/claude-code/discovery.ts
+var CWD_SCAN_BYTES = 64 * 1024;
+var SESSION_META_SCAN_BYTES = 1024 * 1024;
+async function inspectProjectSessions(projectDir, sessionFiles) {
+  const lastActivity = sessionFiles[0]?.mtime || "";
+  let resolvedPath = "";
+  for (const sessionFile of sessionFiles) {
+    const filePath = join4(projectDir, sessionFile.fileName);
+    if (!resolvedPath) {
+      resolvedPath = await extractCwd(filePath);
+    }
+  }
+  return { lastActivity, resolvedPath };
 }
-
+async function discoverClaudeProjects() {
+  const projectsDir = getProjectsDir();
+  const entries = await readDirEntriesSafe(projectsDir);
+  const projects = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const projectDir = join4(projectsDir, entry.name);
+    const sessionFiles = await listFilesWithMtime(projectDir, ".jsonl");
+    if (sessionFiles.length === 0)
+      continue;
+    const projectInfo = await inspectProjectSessions(projectDir, sessionFiles);
+    const resolvedPath = projectInfo.resolvedPath || decodeEncodedPath(entry.name);
+    projects.push({
+      pluginId: "claude-code",
+      nativeId: entry.name,
+      resolvedPath,
+      displayName: resolvedPath,
+      sessionCount: sessionFiles.length,
+      lastActivity: projectInfo.lastActivity
+    });
+  }
+  sortByIsoDesc(projects, (project) => project.lastActivity);
+  return projects;
+}
+var PLAN_PREFIX2 = "Implement the following plan";
+async function listClaudeSessions(nativeId) {
+  const projectDir = join4(getProjectsDir(), nativeId);
+  const files = await listFilesBySuffix(projectDir, ".jsonl");
+  const sessions = [];
+  for (const file of files) {
+    const filePath = join4(projectDir, file);
+    const sessionId = file.replace(".jsonl", "");
+    const meta = await extractSessionMeta(filePath);
+    if (meta)
+      sessions.push({ sessionId, pluginId: "claude-code", ...meta });
+  }
+  classifySessionTypes(sessions);
+  sortByIsoDesc(sessions, (session) => session.timestamp);
+  return sessions;
+}
+function classifySessionTypes(sessions) {
+  const implSlugs = new Set;
+  for (const session of sessions) {
+    if (session.firstMessage.startsWith(PLAN_PREFIX2)) {
+      session.sessionType = "implementation";
+      if (session.slug)
+        implSlugs.add(session.slug);
+    }
+  }
+  for (const session of sessions) {
+    if (!session.sessionType && session.slug && implSlugs.has(session.slug)) {
+      session.sessionType = "plan";
+    }
+  }
+}
+async function extractCwd(filePath) {
+  try {
+    const text = await readTextPrefix(filePath, CWD_SCAN_BYTES);
+    let cwd = "";
+    iterateJsonl(text, ({ parsed }) => {
+      const obj = parsed;
+      if (obj.cwd) {
+        cwd = obj.cwd;
+        return false;
+      }
+    }, { maxLines: 20 });
+    return cwd;
+  } catch {
+    return "";
+  }
+}
+function extractTextFromContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block.type === "text" && "text" in block)
+        return block.text;
+    }
+  }
+  return "";
+}
+function isInternalMessage(text) {
+  return text.startsWith("<local-command") || text.startsWith("<command-name") || /^\[.+\]$/.test(text.trim());
+}
+function isMetaComplete(meta) {
+  return !!(meta.timestamp && meta.slug && meta.firstMessage && meta.model && meta.gitBranch);
+}
+function processMetaLine(obj, meta) {
+  if (obj.timestamp && !meta.timestamp)
+    meta.timestamp = obj.timestamp;
+  if (obj.slug && !meta.slug)
+    meta.slug = obj.slug;
+  if (obj.gitBranch && !meta.gitBranch)
+    meta.gitBranch = obj.gitBranch;
+  if (obj.message?.model && !meta.model)
+    meta.model = obj.message.model;
+  if (!meta.firstMessage && obj.type === "user" && !obj.isMeta && obj.message) {
+    const raw = extractTextFromContent(obj.message.content);
+    if (raw && !isInternalMessage(raw)) {
+      meta.firstMessage = cleanCommandMessage(raw).slice(0, 200);
+    }
+  }
+}
+async function extractSessionMeta(filePath) {
+  try {
+    const text = await readTextPrefix(filePath, SESSION_META_SCAN_BYTES);
+    const meta = {
+      timestamp: "",
+      slug: "",
+      firstMessage: "",
+      model: "",
+      gitBranch: ""
+    };
+    iterateJsonl(text, ({ parsed }) => {
+      const obj = parsed;
+      processMetaLine(obj, meta);
+      if (isMetaComplete(meta))
+        return false;
+    }, {
+      maxLines: 50,
+      onMalformed: () => {}
+    });
+    if (!meta.timestamp || !meta.firstMessage)
+      return null;
+    return {
+      timestamp: meta.timestamp,
+      slug: meta.slug || "unknown",
+      firstMessage: meta.firstMessage,
+      model: meta.model || "unknown",
+      gitBranch: meta.gitBranch || ""
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/server/plugins/claude-code/index.ts
+var claudeCodePlugin = {
+  id: "claude-code",
+  displayName: "Claude Code",
+  getDefaultDataDir: () => getClaudeCodeDir(),
+  discoverProjects: () => discoverClaudeProjects(),
+  listSessions: (nativeId) => listClaudeSessions(nativeId),
+  loadSession: (nativeId, sessionId) => loadClaudeSession(nativeId, sessionId).then((r) => r.session),
+  getResumeCommand: (sessionId) => `claude --resume ${sessionId}`
+};
+
+// src/server/plugins/codex-cli/discovery.ts
+import { readFile } from "node:fs/promises";
+
+// src/server/plugins/codex-cli/session-index.ts
+import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+var FIRST_LINE_SCAN_BYTES = 64 * 1024;
+function isCodexSessionMeta(obj) {
+  return typeof obj === "object" && obj !== null && "uuid" in obj && "cwd" in obj && "timestamps" in obj && typeof obj.uuid === "string" && typeof obj.cwd === "string";
+}
+function isNewFormatMeta(obj) {
+  return typeof obj === "object" && obj !== null && "type" in obj && obj.type === "session_meta" && "payload" in obj && typeof obj.payload === "object" && obj.payload !== null && typeof obj.payload.id === "string" && typeof obj.payload.cwd === "string";
+}
+function normalizeSessionMeta(parsed, fileMtimeEpoch) {
+  if (isCodexSessionMeta(parsed))
+    return parsed;
+  if (isNewFormatMeta(parsed)) {
+    const { payload } = parsed;
+    const isoTimestamp = payload.timestamp || parsed.timestamp;
+    const createdEpoch = isoTimestamp ? new Date(isoTimestamp).getTime() / 1000 : 0;
+    const updatedEpoch = fileMtimeEpoch ?? createdEpoch;
+    return {
+      uuid: payload.id,
+      cwd: payload.cwd,
+      timestamps: { created: createdEpoch, updated: updatedEpoch },
+      model: payload.model || payload.model_provider || "unknown",
+      provider_id: payload.model_provider || "unknown"
+    };
+  }
+  return null;
+}
+async function readFirstLine(filePath) {
+  const text = await readTextPrefix(filePath, FIRST_LINE_SCAN_BYTES);
+  const firstNewline = text.indexOf(`
+`);
+  const firstLine = firstNewline === -1 ? text : text.slice(0, firstNewline);
+  return firstLine.trim() ? firstLine : null;
+}
+async function parseSessionMeta(filePath) {
+  const firstLine = await readFirstLine(filePath);
+  if (!firstLine)
+    return null;
+  try {
+    const parsed = JSON.parse(firstLine);
+    const fileStat = await stat2(filePath).catch(() => null);
+    const fileMtimeEpoch = fileStat ? fileStat.mtime.getTime() / 1000 : undefined;
+    return normalizeSessionMeta(parsed, fileMtimeEpoch);
+  } catch {}
+  return null;
+}
+async function walkJsonlFiles(dir, visit) {
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = join5(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkJsonlFiles(fullPath, visit);
+      continue;
+    }
+    if (entry.name.endsWith(".jsonl")) {
+      await visit(fullPath, entry.name);
+    }
+  }
+}
+async function scanCodexSessions() {
+  const sessionsDir = join5(getCodexCliDir(), "sessions");
+  const sessions = [];
+  await walkJsonlFiles(sessionsDir, async (filePath) => {
+    const meta = await parseSessionMeta(filePath);
+    if (!meta)
+      return;
+    const fileStat = await stat2(filePath).catch(() => null);
+    if (!fileStat)
+      return;
+    sessions.push({
+      filePath,
+      meta,
+      mtime: fileStat.mtime.toISOString()
+    });
+  });
+  return sessions;
+}
+async function walkForFile(dir, match) {
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    const fullPath = join5(dir, entry.name);
+    if (!entry.isDirectory() && match(entry.name))
+      return fullPath;
+    if (entry.isDirectory()) {
+      const found = await walkForFile(fullPath, match);
+      if (found)
+        return found;
+    }
+  }
+  return null;
+}
+async function findCodexSessionFileById(sessionId) {
+  const sessionsDir = join5(getCodexCliDir(), "sessions");
+  const exactName = `${sessionId}.jsonl`;
+  const suffix = `-${sessionId}.jsonl`;
+  const filePath = await walkForFile(sessionsDir, (name) => name === exactName || name.endsWith(suffix));
+  if (!filePath)
+    return null;
+  const fileStat = await stat2(filePath).catch(() => null);
+  return fileStat?.isFile() ? filePath : null;
+}
+
+// src/server/plugins/codex-cli/discovery.ts
+var SESSION_TITLE_SCAN_BYTES = 256 * 1024;
+async function discoverCodexProjects() {
+  const sessions = await scanCodexSessions();
+  const byCwd = new Map;
+  for (const session of sessions) {
+    const existing = byCwd.get(session.meta.cwd);
+    if (existing) {
+      existing.push(session);
+    } else {
+      byCwd.set(session.meta.cwd, [session]);
+    }
+  }
+  const projects = [];
+  for (const [cwd, cwdSessions] of byCwd) {
+    let lastActivity = "";
+    for (const s of cwdSessions) {
+      if (s.mtime > lastActivity)
+        lastActivity = s.mtime;
+    }
+    projects.push({
+      pluginId: "codex-cli",
+      nativeId: cwd,
+      resolvedPath: cwd,
+      displayName: cwd,
+      sessionCount: cwdSessions.length,
+      lastActivity
+    });
+  }
+  sortByIsoDesc(projects, (project) => project.lastActivity);
+  return projects;
+}
+function extractFirstUserMessage(text) {
+  let message = null;
+  iterateJsonl(text, ({ parsed }) => {
+    const event = parsed;
+    if (event.type === "item.completed" && event.item?.type === "agent_message" && event.item.text) {
+      message = event.item.text.slice(0, 200);
+      return false;
+    }
+    if (event.type === "event_msg" && event.payload?.type === "user_message") {
+      const text2 = event.payload.message || event.payload.text;
+      if (typeof text2 === "string" && text2) {
+        message = text2.slice(0, 200);
+        return false;
+      }
+    }
+  }, { startAt: 1 });
+  return message;
+}
+async function listCodexSessions(nativeId) {
+  const allSessions = await scanCodexSessions();
+  const matching = allSessions.filter((s) => s.meta.cwd === nativeId);
+  const sessions = [];
+  for (const s of matching) {
+    let firstMessage = s.meta.name || "";
+    if (!firstMessage) {
+      const prefix = await readTextPrefix(s.filePath, SESSION_TITLE_SCAN_BYTES);
+      firstMessage = extractFirstUserMessage(prefix) || "";
+      if (!firstMessage) {
+        const fullText = await readFile(s.filePath, "utf-8");
+        firstMessage = extractFirstUserMessage(fullText) || "";
+      }
+      firstMessage ||= "Codex session";
+    }
+    const timestamp = epochSecondsToIso(s.meta.timestamps.created);
+    sessions.push({
+      sessionId: s.meta.uuid,
+      timestamp,
+      slug: s.meta.uuid,
+      firstMessage,
+      model: s.meta.model || "unknown",
+      gitBranch: "",
+      pluginId: "codex-cli"
+    });
+  }
+  sortByIsoDesc(sessions, (session) => session.timestamp);
+  return sessions;
+}
+
+// src/server/plugins/codex-cli/parser.ts
+import { readFile as readFile2 } from "node:fs/promises";
+function normalizeEventMsg(payload) {
+  switch (payload.type) {
+    case "task_started":
+      return { type: "turn.started" };
+    case "user_message":
+      return { type: "user_message", text: payload.message || payload.text || "" };
+    case "agent_message":
+      return {
+        type: "item.completed",
+        item: { type: "agent_message", text: payload.message || payload.text || "" }
+      };
+    case "agent_reasoning":
+      return {
+        type: "item.completed",
+        item: { type: "reasoning", text: payload.text || "" }
+      };
+    case "token_count":
+      return {
+        type: "turn.completed",
+        usage: {
+          input_tokens: payload.input_tokens,
+          cached_input_tokens: payload.cached_input_tokens,
+          output_tokens: payload.output_tokens
+        }
+      };
+    case "task_complete":
+      return { type: "turn.completed" };
+    default:
+      return null;
+  }
+}
+function parseArguments(args) {
+  if (!args)
+    return {};
+  if (typeof args === "string") {
+    try {
+      return JSON.parse(args);
+    } catch {
+      return { raw: args };
+    }
+  }
+  return args;
+}
+function normalizeResponseItem(payload) {
+  if (payload.type === "function_call" || payload.type === "custom_tool_call") {
+    const name = payload.name || "unknown";
+    const args = parseArguments(payload.arguments);
+    return {
+      type: "item.completed",
+      item: {
+        type: "command_execution",
+        command: name,
+        aggregated_output: "",
+        exit_code: 0
+      },
+      callId: payload.call_id,
+      toolName: name,
+      toolInput: args
+    };
+  }
+  if (payload.type === "function_call_output" || payload.type === "custom_tool_call_output") {
+    return {
+      type: "tool_output",
+      callId: payload.call_id,
+      text: payload.output || ""
+    };
+  }
+  return null;
+}
+var OLD_FORMAT_TYPES = new Set([
+  "turn.started",
+  "turn.completed",
+  "item.completed",
+  "thread.started"
+]);
+function normalizeEvent(raw) {
+  if (typeof raw !== "object" || raw === null || !("type" in raw))
+    return null;
+  const obj = raw;
+  if (OLD_FORMAT_TYPES.has(obj.type))
+    return raw;
+  const payload = obj.payload;
+  if (!payload)
+    return null;
+  if (obj.type === "event_msg")
+    return normalizeEventMsg(payload);
+  if (obj.type === "response_item")
+    return normalizeResponseItem(payload);
+  return null;
+}
+function buildToolCallFromItem(item, nextToolUseId) {
+  switch (item.type) {
+    case "command_execution":
+      return {
+        toolUseId: nextToolUseId(),
+        name: "command_execution",
+        input: { command: item.command },
+        result: item.aggregated_output || "",
+        isError: item.exit_code !== undefined && item.exit_code !== 0
+      };
+    case "file_change":
+      return {
+        toolUseId: nextToolUseId(),
+        name: "file_change",
+        input: { changes: item.changes },
+        result: "",
+        isError: false
+      };
+    case "mcp_tool_call":
+      return {
+        toolUseId: nextToolUseId(),
+        name: item.tool,
+        input: item.arguments,
+        result: item.result || "",
+        isError: false
+      };
+    case "web_search":
+      return {
+        toolUseId: nextToolUseId(),
+        name: "web_search",
+        input: { query: item.query },
+        result: "",
+        isError: false
+      };
+    default:
+      return null;
+  }
+}
+function createUserTurn(text, timestamp, uuid) {
+  return {
+    kind: "user",
+    uuid,
+    timestamp,
+    text
+  };
+}
+function createAssistantTurn2(model, timestamp, uuid) {
+  return {
+    kind: "assistant",
+    uuid,
+    timestamp,
+    model,
+    contentBlocks: []
+  };
+}
+function itemToContentBlock(item, nextToolUseId) {
+  if (item.type === "agent_message") {
+    return { type: "text", text: item.text };
+  }
+  if (item.type === "reasoning") {
+    return { type: "thinking", block: { text: item.text } };
+  }
+  const toolCall = buildToolCallFromItem(item, nextToolUseId);
+  if (toolCall) {
+    return { type: "tool_call", call: toolCall };
+  }
+  return null;
+}
+function handleTurnStarted(state, event, timestamp, nextUserTurnId) {
+  flushAssistant2(state);
+  state.turnCount++;
+  if (state.turnCount > 1) {
+    state.turns.push(createUserTurn(event.text || "", timestamp, nextUserTurnId()));
+  }
+}
+function handleTurnCompleted(state, event) {
+  if (state.currentAssistant && event.usage) {
+    const usage = {
+      inputTokens: event.usage.input_tokens ?? 0,
+      outputTokens: event.usage.output_tokens ?? 0,
+      cacheReadTokens: event.usage.cached_input_tokens
+    };
+    state.currentAssistant.usage = usage;
+  }
+  flushAssistant2(state);
+}
+function handleItemCompleted(state, event, model, timestamp, nextToolUseId, nextAssistantTurnId) {
+  if (!event.item)
+    return;
+  if (!state.currentAssistant) {
+    state.currentAssistant = createAssistantTurn2(model, timestamp, nextAssistantTurnId());
+  }
+  const block = itemToContentBlock(event.item, nextToolUseId);
+  if (block) {
+    state.currentAssistant.contentBlocks.push(block);
+  }
+}
+function flushAssistant2(state) {
+  if (state.currentAssistant && state.currentAssistant.contentBlocks.length > 0) {
+    state.turns.push(state.currentAssistant);
+  }
+  state.currentAssistant = null;
+}
+function handleUserMessage(state, event) {
+  for (let i = state.turns.length - 1;i >= 0; i--) {
+    const turn = state.turns[i];
+    if (turn.kind === "user" && !turn.text) {
+      turn.text = event.text || "";
+      return;
+    }
+  }
+  if (state.turnCount === 0) {
+    state.turnCount++;
+  }
+  state.turns.push(createUserTurn(event.text || "", "", "codex-user-first"));
+}
+function handleToolOutput(state, event) {
+  if (!event.callId)
+    return;
+  const toolCall = state.pendingToolCalls.get(event.callId);
+  if (toolCall) {
+    toolCall.result = event.text || "";
+  }
+}
+function handleGenericToolCall(state, event, model, timestamp, nextToolUseId, nextAssistantTurnId) {
+  if (!state.currentAssistant) {
+    state.currentAssistant = createAssistantTurn2(model, timestamp, nextAssistantTurnId());
+  }
+  const toolCall = {
+    toolUseId: event.callId || nextToolUseId(),
+    name: event.toolName || "unknown",
+    input: event.toolInput || {},
+    result: "",
+    isError: false
+  };
+  if (event.callId) {
+    state.pendingToolCalls.set(event.callId, toolCall);
+  }
+  state.currentAssistant.contentBlocks.push({ type: "tool_call", call: toolCall });
+}
+function dispatchEvent(state, event, model, timestamp, nextToolUseId, nextUserTurnId, nextAssistantTurnId) {
+  switch (event.type) {
+    case "turn.started":
+      handleTurnStarted(state, event, timestamp, nextUserTurnId);
+      break;
+    case "turn.completed":
+      handleTurnCompleted(state, event);
+      break;
+    case "item.completed":
+      if (event.toolName) {
+        handleGenericToolCall(state, event, model, timestamp, nextToolUseId, nextAssistantTurnId);
+      } else {
+        handleItemCompleted(state, event, model, timestamp, nextToolUseId, nextAssistantTurnId);
+      }
+      break;
+    case "user_message":
+      handleUserMessage(state, event);
+      break;
+    case "tool_output":
+      handleToolOutput(state, event);
+      break;
+  }
+}
+function buildCodexTurns(events, model, timestamp) {
+  let toolUseCounter = 0;
+  let userTurnCounter = 0;
+  let assistantTurnCounter = 0;
+  const nextToolUseId = () => {
+    toolUseCounter++;
+    return `codex-tool-${toolUseCounter}`;
+  };
+  const nextUserTurnId = () => {
+    userTurnCounter++;
+    return `codex-user-${userTurnCounter}`;
+  };
+  const nextAssistantTurnId = () => {
+    assistantTurnCounter++;
+    return `codex-assistant-${assistantTurnCounter}`;
+  };
+  const state = {
+    turns: [],
+    currentAssistant: null,
+    turnCount: 0,
+    pendingToolCalls: new Map
+  };
+  for (const event of events) {
+    dispatchEvent(state, event, model, timestamp, nextToolUseId, nextUserTurnId, nextAssistantTurnId);
+  }
+  flushAssistant2(state);
+  return state.turns;
+}
+async function loadCodexSession(_nativeId, sessionId) {
+  const filePath = await findCodexSessionFileById(sessionId);
+  if (!filePath) {
+    return {
+      sessionId,
+      project: _nativeId,
+      turns: [],
+      pluginId: "codex-cli"
+    };
+  }
+  const text = await readFile2(filePath, "utf-8");
+  let meta = null;
+  const events = [];
+  iterateJsonl(text, ({ parsed, lineIndex }) => {
+    if (lineIndex === 0) {
+      const normalized = normalizeSessionMeta(parsed);
+      if (normalized) {
+        meta = normalized;
+        return;
+      }
+    }
+    const event = normalizeEvent(parsed);
+    if (event) {
+      events.push(event);
+    }
+  });
+  const metaInfo = normalizeSessionMeta(meta);
+  const model = metaInfo?.model || "unknown";
+  const timestamp = metaInfo ? epochSecondsToIso(metaInfo.timestamps.created) : "";
+  const turns = buildCodexTurns(events, model, timestamp);
+  return {
+    sessionId,
+    project: _nativeId,
+    turns,
+    pluginId: "codex-cli"
+  };
+}
+
+// src/server/plugins/codex-cli/index.ts
+var codexCliPlugin = {
+  id: "codex-cli",
+  displayName: "Codex",
+  getDefaultDataDir: () => getCodexCliDir(),
+  discoverProjects: () => discoverCodexProjects(),
+  listSessions: (nativeId) => listCodexSessions(nativeId),
+  loadSession: (nativeId, sessionId) => loadCodexSession(nativeId, sessionId),
+  getResumeCommand: (sessionId) => `codex resume ${sessionId}`
+};
+
+// src/server/plugins/shared/json-utils.ts
+function tryParseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return;
+  }
+}
+
+// src/server/plugins/opencode/db.ts
+import { existsSync } from "node:fs";
+import { join as join6 } from "node:path";
+function getOpenCodeDbPath() {
+  return join6(getOpenCodeDir(), "opencode.db");
+}
+async function openOpenCodeDb() {
+  const dbPath = getOpenCodeDbPath();
+  if (!existsSync(dbPath))
+    return null;
+  try {
+    const sqlite = await import("bun:sqlite");
+    return new sqlite.Database(dbPath, { readonly: true });
+  } catch {
+    return null;
+  }
+}
+
+// src/server/plugins/opencode/discovery.ts
+function getColumns(db, tableName) {
+  const rows = db.query(`PRAGMA table_info(${tableName})`).all();
+  return new Set(rows.map((r) => r.name));
+}
+function inspectSchema(db) {
+  const tableRows = db.query("SELECT name FROM sqlite_master WHERE type='table'").all();
+  const tables = new Set(tableRows.map((row) => row.name));
+  const hasSessionTable = tables.has("session");
+  const hasMessageTable = tables.has("message");
+  const hasPartTable = tables.has("part");
+  const hasProjectTable = tables.has("project");
+  const hasRequiredTables = hasSessionTable && hasMessageTable && hasPartTable;
+  return {
+    hasProjectTable,
+    hasRequiredTables,
+    projectColumns: hasProjectTable ? getColumns(db, "project") : new Set,
+    sessionColumns: hasSessionTable ? getColumns(db, "session") : new Set
+  };
+}
+async function discoverOpenCodeProjects() {
+  const db = await openOpenCodeDb();
+  if (!db)
+    return [];
+  try {
+    const schema = inspectSchema(db);
+    if (!schema.hasRequiredTables)
+      return [];
+    if (schema.hasProjectTable) {
+      return discoverFromProjectTable(db, schema);
+    }
+    return discoverFromSessions(db, schema);
+  } catch {
+    return [];
+  } finally {
+    db.close();
+  }
+}
+function discoverFromProjectTable(db, schema) {
+  const hasWorktree = schema.projectColumns.has("worktree");
+  const hasName = schema.projectColumns.has("name");
+  if (!hasWorktree) {
+    return discoverFromSessions(db, schema);
+  }
+  const selectName = hasName ? "p.name" : "NULL as name";
+  const rows = db.query(`SELECT p.id, p.worktree, ${selectName},
+              count(s.id) as session_count,
+              coalesce(max(s.time_updated), max(s.time_created), p.time_created) as last_activity
+       FROM project p
+       LEFT JOIN session s ON s.project_id = p.id
+       GROUP BY p.id
+       HAVING session_count > 0
+       ORDER BY last_activity DESC`).all();
+  return rows.map((row) => ({
+    pluginId: "opencode",
+    nativeId: row.id,
+    resolvedPath: row.worktree,
+    displayName: row.name || row.worktree,
+    sessionCount: row.session_count,
+    lastActivity: epochMsToIso(row.last_activity)
+  }));
+}
+function discoverFromSessions(db, schema) {
+  const hasDirectory = schema.sessionColumns.has("directory");
+  const hasProjectId = schema.sessionColumns.has("project_id");
+  if (!hasDirectory && !hasProjectId)
+    return [];
+  const groupCol = hasDirectory ? "directory" : "project_id";
+  const rows = db.query(`SELECT ${groupCol} as group_key,
+              count(*) as session_count,
+              coalesce(max(time_updated), max(time_created)) as last_activity
+       FROM session
+       GROUP BY ${groupCol}
+       ORDER BY last_activity DESC`).all();
+  return rows.map((row) => ({
+    pluginId: "opencode",
+    nativeId: row.group_key,
+    resolvedPath: row.group_key,
+    displayName: row.group_key,
+    sessionCount: row.session_count,
+    lastActivity: epochMsToIso(row.last_activity)
+  }));
+}
+function querySessionRows(db, schema, nativeId) {
+  const titleCol = schema.sessionColumns.has("title") ? "title" : "''";
+  const slugCol = schema.sessionColumns.has("slug") ? "slug" : "id";
+  const whereCol = schema.hasProjectTable ? "project_id" : "directory";
+  return db.query(`SELECT id, project_id, directory, ${titleCol} as title,
+              ${slugCol} as slug, time_created, time_updated
+       FROM session
+       WHERE ${whereCol} = ?
+       ORDER BY time_created DESC`).all(nativeId);
+}
+function sessionRowToSummary(db, row) {
+  const preview = getSessionPreview(db, row.id);
+  const firstMessage = row.title || preview.firstMessage || "OpenCode session";
+  return {
+    sessionId: row.id,
+    timestamp: epochMsToIso(row.time_created),
+    slug: row.slug,
+    firstMessage,
+    model: preview.model || "unknown",
+    gitBranch: "",
+    pluginId: "opencode"
+  };
+}
+async function listOpenCodeSessions(nativeId) {
+  const db = await openOpenCodeDb();
+  if (!db)
+    return [];
+  try {
+    const schema = inspectSchema(db);
+    if (!schema.hasRequiredTables)
+      return [];
+    const sessionRows = querySessionRows(db, schema, nativeId);
+    return sessionRows.map((row) => sessionRowToSummary(db, row));
+  } catch {
+    return [];
+  } finally {
+    db.close();
+  }
+}
+function getSessionPreview(db, sessionId) {
+  const preview = { firstMessage: "", model: "" };
+  const msgRow = db.query(`SELECT id, session_id, time_created, data FROM message
+       WHERE session_id = ?
+       ORDER BY time_created ASC
+       LIMIT 10`).all(sessionId);
+  for (const msg of msgRow) {
+    const data = tryParseJson(msg.data);
+    if (!data)
+      continue;
+    assignPreviewModel(preview, data);
+    assignPreviewFirstMessage(preview, data, db, msg.id);
+    if (preview.firstMessage && preview.model)
+      break;
+  }
+  return preview;
+}
+function assignPreviewModel(preview, data) {
+  if (preview.model || data.role !== "assistant" || !data.modelID)
+    return;
+  preview.model = data.modelID;
+}
+function assignPreviewFirstMessage(preview, data, db, messageId) {
+  if (preview.firstMessage || data.role !== "user")
+    return;
+  preview.firstMessage = getFirstUserTextPart(db, messageId);
+}
+function getFirstUserTextPart(db, messageId) {
+  const parts = db.query("SELECT data FROM part WHERE message_id = ? ORDER BY id ASC").all(messageId);
+  for (const part of parts) {
+    const partData = tryParseJson(part.data);
+    if (partData?.type === "text" && partData.text) {
+      return partData.text.slice(0, 200);
+    }
+  }
+  return "";
+}
+
+// src/server/plugins/opencode/parser.ts
+function partToContentBlock(partData, nextToolUseId) {
+  switch (partData.type) {
+    case "text": {
+      const textPart = partData;
+      if (textPart.ignored)
+        return null;
+      return { type: "text", text: textPart.text };
+    }
+    case "reasoning": {
+      const reasoningPart = partData;
+      return { type: "thinking", block: { text: reasoningPart.text } };
+    }
+    case "tool": {
+      const toolPart = partData;
+      return { type: "tool_call", call: buildToolCall2(toolPart, nextToolUseId) };
+    }
+    default:
+      return null;
+  }
+}
+function buildToolCall2(toolPart, nextToolUseId) {
+  const state = toolPart.state;
+  const toolId = toolPart.callID || nextToolUseId();
+  switch (state.status) {
+    case "completed":
+      return {
+        toolUseId: toolId,
+        name: toolPart.tool,
+        input: state.input,
+        result: state.output,
+        isError: false
+      };
+    case "error":
+      return {
+        toolUseId: toolId,
+        name: toolPart.tool,
+        input: state.input,
+        result: state.error,
+        isError: true
+      };
+    case "pending":
+    case "running":
+      return {
+        toolUseId: toolId,
+        name: toolPart.tool,
+        input: state.input,
+        result: "[Tool execution was interrupted]",
+        isError: true
+      };
+  }
+}
+function createUserTurn2(text, timestamp, uuid) {
+  return {
+    kind: "user",
+    uuid,
+    timestamp,
+    text
+  };
+}
+function createAssistantTurn3(model, timestamp, uuid, contentBlocks, usage, stopReason) {
+  return {
+    kind: "assistant",
+    uuid,
+    timestamp,
+    model,
+    contentBlocks,
+    usage,
+    stopReason
+  };
+}
+function collectUserText(parts) {
+  const texts = [];
+  for (const part of parts) {
+    if (part.type === "text" && !part.ignored) {
+      texts.push(part.text);
+    }
+  }
+  return texts.join(`
+`);
+}
+function collectContentBlocks(parts, nextToolUseId) {
+  const blocks = [];
+  for (const part of parts) {
+    const block = partToContentBlock(part, nextToolUseId);
+    if (block)
+      blocks.push(block);
+  }
+  return blocks;
+}
+function tokensToUsage(tokens) {
+  if (!tokens)
+    return;
+  return {
+    inputTokens: tokens.input,
+    outputTokens: tokens.output,
+    cacheReadTokens: tokens.cache?.read,
+    cacheCreationTokens: tokens.cache?.write
+  };
+}
+function extractStepFinishUsage(parts) {
+  for (const part of parts) {
+    if (part.type === "step-finish") {
+      const sf = part;
+      return {
+        inputTokens: sf.tokens.input,
+        outputTokens: sf.tokens.output,
+        cacheReadTokens: sf.tokens.cache?.read,
+        cacheCreationTokens: sf.tokens.cache?.write
+      };
+    }
+  }
+  return;
+}
+function buildUserTurn(msg, timestamp) {
+  return createUserTurn2(collectUserText(msg.parts), timestamp, msg.id);
+}
+function buildAssistantTurnFromMsg(msg, timestamp, nextToolUseId) {
+  const data = msg.data;
+  const model = data.modelID || "unknown";
+  const contentBlocks = collectContentBlocks(msg.parts, nextToolUseId);
+  const usage = tokensToUsage(data.tokens) ?? extractStepFinishUsage(msg.parts);
+  return createAssistantTurn3(model, timestamp, msg.id, contentBlocks, usage, data.finish);
+}
+function buildOpenCodeTurns(messages) {
+  let toolUseCounter = 0;
+  const nextToolUseId = () => {
+    toolUseCounter++;
+    return `opencode-tool-${toolUseCounter}`;
+  };
+  const turns = [];
+  for (const msg of messages) {
+    const timestamp = epochMsToIso(msg.timeCreated);
+    if (msg.data.role === "user") {
+      turns.push(buildUserTurn(msg, timestamp));
+    } else if (msg.data.role === "assistant") {
+      turns.push(buildAssistantTurnFromMsg(msg, timestamp, nextToolUseId));
+    }
+  }
+  return turns;
+}
+function groupPartsByMessage(partRows) {
+  const map = new Map;
+  for (const part of partRows) {
+    const existing = map.get(part.message_id);
+    if (existing) {
+      existing.push(part);
+    } else {
+      map.set(part.message_id, [part]);
+    }
+  }
+  return map;
+}
+function parsePartRows(rawParts) {
+  const parts = [];
+  for (const rawPart of rawParts) {
+    const parsedPart = tryParseJson(rawPart.data);
+    if (parsedPart) {
+      parts.push(parsedPart);
+    }
+  }
+  return parts;
+}
+function buildMessagesFromRows(messageRows, partsByMessage) {
+  const messages = [];
+  for (const row of messageRows) {
+    const data = tryParseJson(row.data);
+    if (data) {
+      const rawParts = partsByMessage.get(row.id) ?? [];
+      messages.push({
+        id: row.id,
+        data,
+        timeCreated: row.time_created,
+        parts: parsePartRows(rawParts)
+      });
+    }
+  }
+  return messages;
+}
+function loadSessionFromDb(db, nativeId, sessionId) {
+  const sessionRow = db.query("SELECT directory FROM session WHERE id = ?").get(sessionId);
+  const project = sessionRow?.directory || nativeId;
+  const messageRows = db.query(`SELECT id, session_id, time_created, data
+       FROM message WHERE session_id = ? ORDER BY time_created ASC`).all(sessionId);
+  if (messageRows.length === 0) {
+    return emptySession(project, sessionId);
+  }
+  const partRows = db.query(`SELECT id, message_id, session_id, time_created, data
+       FROM part WHERE session_id = ? ORDER BY message_id, id ASC`).all(sessionId);
+  const partsByMessage = groupPartsByMessage(partRows);
+  const messages = buildMessagesFromRows(messageRows, partsByMessage);
+  const turns = buildOpenCodeTurns(messages);
+  return { sessionId, project, turns, pluginId: "opencode" };
+}
+async function loadOpenCodeSession(nativeId, sessionId) {
+  const db = await openOpenCodeDb();
+  if (!db) {
+    return emptySession(nativeId, sessionId);
+  }
+  try {
+    return loadSessionFromDb(db, nativeId, sessionId);
+  } catch {
+    return emptySession(nativeId, sessionId);
+  } finally {
+    db.close();
+  }
+}
+function emptySession(project, sessionId) {
+  return {
+    sessionId,
+    project,
+    turns: [],
+    pluginId: "opencode"
+  };
+}
+
+// src/server/plugins/opencode/index.ts
+var openCodePlugin = {
+  id: "opencode",
+  displayName: "OpenCode",
+  getDefaultDataDir: () => getOpenCodeDir(),
+  discoverProjects: () => discoverOpenCodeProjects(),
+  listSessions: (nativeId) => listOpenCodeSessions(nativeId),
+  loadSession: (nativeId, sessionId) => loadOpenCodeSession(nativeId, sessionId)
+};
+
+// src/server/registry.ts
+function createRegistry() {
+  const registry = new PluginRegistry;
+  const claudeDir = claudeCodePlugin.getDefaultDataDir();
+  if (claudeDir && existsSync2(claudeDir)) {
+    registry.register(claudeCodePlugin);
+  }
+  const codexDir = codexCliPlugin.getDefaultDataDir();
+  if (codexDir && existsSync2(codexDir)) {
+    registry.register(codexCliPlugin);
+  }
+  const openCodeDir2 = openCodePlugin.getDefaultDataDir();
+  if (openCodeDir2 && existsSync2(join7(openCodeDir2, "opencode.db"))) {
+    registry.register(openCodePlugin);
+  }
+  return registry;
+}
+
+// src/server/parser/stats.ts
+function emptyStats(projects = 0) {
+  return {
+    projects,
+    sessions: 0,
+    messages: 0,
+    todaySessions: 0,
+    thisWeekSessions: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+    toolCalls: 0,
+    models: {}
+  };
+}
+function toDateString(d) {
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function countRecentSessions(sessions) {
+  const today = toDateString(new Date);
+  const now = new Date;
+  const weekAgo = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 7);
+  const weekAgoStr = toDateString(weekAgo);
+  let todaySessions = 0;
+  let thisWeekSessions = 0;
+  for (const session of sessions) {
+    const d = new Date(session.timestamp);
+    if (Number.isNaN(d.getTime()))
+      continue;
+    const sessionDay = toDateString(d);
+    if (sessionDay === today)
+      todaySessions++;
+    if (sessionDay >= weekAgoStr)
+      thisWeekSessions++;
+  }
+  return { todaySessions, thisWeekSessions };
+}
+function ensureModelUsage(models, model) {
+  if (!models[model]) {
+    models[model] = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0
+    };
+  }
+  return models[model];
+}
+function countVisibleMessages(turns) {
+  return turns.filter((turn) => turn.kind !== "parse_error").length;
+}
+async function collectSessionsWithProjects(registry, stats) {
+  const projects = await registry.discoverAllProjects().catch(() => []);
+  stats.projects = projects.length;
+  const sessionsWithProject = [];
+  for (const project of projects) {
+    const sessions = await registry.listAllSessions(project).catch(() => []);
+    stats.sessions += sessions.length;
+    for (const session of sessions) {
+      sessionsWithProject.push({ project, session });
+    }
+  }
+  return sessionsWithProject;
+}
+function applyRecentSessionStats(stats, sessionsWithProject) {
+  const recent = countRecentSessions(sessionsWithProject.map((item) => item.session));
+  stats.todaySessions = recent.todaySessions;
+  stats.thisWeekSessions = recent.thisWeekSessions;
+}
+async function loadSessionForStats(registry, project, session) {
+  if (!session.pluginId)
+    return null;
+  const source = project.sources.find((item) => item.pluginId === session.pluginId);
+  if (!source)
+    return null;
+  const plugin = registry.getPlugin(session.pluginId);
+  const { rawSessionId } = parseSessionId(session.sessionId);
+  const loaded = await plugin.loadSession(source.nativeId, rawSessionId).catch(() => null);
+  return loaded?.turns ?? null;
+}
+function applyUsageStats(stats, modelUsage, usage) {
+  stats.inputTokens += usage.inputTokens;
+  stats.outputTokens += usage.outputTokens;
+  stats.cacheReadTokens += usage.cacheReadTokens ?? 0;
+  stats.cacheCreationTokens += usage.cacheCreationTokens ?? 0;
+  modelUsage.inputTokens += usage.inputTokens;
+  modelUsage.outputTokens += usage.outputTokens;
+  modelUsage.cacheReadTokens += usage.cacheReadTokens ?? 0;
+  modelUsage.cacheCreationTokens += usage.cacheCreationTokens ?? 0;
+}
+function applyTurnStats(stats, turns, fallbackModel) {
+  stats.messages += countVisibleMessages(turns);
+  for (const turn of turns) {
+    if (turn.kind !== "assistant")
+      continue;
+    stats.toolCalls += turn.contentBlocks.filter((block) => block.type === "tool_call").length;
+    const modelUsage = ensureModelUsage(stats.models, turn.model || fallbackModel || "unknown");
+    if (!turn.usage)
+      continue;
+    applyUsageStats(stats, modelUsage, turn.usage);
+  }
+}
+async function computeStats(registry) {
+  const stats = emptyStats();
+  const sessionsWithProject = await collectSessionsWithProjects(registry, stats);
+  applyRecentSessionStats(stats, sessionsWithProject);
+  for (const item of sessionsWithProject) {
+    const turns = await loadSessionForStats(registry, item.project, item.session);
+    if (!turns)
+      continue;
+    applyTurnStats(stats, turns, item.session.model);
+  }
+  return stats;
+}
+async function scanStats(registry = createRegistry()) {
+  return computeStats(registry);
+}
+
+// src/server/api/stats.ts
+async function handleStats() {
+  const stats = await scanStats();
+  return Response.json({ stats });
+}
+
 // src/server/api/subagent.ts
 async function handleSubAgent(sessionId, agentId, encodedPath) {
+  const parsed = parseSessionId(sessionId);
+  if (parsed.pluginId !== "claude-code") {
+    return Response.json({ error: "sessionId must include claude-code prefix for sub-agent sessions" }, { status: 400 });
+  }
+  if (!parsed.rawSessionId) {
+    return Response.json({ error: "sessionId must include a raw session id after claude-code::" }, { status: 400 });
+  }
   try {
-    const session = await parseSubAgentSession(sessionId, encodedPath, agentId);
+    const session = await parseSubAgentSession(parsed.rawSessionId, encodedPath, agentId);
     return Response.json({ session });
   } catch {
     return Response.json({ error: "Sub-agent not found" }, { status: 404 });
@@ -773,8 +1971,8 @@ async function handleSubAgent(sessionId, agentId, encodedPath) {
 
 // src/server/version.ts
 var appVersion = {
-  version: "1.1.0",
-  commitHash: "b126d9d"
+  version: "2.0.0",
+  commitHash: "834a598"
 };
 
 // src/server/api/version.ts
@@ -783,6 +1981,17 @@ function handleVersion() {
 }
 
 // src/server/cli.ts
+function parseDirFlag(argv, flag, setter) {
+  const idx = argv.indexOf(flag);
+  if (idx === -1)
+    return;
+  const dir = argv[idx + 1];
+  if (!dir || dir.startsWith("-")) {
+    console.error(`Error: ${flag} requires a path argument.`);
+    process.exit(1);
+  }
+  setter(dir);
+}
 function parseCliArgs(argv) {
   const portIdx = argv.indexOf("--port");
   let port = 3583;
@@ -798,45 +2007,52 @@ function parseCliArgs(argv) {
       process.exit(1);
     }
   }
-  const acceptRisks = argv.includes("--accept-risks");
-  const showHelp = argv.includes("--help") || argv.includes("-h");
-  const claudeCodeDirIdx = argv.indexOf("--claude-code-dir");
-  if (claudeCodeDirIdx !== -1) {
-    const dir = argv[claudeCodeDirIdx + 1];
-    if (!dir || dir.startsWith("-")) {
-      console.error("Error: --claude-code-dir requires a path argument.");
+  const hostIdx = argv.indexOf("--host");
+  let host = "127.0.0.1";
+  if (hostIdx !== -1) {
+    const val = argv[hostIdx + 1];
+    if (!val || val.startsWith("-")) {
+      console.error("Error: --host requires an address argument.");
       process.exit(1);
     }
-    setClaudeCodeDir(dir);
+    host = val;
   }
-  return { port, acceptRisks, showHelp };
+  const acceptRisks = argv.includes("--accept-risks");
+  const showHelp = argv.includes("--help") || argv.includes("-h");
+  parseDirFlag(argv, "--claude-code-dir", setClaudeCodeDir);
+  parseDirFlag(argv, "--codex-cli-dir", setCodexCliDir);
+  parseDirFlag(argv, "--opencode-dir", setOpenCodeDir);
+  return { port, host, acceptRisks, showHelp };
 }
 function showHelpText() {
   const dim = "\x1B[2m";
   const reset = "\x1B[0m";
   console.log(`
-Klovi — a web viewer for Claude Code sessions
+Klovi — a web viewer for AI coding sessions
 ${dim}by cookielab.io${reset}
 
 Usage:
   klovi [options]
 
 Options:
-  --accept-risks           Skip the startup security warning
-  --port <number>          Server port (default: 3583)
+  --accept-risks             Skip the startup security warning
+  --host <address>           Bind address (default: 127.0.0.1)
+  --port <number>            Server port (default: 3583)
   --claude-code-dir <path>   Path to Claude Code data directory
-  -h, --help               Show this help message
+  --codex-cli-dir <path>     Path to Codex CLI data directory
+  --opencode-dir <path>      Path to OpenCode data directory
+  -h, --help                 Show this help message
 
-The server runs on http://localhost:3583 by default.
+The server binds to 127.0.0.1:3583 by default.
 `);
 }
-function printStartupBanner(port) {
+function printStartupBanner(port, host) {
   const dim = "\x1B[2m";
   const bold = "\x1B[1m";
   const green = "\x1B[32m";
   const reset = "\x1B[0m";
   const version = appVersion.version;
-  const url = `http://localhost:${port}`;
+  const url = `http://${host}:${port}`;
   const line1 = `   ${bold}${green}{K>  Klovi${reset} ${dim}v${version}${reset}`;
   const line2 = `        ${dim}by cookielab.io${reset}`;
   const line3 = `   Running at ${bold}${url}${reset}`;
@@ -859,8 +2075,10 @@ function printStartupBanner(port) {
   console.log(empty);
   console.log(bot);
 }
-function promptSecurityWarning(port) {
-  const resolvedDir = getClaudeCodeDir();
+function promptSecurityWarning(port, host) {
+  const claudeDir = getClaudeCodeDir();
+  const codexDir = getCodexCliDir();
+  const openDir = getOpenCodeDir();
   const yellow = "\x1B[33m";
   const bold = "\x1B[1m";
   const reset = "\x1B[0m";
@@ -868,11 +2086,15 @@ function promptSecurityWarning(port) {
   console.log("");
   console.log(`${yellow}${bold}  ⚠  WARNING${reset}`);
   console.log("");
-  console.log(`  Klovi reads Claude Code session history from ${resolvedDir}.`);
+  console.log("  Klovi reads AI coding session history from:");
+  console.log(`    - Claude Code: ${claudeDir}`);
+  console.log(`    - Codex CLI:   ${codexDir}`);
+  console.log(`    - OpenCode:    ${openDir}`);
+  console.log("");
   console.log("  Session data may contain sensitive information such as API keys,");
   console.log("  credentials, or private code snippets.");
   console.log("");
-  console.log(`  The server will expose this data on ${bold}http://localhost:${port}${reset}.`);
+  console.log(`  The server will expose this data on ${bold}http://${host}:${port}${reset}.`);
   console.log("");
   console.log(`  ${dim}To skip this prompt, pass --accept-risks${reset}`);
   console.log("");
@@ -887,14 +2109,15 @@ function promptSecurityWarning(port) {
   console.log("");
 }
 function createRoutes() {
+  const registry = createRegistry();
   return [
     { pattern: "/api/version", handler: () => handleVersion() },
     { pattern: "/api/stats", handler: () => handleStats() },
-    { pattern: "/api/search/sessions", handler: () => handleSearchSessions() },
-    { pattern: "/api/projects", handler: () => handleProjects() },
+    { pattern: "/api/search/sessions", handler: () => handleSearchSessions(registry) },
+    { pattern: "/api/projects", handler: () => handleProjects(registry) },
     {
       pattern: "/api/projects/:encodedPath/sessions",
-      handler: (_req, p) => handleSessions(p.encodedPath)
+      handler: (_req, p) => handleSessions(p.encodedPath, registry)
     },
     {
       pattern: "/api/sessions/:sessionId",
@@ -903,7 +2126,7 @@ function createRoutes() {
         if (!project) {
           return Response.json({ error: "project query parameter required" }, { status: 400 });
         }
-        return handleSession(p.sessionId, project);
+        return handleSession(p.sessionId, project, registry);
       }
     },
     {
@@ -920,7 +2143,7 @@ function createRoutes() {
 }
 
 // src/server/http.ts
-import { existsSync } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import { readFile as readFile3 } from "node:fs/promises";
 import { createServer } from "node:http";
 import { extname, resolve, sep } from "node:path";
@@ -934,7 +2157,7 @@ function matchRoute(pattern, pathname) {
     const pat = patternParts[i];
     const val = pathParts[i];
     if (pat.startsWith(":")) {
-      params[pat.slice(1)] = val;
+      params[pat.slice(1)] = decodeURIComponent(val);
     } else if (pat !== val) {
       return null;
     }
@@ -1019,8 +2242,8 @@ async function handleRequest(pathname, url, method, routes, staticDir, hasStatic
     headers: { "content-type": "text/plain" }
   });
 }
-function startServer(port, routes, staticDir, embeddedAssets) {
-  const hasStaticDir = !embeddedAssets && existsSync(staticDir);
+function startServer(port, host, routes, staticDir, embeddedAssets) {
+  const hasStaticDir = !embeddedAssets && existsSync3(staticDir);
   const server = createServer(async (req, res) => {
     try {
       const url = new URL(req.url, `http://${req.headers.host || "localhost"}`);
@@ -1032,7 +2255,7 @@ function startServer(port, routes, staticDir, embeddedAssets) {
       res.end("Internal Server Error");
     }
   });
-  server.listen(port);
+  server.listen(port, host);
 }
 async function writeResponse(res, webResponse) {
   const headers = {};
@@ -1045,21 +2268,19 @@ async function writeResponse(res, webResponse) {
 }
 
 // index.ts
-var { port, acceptRisks, showHelp } = parseCliArgs(process.argv);
+var { port, host, acceptRisks, showHelp } = parseCliArgs(process.argv);
 if (showHelp) {
   showHelpText();
   process.exit(0);
 }
 var resolvedDir = getClaudeCodeDir();
-if (!existsSync2(resolvedDir)) {
-  console.error(`Error: Claude Code directory not found: ${resolvedDir}`);
-  console.error("Hint: use --claude-code-dir <path> to specify a custom location.");
-  process.exit(1);
+if (!existsSync4(resolvedDir)) {
+  console.warn(`Warning: Claude Code directory not found: ${resolvedDir}`);
 }
 if (!acceptRisks) {
-  promptSecurityWarning(port);
+  promptSecurityWarning(port, host);
 }
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
-var staticDir = existsSync2(join5(__dirname2, "public", "index.html")) ? join5(__dirname2, "public") : join5(__dirname2, "dist", "public");
-startServer(port, createRoutes(), staticDir);
-printStartupBanner(port);
+var staticDir = existsSync4(join8(__dirname2, "public", "index.html")) ? join8(__dirname2, "public") : join8(__dirname2, "dist", "public");
+startServer(port, host, createRoutes(), staticDir);
+printStartupBanner(port, host);