tokenphage 2026.7.2-BETA → 2026.11.1

package/src/parsers/opencode.js

@@ -0,0 +1,166 @@
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { localDateOf } from '../lib/dates.js';
+
+// opencode(sst) 세션 저장 파서.
+// 최신 opencode는 사용량을 data home 아래 opencode.db(SQLite)에 저장하고,
+// 구버전은 storage/message·part JSON 파일에 저장한다. 두 형태를 모두 지원한다.
+//
+// DB는 외부 App(`opencode` CLI)을 거치지 않고 read-only로 직접 조회한다.
+// OpenCode의 설치 여부·버전·오작동이 tokenphage sync에 영향을 주지 않아야 하기 때문이다.
+//
+// opencode는 턴당 assistant 메시지 1개에 스텝마다 tokens를 덮어써(=) 마지막 스텝만 남기므로,
+// 스텝별 토큰이 보존된 step-finish part를 전부 합산해야 정확하다.
+// 전략:
+//  - message(role==='assistant')에서 id→{model, date}를 모으고, step-finish part를 messageID로 조인한다.
+//  - 입력 파일 목록에 message/part가 섞여 오고 순서 보장이 없으므로, 두 맵을 모은 뒤 마지막에 조인한다.
+//  - 필드 매핑(claude/codex와 정합): opencode getUsage가 input은 캐시 제외로, output은 reasoning 제외로
+//    저장하므로 → inputTok은 그대로, outputTok은 output+reasoning으로 reasoning을 되살린다.
+//    cache.write는 cacheCreate로 둔다(opencode는 Anthropic cacheCreation을 여기 담는다).
+//  - 손상 파일·부모 없는 part·모델/날짜 없는 메시지는 집계에서 제외한다.
+
+// DB 스키마도 JSON 파일과 같은 구조(message.data / part.data)를 담고 있어 동일 규칙으로 집계한다.
+const USAGE_QUERY = `
+SELECT
+  strftime('%Y-%m-%d', m.time_created / 1000, 'unixepoch', 'localtime') AS date,
+  json_extract(m.data, '$.modelID') AS model,
+  SUM(MAX(COALESCE(json_extract(p.data, '$.tokens.input'), 0), 0)) AS input,
+  SUM(MAX(COALESCE(json_extract(p.data, '$.tokens.output'), 0), 0)) AS output,
+  SUM(MAX(COALESCE(json_extract(p.data, '$.tokens.reasoning'), 0), 0)) AS reasoning,
+  SUM(MAX(COALESCE(json_extract(p.data, '$.tokens.cache.read'), 0), 0)) AS cache_read,
+  SUM(MAX(COALESCE(json_extract(p.data, '$.tokens.cache.write'), 0), 0)) AS cache_write
+FROM message m
+JOIN part p ON p.message_id = m.id
+WHERE json_extract(m.data, '$.role') = 'assistant'
+  AND json_extract(p.data, '$.type') = 'step-finish'
+  AND json_type(p.data, '$.tokens') = 'object'
+  AND json_extract(m.data, '$.modelID') IS NOT NULL
+GROUP BY date, model
+`;
+
+// step-finish part의 tokens를 tokenphage 레코드 4필드로 매핑한다. 음수 방어로 max(…,0).
+function entryOf(date, model, tokens) {
+  const cache = tokens.cache ?? {};
+  return {
+    date,
+    model,
+    inputTok: Math.max(tokens.input ?? 0, 0),
+    // opencode는 output에서 reasoning을 미리 뺐으므로 되살려 청구 기준(claude/codex)과 맞춘다.
+    outputTok: Math.max(tokens.output ?? 0, 0) + Math.max(tokens.reasoning ?? 0, 0),
+    cacheReadTok: Math.max(cache.read ?? 0, 0),
+    cacheCreateTok: Math.max(cache.write ?? 0, 0),
+  };
+}
+
+// USAGE_QUERY가 내보내는 7개 별칭(date·model·input·output·reasoning·cache_read·cache_write)만 읽는다.
+// date는 strftime 결과라 'YYYY-MM-DD' 아니면 NULL이다(m.time_created가 NULL인 경우).
+// 날짜나 모델을 못 만든 행은 어느 날짜·모델에 귀속시킬지 알 수 없으므로 집계에서 뺀다.
+function entryOfRow(row) {
+  if (!row || typeof row.model !== 'string' || !row.model) return null;
+  if (typeof row.date !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(row.date)) return null;
+  return entryOf(row.date, row.model, {
+    input: row.input,
+    output: row.output,
+    reasoning: row.reasoning,
+    cache: { read: row.cache_read, write: row.cache_write },
+  });
+}
+
+// OpenCode를 지운 뒤 남은 빈 DB와, 스키마가 바뀐 DB를 구분하기 위한 조회.
+function tableCount(db, filter = '') {
+  return db.prepare(`SELECT COUNT(*) AS n FROM sqlite_master WHERE type = 'table'${filter}`).get().n;
+}
+function hasUsageTables(db) {
+  return tableCount(db, " AND name IN ('message', 'part')") === 2;
+}
+function hasAnyTable(db) {
+  return tableCount(db, " AND name NOT LIKE 'sqlite_%'") > 0;
+}
+
+// opencode.db를 read-only로 직접 연다. OpenCode CLI/App은 호출하지 않는다.
+// OpenCode가 쓰는 중이어도 WAL 기반이라 읽기는 막히지 않는다.
+// DB 삭제·손상·권한·스키마 변경 등 어떤 실패도 claude/codex sync를 막지 않도록
+// 예외를 올리지 않고 빈 목록으로 격리한다(경고만 남긴다).
+// better-sqlite3는 네이티브 모듈이라 로드 자체가 실패할 수 있다
+// 정적 import면 그 실패가 CLI 전체를 죽이므로 격리 대상인 이 try 안에서 동적으로 불러온다.
+async function queryOpencodeRows(dbPath, onDatabase = null) {
+  let db;
+  try {
+    const { default: Database } = await import('better-sqlite3');
+    db = new Database(dbPath, { readonly: true, fileMustExist: true });
+    onDatabase?.(db); // 실행시간 수집도 같은 연결로 읽는다(수집기는 예외를 던지지 않는다)
+    // 기록이 아직 없는 빈 DB는 정상 상태다. 반대로 다른 테이블은 있는데 message/part만
+    // 없다면 OpenCode 스키마가 바뀐 것이므로 집계가 0으로 새지 않게 알린다.
+    if (!hasUsageTables(db)) {
+      if (hasAnyTable(db)) console.warn(`Skipping OpenCode usage: ${dbPath} has no message/part table (schema changed?)`);
+      return [];
+    }
+    return db.prepare(USAGE_QUERY).all();
+  } catch (err) {
+    // 파일이 사라졌으면 집계할 기록이 없을 뿐이라 알릴 것이 없다.
+    // 파일이 남아 있는데 실패했다면 손상·권한 문제로 사용량이 누락되는 중이다.
+    if (existsSync(dbPath)) console.warn(`Skipping OpenCode usage: could not read ${dbPath} (${err.message})`);
+    return [];
+  } finally {
+    try { db?.close(); } catch { /* close 실패는 이미 읽은 결과에 영향이 없다 */ }
+  }
+}
+
+/** OpenCode SQLite 조회 결과를 tokenphage usage 목록으로 변환한다. */
+export function parseOpencodeRows(rows) {
+  if (!Array.isArray(rows)) return [];
+  const entries = [];
+  for (const row of rows) {
+    const entry = entryOfRow(row);
+    if (entry) entries.push(entry);
+  }
+  return entries;
+}
+
+/**
+ * opencode.db(SQLite)를 직접 조회해 tokenphage usage 목록으로 변환한다.
+ * @param {string} dbPath opencode.db 절대 경로
+ * @param {(dbPath: string, onDatabase?: Function|null) => Array<object>} [queryRows] 조회 구현(테스트 주입용)
+ * @param {((db: object) => void)|null} [onDatabase] 연 DB로 실행시간을 모으는 수집기(예외를 던지지 않아야 한다)
+ */
+export async function parseOpencodeDatabase(dbPath, queryRows = queryOpencodeRows, onDatabase = null) {
+  return parseOpencodeRows(await queryRows(dbPath, onDatabase));
+}
+
+/**
+ * opencode message/part 파일들을 스텝(step-finish) 단위 usage 목록으로 파싱한다.
+ * @param {string[]} files 메시지·파트 JSON 파일 경로 목록 (섞여 있어도 됨)
+ * @returns {Promise<Array<{date: string, model: string, inputTok: number, outputTok: number, cacheReadTok: number, cacheCreateTok: number}>>}
+ */
+export async function parseOpencodeFiles(files) {
+  const messageMeta = new Map(); // messageID → { model, date }
+  const stepParts = [];          // { messageID, tokens }
+
+  for (const file of files) {
+    let obj;
+    try {
+      obj = JSON.parse(await readFile(file, 'utf8'));
+    } catch { continue; } // 읽기 실패·손상 JSON skip
+    if (!obj) continue;
+
+    if (obj.role === 'assistant') {
+      // 모델·날짜를 못 만들면 이 메시지의 파트는 귀속 불가 → 맵에 넣지 않는다.
+      if (!obj.id || !obj.modelID) continue;
+      const date = localDateOf(obj.time?.created);
+      if (!date) continue;
+      messageMeta.set(obj.id, { model: obj.modelID, date });
+    } else if (obj.type === 'step-finish') {
+      if (!obj.messageID || !obj.tokens) continue;
+      stepParts.push({ messageID: obj.messageID, tokens: obj.tokens });
+    }
+    // 그 외(user 메시지, 다른 part, session/project 파일)는 무시
+  }
+
+  const entries = [];
+  for (const part of stepParts) {
+    const meta = messageMeta.get(part.messageID);
+    if (!meta) continue; // 부모 메시지 없음/모델·날짜 무효 → skip
+    entries.push(entryOf(meta.date, meta.model, part.tokens));
+  }
+  return entries;
+}

