@seqyuan/annodex 0.1.12 → 0.1.14

package/lib/session-reader.ts

@@ -1,903 +0,0 @@
-/**
- * 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;
-}