@seqyuan/annodex 0.1.10 → 0.1.12

package/lib/session-reader.ts

@@ -0,0 +1,903 @@
+/**
+ * Session Reader — Codex app-server thread-based session management
+ *
+ * Sessions are managed by codex app-server (threads in ~/.codex/).
+ * This module provides helpers to query threads via the app-server API.
+ * No separate session registry — annodex and codex CLI share sessions.
+ */
+
+import { dirname, join } from "path";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, statSync, writeFileSync } from "fs";
+import type {
+  AgentMessage,
+  AssistantMessage,
+  SessionInfo,
+  SessionEntry,
+  SessionContext,
+  SessionTreeNode,
+  SubagentRun,
+  TextContent,
+  ToolResultMessage,
+} from "./types";
+import {
+  type CodexThread,
+  type CodexThreadItem,
+  type CodexUserInput,
+  type CodexServerConnection,
+  getServerForCwd,
+  getOrCreateCodexServer,
+  releaseCodexServerConnection,
+  codexServerEnvForModel,
+  readThread,
+} from "./codex-server";
+import { getCodexHome } from "./codex-home";
+import { readSessionRuntime, upsertSessionRuntime } from "./session-runtime";
+import { mergeSubagentRuns, subagentRunsFromCollabEvent, subagentRunsFromCollabItem } from "./subagent-progress";
+import { readCodexUsageFromFile } from "./codex-usage";
+import { findProvider, normalizeRuntimeProviderId, readMergedConfig } from "./annodex-config";
+
+// ============================================================================
+// Agent dir (used for SOUL.md/HARNESS.md location)
+// ============================================================================
+
+export function getAgentDir(): string {
+  const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? "/tmp";
+  return join(homeDir, ".config", "annodex");
+}
+
+export function getSessionsDir(): string {
+  return join(getAgentDir(), "sessions");
+}
+
+// ============================================================================
+// Session path cache
+// ============================================================================
+
+declare global {
+  var __annodexSessionPathCache: Map<string, string> | undefined;
+}
+
+function getPathCache(): Map<string, string> {
+  if (!globalThis.__annodexSessionPathCache) globalThis.__annodexSessionPathCache = new Map();
+  return globalThis.__annodexSessionPathCache;
+}
+
+export function cacheSessionPath(sessionId: string, cwd: string): void {
+  getPathCache().set(sessionId, cwd);
+}
+
+export function invalidateSessionPathCache(sessionId: string): void {
+  getPathCache().delete(sessionId);
+}
+
+export async function resolveSessionPath(sessionId: string): Promise<string | null> {
+  const cached = getPathCache().get(sessionId);
+  if (cached) return cached;
+
+  return getSessionInfoById(sessionId)?.cwd ?? null;
+}
+
+// ============================================================================
+// Session listing (fast local read from ~/.codex/sessions)
+// ============================================================================
+
+export async function listAllSessions(options: { cwd?: string | null } = {}): Promise<SessionInfo[]> {
+  return listLocalCodexSessions(options);
+}
+
+function getCodexSessionsRoot(): string {
+  return join(getCodexHome(), "sessions");
+}
+
+const MAX_SESSION_SUMMARY_BYTES = 2 * 1024 * 1024;
+
+function normalizeCwdPath(cwd: string): string {
+  const trimmed = cwd.trim();
+  return trimmed.replace(/[\\/]+$/, "") || trimmed;
+}
+
+function listJsonlFiles(dir: string, out: string[] = []): string[] {
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        listJsonlFiles(fullPath, out);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        out.push(fullPath);
+      }
+    }
+  } catch {
+    return out;
+  }
+  return out;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function parseJsonLine(line: string): Record<string, unknown> | null {
+  try {
+    const parsed = JSON.parse(line) as unknown;
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function payloadRecord(line: Record<string, unknown>): Record<string, unknown> | null {
+  return isRecord(line.payload) ? line.payload : null;
+}
+
+function objectString(obj: Record<string, unknown>, key: string): string | undefined {
+  const value = obj[key];
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+
+function annodexProviderId(value: string | undefined, preferCodex = false): string | undefined {
+  if (!value) return undefined;
+  try {
+    return normalizeRuntimeProviderId(readMergedConfig(), value, { preferCodex });
+  } catch {
+    return value;
+  }
+}
+
+function textFromResponseContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((block) => {
+      if (!isRecord(block)) return "";
+      if (typeof block.text === "string") return block.text;
+      if (typeof block.content === "string") return block.content;
+      return "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+
+function timestampMs(value: unknown): number | undefined {
+  if (typeof value !== "string" || !value) return undefined;
+  const time = Date.parse(value);
+  return Number.isFinite(time) ? time : undefined;
+}
+
+interface LocalCodexSessionMeta {
+  id: string;
+  cwd: string;
+  created: string;
+  modelProvider?: string;
+  parentSessionId?: string;
+}
+
+interface SessionHistoryCacheRecord {
+  filePath: string;
+  size: number;
+  mtimeMs: number;
+  summary: SessionInfo;
+  model?: {
+    provider?: string;
+    modelId?: string;
+    thinkingLevel?: string;
+  };
+}
+
+interface SessionHistoryCacheFile {
+  version: 1;
+  records: Record<string, SessionHistoryCacheRecord>;
+}
+
+interface LocalFileStamp {
+  size: number;
+  mtimeMs: number;
+  modified: string;
+}
+
+interface SessionFileRuntime {
+  provider?: string;
+  modelId?: string;
+  thinkingLevel?: string;
+}
+
+function statSessionFile(filePath: string): LocalFileStamp | null {
+  try {
+    const stat = statSync(filePath);
+    return {
+      size: Number(stat.size),
+      mtimeMs: Number(stat.mtimeMs),
+      modified: stat.mtime.toISOString(),
+    };
+  } catch {
+    return null;
+  }
+}
+
+function getSessionHistoryCachePath(): string {
+  return join(getAgentDir(), "session-history-cache.json");
+}
+
+function readSessionHistoryCache(): SessionHistoryCacheFile {
+  const path = getSessionHistoryCachePath();
+  if (!existsSync(path)) return { version: 1, records: {} };
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8")) as Partial<SessionHistoryCacheFile>;
+    return {
+      version: 1,
+      records: parsed.records && typeof parsed.records === "object" ? parsed.records : {},
+    };
+  } catch {
+    return { version: 1, records: {} };
+  }
+}
+
+function writeSessionHistoryCache(cache: SessionHistoryCacheFile): void {
+  const path = getSessionHistoryCachePath();
+  const dir = dirname(path);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(path, JSON.stringify(cache, null, 2), "utf-8");
+}
+
+function readFilePrefix(filePath: string, bytes = 64 * 1024): string {
+  let fd: number | null = null;
+  try {
+    fd = openSync(filePath, "r");
+    const buffer = Buffer.alloc(bytes);
+    const read = readSync(fd, buffer, 0, bytes, 0);
+    return buffer.subarray(0, read).toString("utf-8");
+  } catch {
+    return "";
+  } finally {
+    if (fd !== null) {
+      try { closeSync(fd); } catch { /* ignore */ }
+    }
+  }
+}
+
+function unescapeJsonString(value: string): string {
+  try {
+    return JSON.parse(`"${value}"`) as string;
+  } catch {
+    return value;
+  }
+}
+
+function readCodexSessionMeta(filePath: string): LocalCodexSessionMeta | null {
+  const prefix = readFilePrefix(filePath);
+  if (!/"type"\s*:\s*"session_meta"/.test(prefix)) return null;
+  const firstLine = prefix.split(/\r?\n/, 1)[0] ?? "";
+  const parsed = parseJsonLine(firstLine);
+  const payload = parsed ? payloadRecord(parsed) : null;
+  const source = payload ?? parsed;
+  if (source) {
+    const id = objectString(source, "id");
+    const cwdRaw = objectString(source, "cwd");
+    if (id && cwdRaw) {
+      const parentFromSource = isRecord(source.source)
+        && isRecord(source.source.subagent)
+        && isRecord(source.source.subagent.thread_spawn)
+        ? objectString(source.source.subagent.thread_spawn, "parent_thread_id")
+        : undefined;
+      return {
+        id,
+        cwd: normalizeCwdPath(cwdRaw),
+        created: objectString(source, "timestamp") ?? objectString(parsed ?? {}, "timestamp") ?? new Date(0).toISOString(),
+        modelProvider: annodexProviderId(objectString(source, "model_provider"), true),
+        parentSessionId: objectString(source, "forked_from_id") ?? parentFromSource,
+      };
+    }
+  }
+
+  const idMatch = /"id"\s*:\s*"((?:\\.|[^"\\])*)"/.exec(prefix);
+  const cwdMatch = /"cwd"\s*:\s*"((?:\\.|[^"\\])*)"/.exec(prefix);
+  const timestampMatch = /"timestamp"\s*:\s*"((?:\\.|[^"\\])*)"/.exec(prefix);
+  const modelProviderMatch = /"model_provider"\s*:\s*"((?:\\.|[^"\\])*)"/.exec(prefix);
+  const forkedFromMatch = /"forked_from_id"\s*:\s*"((?:\\.|[^"\\])*)"/.exec(prefix);
+  const id = idMatch ? unescapeJsonString(idMatch[1]) : null;
+  const cwd = cwdMatch ? normalizeCwdPath(unescapeJsonString(cwdMatch[1])) : null;
+  if (!id || !cwd) return null;
+  const created = timestampMatch ? unescapeJsonString(timestampMatch[1]) : new Date(0).toISOString();
+  return {
+    id,
+    cwd,
+    created,
+    modelProvider: annodexProviderId(modelProviderMatch ? unescapeJsonString(modelProviderMatch[1]) : undefined, true),
+    parentSessionId: forkedFromMatch ? unescapeJsonString(forkedFromMatch[1]) : undefined,
+  };
+}
+
+function cleanPreview(text: string): string {
+  const trimmed = text.trim();
+  if (!trimmed) return "";
+  if (trimmed.includes("AGENTS.md instructions")) return "";
+  const markerIndex = trimmed.lastIndexOf("<environment_context>");
+  const withoutPrependedContext = markerIndex >= 0
+    ? trimmed.slice(markerIndex).replace(/^<environment_context>[\s\S]*?<\/environment_context>\s*/m, "").trim()
+    : trimmed;
+  const singleLine = withoutPrependedContext.replace(/\s+/g, " ").trim();
+  return singleLine.length > 180 ? `${singleLine.slice(0, 180)}...` : singleLine;
+}
+
+function maybeSetFirstMessage(current: string, candidate: string): string {
+  if (current) return current;
+  const cleaned = cleanPreview(candidate);
+  return cleaned || current;
+}
+
+function summarizeCodexSessionFile(
+  filePath: string,
+  meta: LocalCodexSessionMeta,
+  stamp: LocalFileStamp,
+): SessionHistoryCacheRecord | null {
+  const content = readFilePrefix(filePath, MAX_SESSION_SUMMARY_BYTES);
+  if (!content) return null;
+
+  const lines = content.split("\n").filter((line) => line.trim());
+
+  let firstMessage = "";
+  let eventMessageCount = 0;
+  let responseMessageCount = 0;
+  let modelId: string | undefined;
+  let thinkingLevel: string | undefined;
+
+  for (const line of lines) {
+    const item = parseJsonLine(line);
+    if (!item) continue;
+    const itemPayload = payloadRecord(item) ?? item;
+
+    if (item.type === "event_msg") {
+      const payloadType = itemPayload.type;
+      if (payloadType === "user_message" || payloadType === "agent_message") {
+        eventMessageCount++;
+      }
+      if (payloadType === "user_message" && typeof itemPayload.message === "string") {
+        firstMessage = maybeSetFirstMessage(firstMessage, itemPayload.message);
+      }
+      continue;
+    }
+
+    if (item.type === "response_item" && itemPayload.type === "message") {
+      const role = itemPayload.role;
+      if (role === "user" || role === "assistant") responseMessageCount++;
+      if (role === "user") {
+        firstMessage = maybeSetFirstMessage(firstMessage, textFromResponseContent(itemPayload.content));
+      }
+      continue;
+    }
+
+    if (item.type === "turn_context") {
+      modelId = objectString(itemPayload, "model") ?? modelId;
+      thinkingLevel = objectString(itemPayload, "effort") ?? thinkingLevel;
+    }
+  }
+
+  cacheSessionPath(meta.id, meta.cwd);
+  const summary: SessionInfo = {
+    id: meta.id,
+    path: filePath,
+    cwd: meta.cwd,
+    cwdExists: existsSync(meta.cwd),
+    created: meta.created,
+    modified: stamp.modified,
+    messageCount: eventMessageCount || responseMessageCount || (firstMessage ? 1 : 0),
+    firstMessage: firstMessage || "(no messages)",
+    parentSessionId: meta.parentSessionId,
+  };
+  const model = {
+    provider: meta.modelProvider,
+    modelId,
+    thinkingLevel,
+  };
+  const existingRuntime = readSessionRuntime(meta.id);
+  const runtimePatch = {
+    cwd: meta.cwd,
+    provider: existingRuntime?.provider ?? model.provider,
+    modelId: existingRuntime?.modelId ?? model.modelId,
+    thinkingLevel: existingRuntime?.thinkingLevel ?? model.thinkingLevel,
+  };
+  if (runtimePatch.provider || runtimePatch.modelId || runtimePatch.thinkingLevel) {
+    upsertSessionRuntime(meta.id, {
+      cwd: runtimePatch.cwd,
+      provider: runtimePatch.provider,
+      modelId: runtimePatch.modelId,
+      thinkingLevel: runtimePatch.thinkingLevel,
+    });
+  }
+  return {
+    filePath,
+    size: stamp.size,
+    mtimeMs: stamp.mtimeMs,
+    summary,
+    model,
+  };
+}
+
+function listLocalCodexSessions(options: { cwd?: string | null } = {}): SessionInfo[] {
+  const sessions: SessionInfo[] = [];
+  const seenIds = new Set<string>();
+  const explicitCwd = options.cwd?.trim() ? normalizeCwdPath(options.cwd) : undefined;
+  const root = getCodexSessionsRoot();
+  if (!existsSync(root)) return sessions;
+  const cache = readSessionHistoryCache();
+  const nextRecords: Record<string, SessionHistoryCacheRecord> = {};
+
+  for (const filePath of listJsonlFiles(root)) {
+    const stamp = statSessionFile(filePath);
+    if (!stamp) continue;
+    const cached = cache.records[filePath];
+    let record = cached && cached.size === stamp.size && cached.mtimeMs === stamp.mtimeMs
+      ? cached
+      : null;
+    if (!record) {
+      const meta = readCodexSessionMeta(filePath);
+      if (!meta) continue;
+      record = summarizeCodexSessionFile(filePath, meta, stamp);
+    }
+    if (!record) continue;
+    nextRecords[filePath] = record;
+    const session: SessionInfo = {
+      ...record.summary,
+      modified: new Date(record.mtimeMs).toISOString(),
+      cwdExists: existsSync(record.summary.cwd),
+    };
+    cacheSessionPath(session.id, session.cwd);
+    if (explicitCwd && normalizeCwdPath(session.cwd) !== explicitCwd) continue;
+    if (!session || seenIds.has(session.id)) continue;
+    seenIds.add(session.id);
+    sessions.push(session);
+  }
+
+  writeSessionHistoryCache({ version: 1, records: nextRecords });
+  return sessions.sort((a, b) => b.modified.localeCompare(a.modified));
+}
+
+export function getSessionInfoById(sessionId: string): SessionInfo | null {
+  const root = getCodexSessionsRoot();
+  if (!sessionId || !existsSync(root)) return null;
+
+  const files = listJsonlFiles(root);
+  const ordered = [
+    ...files.filter((filePath) => filePath.includes(sessionId)),
+    ...files.filter((filePath) => !filePath.includes(sessionId)),
+  ];
+
+  for (const filePath of ordered) {
+    const stamp = statSessionFile(filePath);
+    if (!stamp) continue;
+    const meta = readCodexSessionMeta(filePath);
+    if (meta?.id !== sessionId) continue;
+    const record = summarizeCodexSessionFile(filePath, meta, stamp);
+    if (!record) return null;
+    return {
+      ...record.summary,
+      modified: new Date(record.mtimeMs).toISOString(),
+      cwdExists: existsSync(record.summary.cwd),
+    };
+  }
+
+  return null;
+}
+
+function isoFromTimestamp(value: number | string | undefined): string {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return new Date(value * 1000).toISOString();
+  }
+  if (typeof value === "string" && value) return value;
+  return new Date(0).toISOString();
+}
+
+// ============================================================================
+// Session entries / tree (simplified — data comes from codex thread API)
+// ============================================================================
+
+export function getSessionEntries(filePath: string): SessionEntry[] {
+  void filePath;
+  // Codex app-server sessions are read asynchronously through readThread().
+  // This synchronous API is kept only for older call sites.
+  return [];
+}
+
+export function buildTree(entries: SessionEntry[]): SessionTreeNode[] {
+  void entries;
+  return [];
+}
+
+export function buildSessionContext(
+  entries: SessionEntry[],
+  leafId?: string | null,
+): SessionContext {
+  void entries;
+  void leafId;
+  return { messages: [], entryIds: [], thinkingLevel: "off", model: null, subagentRuns: [], sessionStats: null, contextUsage: null };
+}
+
+export function getLeafId(entries: SessionEntry[]): string | null {
+  if (entries.length === 0) return null;
+  return entries[entries.length - 1]?.id ?? null;
+}
+
+export async function loadCodexSessionContext(
+  sessionId: string,
+  cwd: string,
+  leafId?: string | null,
+): Promise<{
+  context: SessionContext;
+  tree: SessionTreeNode[];
+  leafId: string | null;
+  thread: CodexThread | null;
+}> {
+  // Look up the session's stored provider so we use the correct codex
+  // app-server instance.  Otherwise a thread created under DeepRouter would
+  // be queried through the DeepSeek server and return "thread not found".
+  const sessionRt = readSessionRuntime(sessionId);
+  let conn: CodexServerConnection;
+  let ownsConn = false;
+  if (sessionRt?.provider) {
+    const cfg = readMergedConfig();
+    const np = normalizeRuntimeProviderId(cfg, sessionRt.provider);
+    const pc = np ? findProvider(cfg, np) : undefined;
+    if (pc) {
+      conn = await getOrCreateCodexServer(
+        cwd,
+        codexServerEnvForModel(pc, sessionRt.modelId, sessionRt.thinkingLevel),
+      );
+      ownsConn = true;
+    } else {
+      const ec = getServerForCwd(cwd);
+      conn = ec ?? await getOrCreateCodexServer(cwd);
+      ownsConn = !ec;
+    }
+  } else {
+    const ec = getServerForCwd(cwd);
+    conn = ec ?? await getOrCreateCodexServer(cwd);
+    ownsConn = !ec;
+  }
+  let thread: CodexThread | null = null;
+  try {
+    thread = await readThread(conn, sessionId);
+  } finally {
+    if (ownsConn) releaseCodexServerConnection(conn);
+  }
+  if (!thread) {
+    return {
+      context: { messages: [], entryIds: [], thinkingLevel: "off", model: null, subagentRuns: [], sessionStats: null, contextUsage: null },
+      tree: [],
+      leafId: null,
+      thread: null,
+    };
+  }
+
+  cacheSessionPath(thread.id, thread.cwd || cwd);
+  if (thread.model || thread.modelProvider) {
+    upsertSessionRuntime(thread.id, {
+      cwd: thread.cwd || cwd,
+      provider: thread.modelProvider,
+      modelId: thread.model,
+    });
+  }
+  const fileRuntime = runtimeFromSessionFile(thread.id);
+  const runtime = readSessionRuntime(thread.id);
+  const runtimeProvider = runtime?.provider ?? fileRuntime?.provider;
+  const runtimeModelId = runtime?.modelId ?? fileRuntime?.modelId;
+  const runtimeThinkingLevel = runtime?.thinkingLevel ?? fileRuntime?.thinkingLevel;
+  const fallbackModel = thread.model
+    ? { provider: thread.modelProvider ?? runtimeProvider ?? "codex", modelId: thread.model }
+    : runtimeModelId
+      ? { provider: runtimeProvider ?? "codex", modelId: runtimeModelId }
+      : null;
+  const entries = entriesFromThread(thread, fallbackModel);
+  const selectedEntries = leafId ? entriesUntil(entries, leafId) : entries;
+  const usage = readCodexUsageFromFile(findCodexSessionFile(thread.id), runtimeModelId ?? thread.model);
+  const usageEntryByTurnId = new Map<string, string>();
+  for (const entry of selectedEntries) {
+    if (entry.turnId && entry.message.role === "assistant" && assistantHasText(entry.message)) {
+      usageEntryByTurnId.set(entry.turnId, entry.id);
+    }
+  }
+  const messages: AgentMessage[] = [];
+  const entryIds: string[] = [];
+  for (const entry of selectedEntries) {
+    const message = entry.message;
+    if (entry.turnId && message.role === "assistant" && usageEntryByTurnId.get(entry.turnId) === entry.id) {
+      const messageUsage = usage.messageUsageByTurnId.get(entry.turnId);
+      messages.push(messageUsage ? { ...message, usage: messageUsage } : message);
+    } else {
+      messages.push(message);
+    }
+    entryIds.push(entry.id);
+  }
+
+  const currentLeafId = selectedEntries[selectedEntries.length - 1]?.id ?? entries[entries.length - 1]?.id ?? null;
+  const model = thread.model
+    ? { provider: thread.modelProvider ?? runtimeProvider ?? "codex", modelId: thread.model }
+    : runtimeModelId
+      ? { provider: runtimeProvider ?? "codex", modelId: runtimeModelId }
+      : null;
+  return {
+    context: {
+      messages,
+      entryIds,
+      thinkingLevel: runtimeThinkingLevel ?? "off",
+      model,
+      subagentRuns: mergeSubagentRuns(subagentRunsFromThread(thread), subagentRunsFromSessionFile(sessionId)),
+      sessionStats: usage.sessionStats,
+      contextUsage: usage.contextUsage,
+    },
+    tree: buildTreeFromMessageEntries(entries),
+    leafId: currentLeafId,
+    thread,
+  };
+}
+
+export async function searchCodexSessionEntries(sessionId: string, cwd: string): Promise<SessionEntry[]> {
+  const loaded = await loadCodexSessionContext(sessionId, cwd);
+  const runtime = readSessionRuntime(sessionId);
+  const fileRuntime = runtimeFromSessionFile(sessionId);
+  const runtimeProvider = runtime?.provider ?? fileRuntime?.provider;
+  const runtimeModelId = runtime?.modelId ?? fileRuntime?.modelId;
+  const fallbackModel = loaded.thread?.model
+    ? { provider: loaded.thread.modelProvider ?? runtimeProvider ?? "codex", modelId: loaded.thread.model }
+    : runtimeModelId
+      ? { provider: runtimeProvider ?? "codex", modelId: runtimeModelId }
+      : null;
+  return entriesFromThread(loaded.thread, fallbackModel);
+}
+
+function entriesUntil(
+  entries: Array<SessionEntry & { message: AgentMessage; turnId?: string }>,
+  targetId: string,
+): Array<SessionEntry & { message: AgentMessage; turnId?: string }> {
+  const idx = entries.findIndex((entry) => entry.id === targetId);
+  return idx >= 0 ? entries.slice(0, idx + 1) : entries;
+}
+
+function entriesFromThread(
+  thread: CodexThread | null,
+  fallbackModel?: { provider: string; modelId: string } | null,
+): Array<SessionEntry & { message: AgentMessage; turnId?: string }> {
+  if (!thread) return [];
+  const entries: Array<SessionEntry & { message: AgentMessage; turnId?: string }> = [];
+  let parentId: string | null = null;
+
+  for (const turn of thread.turns ?? []) {
+    const timestamp = isoFromTimestamp(thread.updatedAt);
+    for (const item of turn.items) {
+      const message = messageFromItem(item, thread, fallbackModel);
+      if (!message) continue;
+      const entry = {
+        type: "message" as const,
+        id: item.id,
+        parentId,
+        timestamp,
+        message,
+        turnId: turn.id,
+      };
+      entries.push(entry);
+      parentId = item.id;
+    }
+  }
+  return entries;
+}
+
+function assistantHasText(message: AssistantMessage): boolean {
+  return message.content.some((block) => block.type === "text" && block.text.trim());
+}
+
+function subagentRunsFromThread(thread: CodexThread | null): SubagentRun[] {
+  if (!thread) return [];
+  const runs: SubagentRun[] = [];
+  for (const turn of thread.turns ?? []) {
+    for (const item of turn.items) {
+      if (item.type === "collabAgentToolCall") {
+        runs.push(...subagentRunsFromCollabItem(item, thread.updatedAt ? thread.updatedAt * 1000 : undefined));
+      }
+    }
+  }
+  return runs;
+}
+
+export function findCodexSessionFile(sessionId: string): string | null {
+  const root = getCodexSessionsRoot();
+  if (!sessionId || !existsSync(root)) return null;
+  const files = listJsonlFiles(root);
+  return files.find((filePath) => filePath.includes(sessionId)) ?? files.find((filePath) => {
+    const meta = readCodexSessionMeta(filePath);
+    return meta?.id === sessionId;
+  }) ?? null;
+}
+
+function subagentRunsFromSessionFile(sessionId: string): SubagentRun[] {
+  const filePath = findCodexSessionFile(sessionId);
+  if (!filePath) return [];
+  let content = "";
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  if (!content) return [];
+  const runs: SubagentRun[] = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim() || !line.includes("collab_")) continue;
+    const item = parseJsonLine(line);
+    if (!item || item.type !== "event_msg") continue;
+    const payload = payloadRecord(item);
+    if (!payload) continue;
+    runs.push(...subagentRunsFromCollabEvent(payload, timestampMs(item.timestamp)));
+  }
+  return runs;
+}
+
+function runtimeFromSessionFile(sessionId: string): SessionFileRuntime | null {
+  const filePath = findCodexSessionFile(sessionId);
+  if (!filePath) return null;
+  let content = "";
+  try {
+    content = readFilePrefix(filePath, MAX_SESSION_SUMMARY_BYTES);
+  } catch {
+    return null;
+  }
+  let provider: string | undefined;
+  let modelId: string | undefined;
+  let thinkingLevel: string | undefined;
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    const item = parseJsonLine(line);
+    if (!item) continue;
+    const payload = payloadRecord(item) ?? item;
+    if (item.type === "session_meta") {
+      provider = annodexProviderId(objectString(payload, "model_provider"), true) ?? provider;
+      continue;
+    }
+    if (item.type === "turn_context") {
+      modelId = objectString(payload, "model") ?? modelId;
+      thinkingLevel = objectString(payload, "effort") ?? thinkingLevel;
+    }
+  }
+  return provider || modelId || thinkingLevel ? { provider, modelId, thinkingLevel } : null;
+}
+
+function messageFromItem(
+  item: CodexThreadItem,
+  thread: CodexThread,
+  fallbackModel?: { provider: string; modelId: string } | null,
+): AgentMessage | null {
+  if (item.type === "userMessage") {
+    return {
+      role: "user",
+      content: contentFromUserInputs(item.content ?? []),
+    };
+  }
+  if (item.type === "agentMessage") {
+    return {
+      role: "assistant",
+      content: [{ type: "text", text: item.text ?? "" }],
+      model: thread.model ?? fallbackModel?.modelId ?? "",
+      provider: thread.modelProvider ?? fallbackModel?.provider ?? "",
+    } satisfies AssistantMessage;
+  }
+  if (item.type === "reasoning") {
+    const thinking = [...(item.summary ?? []), ...(item.content ?? [])].join("\n").trim();
+    if (!thinking) return null;
+    return {
+      role: "assistant",
+      content: [{ type: "thinking", thinking }],
+      model: thread.model ?? fallbackModel?.modelId ?? "",
+      provider: thread.modelProvider ?? fallbackModel?.provider ?? "",
+    } satisfies AssistantMessage;
+  }
+  if (item.type === "commandExecution") {
+    const text = [item.aggregatedOutput ?? "", item.exitCode !== null && item.exitCode !== undefined ? `Exit code: ${item.exitCode}` : ""]
+      .filter(Boolean)
+      .join("\n");
+    return toolResult(item.id, "bash", text, item.status === "failed" || item.status === "declined");
+  }
+  if (item.type === "fileChange") {
+    return toolResult(item.id, "edit", JSON.stringify(item.changes ?? []), item.status === "failed" || item.status === "declined");
+  }
+  if (item.type === "mcpToolCall") {
+    return toolResult(item.id, item.tool || item.server || "mcp", JSON.stringify(item.result ?? item.error ?? ""), !!item.error);
+  }
+  if (item.type === "dynamicToolCall") {
+    return toolResult(item.id, item.tool || "tool", JSON.stringify(item.contentItems ?? []), item.success === false);
+  }
+  if (item.type === "collabAgentToolCall") {
+    const runs = subagentRunsFromCollabItem(item, thread.updatedAt ? thread.updatedAt * 1000 : undefined);
+    return {
+      role: "custom",
+      customType: "subagent-progress",
+      content: "Agent progress updated",
+      display: false,
+      details: { runs },
+      timestamp: thread.updatedAt ? thread.updatedAt * 1000 : undefined,
+    };
+  }
+  return null;
+}
+
+function toolResult(toolCallId: string, toolName: string, text: string, isError: boolean): ToolResultMessage {
+  return {
+    role: "toolResult",
+    toolCallId,
+    toolName,
+    content: [{ type: "text", text }],
+    isError,
+  };
+}
+
+function contentFromUserInputs(inputs: CodexUserInput[]): string | TextContent[] {
+  const textBlocks: TextContent[] = [];
+  for (const input of inputs) {
+    if (input.type === "text") {
+      textBlocks.push({ type: "text", text: input.text });
+    } else if (input.type === "image") {
+      textBlocks.push({ type: "text", text: `[image] ${input.url.slice(0, 120)}` });
+    } else if (input.type === "localImage") {
+      textBlocks.push({ type: "text", text: `[image] ${input.path}` });
+    } else if (input.type === "mention") {
+      textBlocks.push({ type: "text", text: `@${input.path}` });
+    } else if (input.type === "skill") {
+      textBlocks.push({ type: "text", text: `$${input.name}` });
+    }
+  }
+  if (textBlocks.length === 0) return "";
+  if (textBlocks.length === 1) return textBlocks[0].text;
+  return textBlocks;
+}
+
+function buildTreeFromMessageEntries(entries: Array<SessionEntry & { message: AgentMessage }>): SessionTreeNode[] {
+  const entriesById = new Map<string, SessionEntry & { message: AgentMessage }>();
+  const childCounts = new Map<string, number>();
+  let rootCount = 0;
+  for (const entry of entries) {
+    entriesById.set(entry.id, entry);
+    if (entry.parentId) {
+      childCounts.set(entry.parentId, (childCounts.get(entry.parentId) ?? 0) + 1);
+    } else {
+      rootCount++;
+    }
+  }
+
+  let hasBranch = rootCount > 1;
+  if (!hasBranch) {
+    for (const count of childCounts.values()) {
+      if (count > 1) {
+        hasBranch = true;
+        break;
+      }
+    }
+  }
+  if (!hasBranch) return [];
+
+  const keep = new Set<string>();
+  for (const entry of entries) {
+    const childCount = childCounts.get(entry.id) ?? 0;
+    const siblingCount = entry.parentId ? (childCounts.get(entry.parentId) ?? 0) : rootCount;
+    if (!entry.parentId || childCount === 0 || childCount > 1 || siblingCount > 1) {
+      keep.add(entry.id);
+    }
+  }
+
+  const nodes = new Map<string, SessionTreeNode>();
+  const roots: SessionTreeNode[] = [];
+  for (const entry of entries) {
+    if (!keep.has(entry.id)) continue;
+    nodes.set(entry.id, { entry, children: [] });
+  }
+
+  for (const entry of entries) {
+    if (!keep.has(entry.id)) continue;
+    const node = nodes.get(entry.id);
+    if (!node) continue;
+    let parentId = entry.parentId;
+    while (parentId && !keep.has(parentId)) {
+      parentId = entriesById.get(parentId)?.parentId ?? null;
+    }
+    if (parentId && nodes.has(parentId)) {
+      nodes.get(parentId)!.children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  return roots;
+}