package/src/runtime/claude.js

@@ -0,0 +1,161 @@
+import { sumRuntimes, addRuntimeRows } from './timeline.js';
+
+// Claude Code 실행시간 추출기. parseClaudeFiles가 읽은 줄을 받아 실행 단위별로 계산한다.
+//  - 실행 단위: 메인 세션 파일, subagents/ 아래 에이전트 파일(파일 전체가 한 턴). journal.jsonl은 제외한다.
+//  - 이벤트: timestamp가 있는 user·assistant·system·attachment 레코드.
+//  - 턴 시작: 메인 파일에서 처음 나온 promptId의 user 레코드. promptId가 없는 옛 파일은 사람이 입력한 질문.
+//  - 중복 제거: forkedFrom을 원본까지 따라간 uuid로 한 번만 센다. 원본이 있으면 복사본은 버린다.
+
+const SOURCE = 'claude';
+const EVENT_TYPES = new Set(['user', 'assistant', 'system', 'attachment']);
+const INTERRUPTED_PREFIX = '[Request interrupted';
+const LOCAL_STDOUT_PREFIX = '<local-command-stdout>';
+const MAX_FORK_DEPTH = 100;
+
+function firstText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  const text = content.find((c) => c?.type === 'text')?.text;
+  return typeof text === 'string' ? text : '';
+}
+
+function isToolResult(obj) {
+  const content = obj.message?.content;
+  return obj.toolUseResult != null || (Array.isArray(content) && content.some((c) => c?.type === 'tool_result'));
+}
+
+/** promptId가 없는 옛 버전의 턴 시작: 사람이 입력한 질문, 작업 완료 알림, 다른 세션 메시지. */
+function isLegacyTurnStart(obj) {
+  const kind = obj.origin?.kind;
+  if (kind === 'task-notification' || kind === 'peer') return true;
+  if (obj.isMeta || obj.isCompactSummary || isToolResult(obj)) return false;
+  const text = firstText(obj.message?.content);
+  return !text.startsWith(INTERRUPTED_PREFIX) && !text.startsWith(LOCAL_STDOUT_PREFIX);
+}
+
+function unitKindOf(file) {
+  const path = String(file).replaceAll('\\', '/');
+  if (path.split('/').pop() === 'journal.jsonl') return 'journal';
+  // 사용자 폴더 이름에 subagents가 있어도 영향받지 않게 projects/ 아래 경로만 본다
+  return path.slice(Math.max(path.lastIndexOf('/projects/'), 0)).includes('/subagents/') ? 'agent' : 'main';
+}
+
+function nonEmptyString(value) {
+  return typeof value === 'string' && value !== '' ? value : undefined;
+}
+
+// 에이전트 파일은 가장 이른 기록이, 메인 파일은 처음 나온 promptId(옛 파일은 사람의 질문)가 턴 시작이다.
+function markTurnStarts(unit, events) {
+  if (unit.kind === 'agent') {
+    let first = null;
+    for (const e of events) if (!first || e.t < first.t) first = e;
+    if (first) first.start = true;
+    return;
+  }
+  const seen = new Set();
+  for (const e of events) {
+    if (!unit.hasPromptId) {
+      e.start = e.legacyStart === true;
+    } else if (e.promptId !== undefined && !seen.has(e.promptId)) {
+      seen.add(e.promptId);
+      e.start = true;
+    }
+  }
+}
+
+/**
+ * Claude 실행시간 수집기를 만든다. onRecord를 parseClaudeFiles에 넘겨 같은 읽기에서 계산한다.
+ * @returns {{ onRecord: (record: object, file: string) => void,
+ *   result: () => { source: 'claude', rows: Array<{ date: string, source: string, model: string, runtimeMs: number }>, ok: boolean } }}
+ */
+export function createClaudeRuntimeCollector() {
+  const totals = new Map();
+  const originals = new Set();   // 원본 레코드 uuid
+  const copyParents = new Map(); // 복사본 uuid → 가리키는 uuid
+  const pending = [];            // 복사본이 있어 끝에 원본과 대조할 실행 단위(나머지는 읽는 즉시 합산)
+  let unit = null;
+  let failed = false;
+
+  const sumUnit = (target, events) => {
+    markTurnStarts(target, events);
+    addRuntimeRows(totals, sumRuntimes([{ source: SOURCE, events }]));
+  };
+
+  // 파일이 바뀌면 앞 단위를 마무리한다(parseClaudeFiles는 파일을 하나씩 순서대로 읽는다).
+  const closeUnit = () => {
+    if (!unit) return;
+    if (unit.hasCopies) pending.push(unit);
+    else if (unit.kind !== 'journal') sumUnit(unit, unit.events);
+    unit = null;
+  };
+
+  // 포크의 포크는 앞 복사본을 가리키므로 원본 uuid까지 따라간다.
+  const rootOf = (key) => {
+    let current = key;
+    for (let hop = 0; hop < MAX_FORK_DEPTH && copyParents.has(current); hop++) current = copyParents.get(current);
+    return current;
+  };
+
+  const onRecord = (obj, file) => {
+    try {
+      if (!EVENT_TYPES.has(obj?.type)) return;
+      const t = Date.parse(obj.timestamp);
+      if (!Number.isFinite(t)) return;
+      if (unit?.file !== file) {
+        closeUnit();
+        unit = { file, kind: unitKindOf(file), events: [], hasPromptId: false, hasCopies: false };
+      }
+      if (unit.kind === 'journal') return;
+
+      const isUser = obj.type === 'user';
+      const promptId = isUser ? nonEmptyString(obj.promptId) : undefined;
+      if (promptId) unit.hasPromptId = true;
+
+      const uuid = nonEmptyString(obj.uuid);
+      const copyOf = nonEmptyString(obj.forkedFrom?.messageUuid);
+      if (copyOf) {
+        if (uuid) copyParents.set(uuid, copyOf);
+        unit.hasCopies = true;
+      } else if (uuid) {
+        if (originals.has(uuid)) return; // resume 복사본(같은 uuid)
+        originals.add(uuid);
+      }
+
+      const isAssistant = obj.type === 'assistant';
+      const event = { t, start: false, reply: isAssistant || (isUser && isToolResult(obj)), model: isAssistant ? obj.message?.model : undefined };
+      if (isUser) {
+        event.promptId = promptId;
+        event.legacyStart = isLegacyTurnStart(obj);
+      }
+      if (copyOf) event.copyOf = copyOf;
+      unit.events.push(event);
+    } catch {
+      failed = true;
+    }
+  };
+
+  const result = () => {
+    try {
+      closeUnit();
+      const keptCopies = new Set();
+      for (const waiting of pending) {
+        const kept = [];
+        for (const e of waiting.events) {
+          if (e.copyOf !== undefined) {
+            const root = rootOf(e.copyOf);
+            if (originals.has(root) || keptCopies.has(root)) continue;
+            keptCopies.add(root);
+          }
+          kept.push(e);
+        }
+        sumUnit(waiting, kept);
+      }
+      pending.length = 0;
+      return { source: SOURCE, rows: [...totals.values()], ok: !failed };
+    } catch {
+      return { source: SOURCE, rows: [], ok: false };
+    }
+  };
+
+  return { onRecord, result };
+}

package/src/runtime/codex.js

@@ -0,0 +1,128 @@
+import { sumRuntimes } from './timeline.js';
+
+// Codex 실행시간 추출기. parseCodexFiles가 읽은 rollout 줄을 받아 파일(실행 단위)별 턴으로 모은다.
+//  - 파일 신원은 첫 session_meta. 턴은 task_started(turn_started)부터, 그 이벤트가 없는 구버전은 user_message부터.
+//  - task_complete(turn_complete)·turn_aborted 뒤 기록은 다음 턴 시작 전까지 세지 않는다.
+//  - 포크 복사본은 turn_id가 같아 첫 session_meta가 가장 이른 파일 것만 쓴다.
+//  - turn_id가 없는 구버전은 다른 id의 session_meta가 나온 뒤를 복사로 본다.
+
+const SOURCE = 'codex';
+const START_EVENTS = new Set(['task_started', 'turn_started']);
+const END_EVENTS = new Set(['task_complete', 'turn_complete', 'turn_aborted']);
+// 모델 응답·도구 호출과 그 결과(response_item.payload.type)
+const REPLY_ITEMS = new Set([
+  'reasoning', 'agent_message', 'function_call', 'function_call_output', 'custom_tool_call', 'custom_tool_call_output',
+  'local_shell_call', 'web_search_call', 'tool_search_call', 'tool_search_output', 'image_generation_call',
+]);
+// 응답·도구 결과를 알리는 event_msg(legacy 기록 방식)
+const REPLY_EVENTS = new Set([
+  'agent_message', 'agent_reasoning', 'agent_reasoning_raw_content', 'exec_command_end', 'patch_apply_end',
+  'mcp_tool_call_end', 'web_search_end', 'image_generation_end',
+]);
+const INPUT_ITEMS = new Set(['UserMessage', 'HookPrompt']);
+
+function isReply(obj) {
+  const payload = obj.payload;
+  if (obj.type === 'response_item') {
+    return REPLY_ITEMS.has(payload.type) || (payload.type === 'message' && payload.role === 'assistant');
+  }
+  if (obj.type !== 'event_msg') return false;
+  if (payload.type === 'item_completed') return typeof payload.item?.type === 'string' && !INPUT_ITEMS.has(payload.item.type);
+  return REPLY_EVENTS.has(payload.type);
+}
+
+function nonEmptyString(value) {
+  return typeof value === 'string' && value !== '' ? value : null;
+}
+
+/**
+ * Codex 실행시간 수집기를 만든다. onRecord를 parseCodexFiles에 넘겨 같은 읽기에서 이벤트를 모은다.
+ * @returns {{ onRecord: (record: object, file: string) => void,
+ *   result: () => { source: 'codex', rows: Array<{ date: string, source: string, model: string, runtimeMs: number }>, ok: boolean } }}
+ */
+export function createCodexRuntimeCollector() {
+  const files = []; // { path, metaId, metaTime, copying, model, inTask, segments, open }
+  let current = null;
+  let failed = false;
+
+  const fileOf = (path) => {
+    if (current?.path !== path) {
+      current = { path, metaId: null, metaTime: Infinity, copying: false, model: null, inTask: false, segments: [], open: null };
+      files.push(current);
+    }
+    return current;
+  };
+
+  const openSegment = (file, t, turnId) => {
+    file.open = { turnId, copy: turnId === null && file.copying, events: [{ t, start: true }] };
+    file.segments.push(file.open);
+  };
+
+  const onRecord = (obj, path) => {
+    try {
+      const payload = obj?.payload;
+      if (!payload || typeof obj.type !== 'string') return;
+      const file = fileOf(path);
+      const t = Date.parse(obj.timestamp);
+
+      if (obj.type === 'session_meta') {
+        if (file.metaId === null) {
+          file.metaId = nonEmptyString(payload.id) ?? '';
+          const metaTime = Date.parse(payload.timestamp);
+          file.metaTime = Number.isFinite(metaTime) ? metaTime : (Number.isFinite(t) ? t : Infinity);
+        } else if (nonEmptyString(payload.id) && payload.id !== file.metaId) {
+          file.copying = true; // 부모 기록 복사가 시작된다
+          if (file.open?.turnId === null) file.open = null;
+        }
+        return;
+      }
+      if (!Number.isFinite(t)) return;
+      if (obj.type === 'turn_context' && nonEmptyString(payload.model)) file.model = payload.model;
+
+      if (obj.type === 'event_msg' && START_EVENTS.has(payload.type)) {
+        openSegment(file, t, nonEmptyString(payload.turn_id));
+        file.inTask = true;
+        return;
+      }
+      if (obj.type === 'event_msg' && payload.type === 'user_message' && !file.inTask) {
+        openSegment(file, t, null);
+        return;
+      }
+      if (!file.open) return;
+
+      const reply = isReply(obj);
+      file.open.events.push({ t, start: false, reply, model: reply ? file.model : undefined });
+      if (obj.type === 'event_msg' && END_EVENTS.has(payload.type)) {
+        file.open = null;
+        file.inTask = false;
+      }
+    } catch {
+      failed = true;
+    }
+  };
+
+  const result = () => {
+    try {
+      // 같은 turn_id는 첫 session_meta가 가장 이른 파일(같으면 먼저 읽은 파일)이 주인이다.
+      const owners = new Map();
+      files.forEach((file, index) => {
+        for (const segment of file.segments) {
+          if (segment.turnId === null) continue;
+          const owner = owners.get(segment.turnId);
+          if (owner === undefined || file.metaTime < files[owner].metaTime) owners.set(segment.turnId, index);
+        }
+      });
+      const units = files.map((file, index) => ({
+        source: SOURCE,
+        events: file.segments
+          .filter((segment) => (segment.turnId === null ? !segment.copy : owners.get(segment.turnId) === index))
+          .flatMap((segment) => segment.events),
+      }));
+      return { source: SOURCE, rows: sumRuntimes(units), ok: !failed };
+    } catch {
+      return { source: SOURCE, rows: [], ok: false };
+    }
+  };
+
+  return { onRecord, result };
+}

package/src/runtime/opencode.js

@@ -0,0 +1,97 @@
+import { sumRuntimes } from './timeline.js';
+
+// opencode 실행시간 추출기. 토큰 파서가 연 opencode.db 연결로 assistant 메시지의 생성·완료 시각을 읽는다.
+//  - 실행 단위는 세션(자식 세션 포함). 턴은 같은 parentID의 assistant 묶음이고 첫 assistant 생성 시각에 시작한다.
+//  - step-start 파트가 없는 메시지(사용자 셸 명령)와 time.completed가 없는 메시지는 뺀다.
+//  - 포크 복사본은 (role, 생성·완료 시각, modelID)가 같아 가장 먼저 만들어진 세션 것만 쓴다.
+
+const SOURCE = 'opencode';
+const REQUIRED_TABLES = ['session', 'message', 'part'];
+
+const MESSAGE_QUERY = `
+SELECT
+  m.session_id AS sessionId,
+  s.time_created AS sessionCreated,
+  json_extract(m.data, '$.parentID') AS parentId,
+  json_extract(m.data, '$.modelID') AS model,
+  json_extract(m.data, '$.time.created') AS created,
+  json_extract(m.data, '$.time.completed') AS completed
+FROM message m
+LEFT JOIN session s ON s.id = m.session_id
+WHERE json_extract(m.data, '$.role') = 'assistant'
+  AND json_extract(m.data, '$.time.completed') IS NOT NULL
+  AND EXISTS (SELECT 1 FROM part p WHERE p.message_id = m.id AND json_extract(p.data, '$.type') = 'step-start')
+`;
+
+function tablesOf(db) {
+  const rows = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'").all();
+  return new Set(rows.map((row) => row.name));
+}
+
+function isEarlierSession(a, b) {
+  const ta = a.sessionCreated ?? Infinity;
+  const tb = b.sessionCreated ?? Infinity;
+  return ta < tb || (ta === tb && String(a.sessionId) < String(b.sessionId));
+}
+
+// 복사본을 걸러 세션별 실행 단위로 묶는다. 턴마다 메시지 생성(시작)·완료(응답) 이벤트를 만든다.
+function unitsOf(rows) {
+  const owners = new Map();
+  for (const row of rows) {
+    if (!Number.isFinite(row.created) || !Number.isFinite(row.completed)) continue;
+    const key = `assistant\u0000${row.created}\u0000${row.completed}\u0000${row.model}`;
+    const owner = owners.get(key);
+    if (!owner || isEarlierSession(row, owner)) owners.set(key, row);
+  }
+
+  const sessions = new Map(); // 세션 → (parentID → 메시지 목록)
+  for (const row of owners.values()) {
+    let turns = sessions.get(row.sessionId);
+    if (!turns) sessions.set(row.sessionId, (turns = new Map()));
+    const turnKey = row.parentId ?? `\u0000${row.created}`; // parentID가 없으면 메시지 하나가 한 턴
+    const messages = turns.get(turnKey);
+    if (messages) messages.push(row);
+    else turns.set(turnKey, [row]);
+  }
+
+  return Array.from(sessions.values(), (turns) => ({
+    source: SOURCE,
+    events: [...turns.values()].flatMap((messages) => messages
+      .sort((a, b) => a.created - b.created)
+      .flatMap((m, i) => [
+        { t: m.created, start: i === 0, model: m.model },
+        { t: m.completed, reply: true, model: m.model },
+      ])),
+  }));
+}
+
+/**
+ * opencode 실행시간 수집기를 만든다. onDatabase를 parseOpencodeDatabase에 넘겨 같은 연결로 읽는다.
+ * @returns {{ onDatabase: (db: object) => void,
+ *   result: () => { source: 'opencode', rows: Array<{ date: string, source: string, model: string, runtimeMs: number }>, ok: boolean } }}
+ */
+export function createOpencodeRuntimeCollector() {
+  let rows = null; // DB를 열지 못했으면 null로 남는다
+  let ok = false;
+
+  const onDatabase = (db) => {
+    try {
+      const tables = tablesOf(db);
+      if (tables.size === 0) {
+        rows = []; // 기록이 아직 없는 빈 DB
+      } else if (REQUIRED_TABLES.some((name) => !tables.has(name))) {
+        throw new Error('opencode.db schema changed');
+      } else {
+        rows = sumRuntimes(unitsOf(db.prepare(MESSAGE_QUERY).all()));
+      }
+      ok = true;
+    } catch {
+      rows = [];
+      ok = false;
+    }
+  };
+
+  const result = () => ({ source: SOURCE, rows: rows ?? [], ok: rows !== null && ok });
+
+  return { onDatabase, result };
+}

package/src/runtime/read-logs.js

@@ -0,0 +1,46 @@
+import { parseClaudeFiles } from '../parsers/claude.js';
+import { parseCodexFiles } from '../parsers/codex.js';
+import { parseOpencodeDatabase, parseOpencodeFiles } from '../parsers/opencode.js';
+import { createClaudeRuntimeCollector } from './claude.js';
+import { createCodexRuntimeCollector } from './codex.js';
+import { createOpencodeRuntimeCollector } from './opencode.js';
+
+/**
+ * 소스별 실행시간 줄을 이어 붙이고 읽기 성공 여부와 읽지 못한 소스를 모은다. 줄마다 source가 달라 합칠 줄은 없다.
+ * @param {Array<{ source: string, rows: Array<{ date: string, source: string, model: string, runtimeMs: number }>, ok: boolean }>} results 로그가 있는 소스의 결과
+ * @param {string|null} fromDate YYYY-MM-DD(포함). null이면 전체 기간
+ */
+function mergeRuntimeResults(results, fromDate = null) {
+  const runtimes = results.flatMap((result) => result.rows).filter((row) => !fromDate || row.date >= fromDate);
+  const failedSources = results.filter((result) => !result.ok).map((result) => result.source);
+  return { runtimes, allSourcesRead: failedSources.length === 0, failedSources };
+}
+
+/**
+ * 찾은 로그를 소스마다 한 번씩 읽어 토큰 항목과 실행시간을 함께 모은다.
+ * Claude·Codex 파일을 열 수 없으면 예외를 올린다.
+ * @param {{ claudeFiles: string[], codexFiles: string[], opencodeDatabase: string|null, opencodeFiles: string[] }} paths
+ * @param {string|null} [runtimeFrom] 실행시간 시작 날짜 YYYY-MM-DD(포함). null이면 전체 기간
+ * @returns {Promise<{ entries: Array<object>, runtimes: Array<{ date: string, source: string, model: string, runtimeMs: number }>, allSourcesRead: boolean }>}
+ */
+export async function readLogs(paths, runtimeFrom = null) {
+  const claude = createClaudeRuntimeCollector();
+  const codex = createCodexRuntimeCollector();
+  const opencode = createOpencodeRuntimeCollector();
+
+  const [claudeEntries, codexEntries, opencodeEntries] = await Promise.all([
+    parseClaudeFiles(paths.claudeFiles, claude.onRecord),
+    parseCodexFiles(paths.codexFiles, codex.onRecord),
+    paths.opencodeDatabase
+      ? parseOpencodeDatabase(paths.opencodeDatabase, undefined, opencode.onDatabase)
+      : parseOpencodeFiles(paths.opencodeFiles),
+  ]);
+
+  // 로그가 없는 소스(미설치)는 성공 조건에서 뺀다. opencode 옛 JSON 저장소는 실행시간 범위 밖이다.
+  const results = [];
+  if (paths.claudeFiles.length > 0) results.push(claude.result());
+  if (paths.codexFiles.length > 0) results.push(codex.result());
+  if (paths.opencodeDatabase) results.push(opencode.result());
+
+  return { entries: [...claudeEntries, ...codexEntries, ...opencodeEntries], ...mergeRuntimeResults(results, runtimeFrom) };
+}