tokenphage 2026.8.1 → 2026.11.1

package/README.md

@@ -11,16 +11,16 @@ Claude Code, Codex, opencode의 토큰 사용량을 모아 GitHub README에 붙
 
 ## 📋 요구 사항
 
-- **Node.js 20.17 이상**
+- **Node.js 22.14 이상**
 - macOS 또는 Windows (자동 동기화 사용 시)
 - GitHub 계정
 
 ## 🖼️ 이런 배지가 만들어져요
 
-GitHub README(이미지를 붙일 수 있는 곳이면 어디든)에 아래 한 줄만 넣으면 됩니다. `kobenlys`를 본인 GitHub 아이디로 바꾸세요.
+GitHub README(이미지를 붙일 수 있는 곳이면 어디든)에 아래 한 줄만 넣으면 됩니다. `<your-github-name>`을 본인 GitHub 아이디로 바꾸세요.
 
 ```markdown
-[![TokenPhage](https://api.tokenphage.com/badge/kobenlys)](https://github.com/TOKENPHAGE)
+[![Tokenphage](https://api.tokenphage.com/badge/<your-github-name>)](https://github.com/TOKENPHAGE)
 ```
 
 **결과 ↓**
@@ -33,16 +33,34 @@ GitHub README(이미지를 붙일 수 있는 곳이면 어디든)에 아래 한
   <tr>
     <td align="center">
       <a href="https://github.com/TOKENPHAGE"><img src="https://api.tokenphage.com/badge/kobenlys?theme=gpu&amp;mode=dark" alt="TokenPhage gpu dark 배지"></a><br/>
-      <code>https://api.tokenphage.com/badge/kobenlys?theme=gpu&amp;mode=dark</code>
+      <code>[![Tokenphage](https://api.tokenphage.com/badge/&lt;your-github-name&gt;?theme=gpu&amp;mode=dark)](https://github.com/TOKENPHAGE)</code>
     </td>
     <td align="center">
       <a href="https://github.com/TOKENPHAGE"><img src="https://api.tokenphage.com/badge/kobenlys?theme=claude&amp;mode=light" alt="TokenPhage claude light 배지"></a><br/>
-      <code>https://api.tokenphage.com/badge/kobenlys?theme=claude&amp;mode=light</code>
+      <code>[![Tokenphage](https://api.tokenphage.com/badge/&lt;your-github-name&gt;?theme=claude&amp;mode=light)](https://github.com/TOKENPHAGE)</code>
+    </td>
+  </tr>
+  <tr>
+    <td align="center" colspan="2"><strong>grass-claude · light</strong></td>
+  </tr>
+  <tr>
+    <td align="center" colspan="2">
+      <a href="https://github.com/TOKENPHAGE"><img src="https://api.tokenphage.com/badge/kobenlys?theme=grass-claude" alt="TokenPhage grass-claude light 배지"></a><br/>
+      <code>[![Tokenphage](https://api.tokenphage.com/badge/&lt;your-github-name&gt;?theme=grass-claude)](https://github.com/TOKENPHAGE)</code>
+    </td>
+  </tr>
+  <tr>
+    <td align="center" colspan="2"><strong>grass-claude · dark</strong></td>
+  </tr>
+  <tr>
+    <td align="center" colspan="2">
+      <a href="https://github.com/TOKENPHAGE"><img src="https://api.tokenphage.com/badge/kobenlys?theme=grass-claude&amp;mode=dark" alt="TokenPhage grass-claude dark 배지"></a><br/>
+      <code>[![Tokenphage](https://api.tokenphage.com/badge/&lt;your-github-name&gt;?theme=grass-claude&amp;mode=dark)](https://github.com/TOKENPHAGE)</code>
     </td>
   </tr>
 </table>
 
-> 🎨 URL 뒤에 옵션을 붙일 수 있어요 — 테마 `?theme=gpu`(기본) 또는 `?theme=claude`, 색상 `?mode=light`(기본) 또는 `?mode=dark`.
+> 🎨 URL 뒤에 옵션을 붙일 수 있어요 — 테마 `?theme=gpu`(기본) · `?theme=claude` · `?theme=grass-claude`, 색상 `?mode=light`(기본) 또는 `?mode=dark`.
 
 ## 📦 설치
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenphage",
-  "version": "2026.8.1",
+  "version": "2026.11.1",
   "description": "AI 토큰 사용량 GitHub README 뱃지",
   "author": "kobenlys <kobenlys@gmail.com>",
   "license": "MIT",
@@ -24,6 +24,7 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^8.5.0",
+    "better-sqlite3": "^13.0.3",
     "chalk": "^5.6.2",
     "commander": "^12.1.0",
     "glob": "^11.0.0",
@@ -37,6 +38,6 @@
     "mute-stream": "^3.0.0"
   },
   "engines": {
-    "node": "^20.17.0 || ^22.13.0 || >=23.5.0"
+    "node": "^22.14.0 || >=23.6.0"
   }
 }

package/src/auth.js

@@ -4,6 +4,7 @@ import { join } from 'path';
 import { randomUUID } from 'crypto';
 import { normalizeConfig } from './lib/config-schema.js';
 import { localDateOf } from './lib/dates.js';
+import { apiFetch } from './sync.js';
 
 // 로컬 설정 파일 경로: ~/.tokenphage/config.json (JWT·deviceId·sync 상태 보관)
 const CONFIG_DIR = join(homedir(), '.tokenphage');
@@ -79,18 +80,10 @@ export function getCustomClaudePaths() {
   return Array.isArray(paths) ? paths : [];
 }
 
-/** 마지막 sync 완료 날짜(YYYY-MM-DD)를 반환한다. 없으면 null. */
-export function getLastSyncDate() { return loadConfig().lastSyncDate ?? null; }
-
-/** 마지막 sync 날짜를 저장한다. 다음 sync는 이 날짜 이후만 증분 파싱한다. */
-export function saveLastSyncDate(date) {
-  saveConfig({ ...loadConfig(), lastSyncDate: date });
-}
-
-/** lastSyncDate를 제거해 다음 sync가 전체 히스토리를 재파싱하도록 한다. token/deviceId는 보존. */
-export function clearLastSyncDate() {
-  const { lastSyncDate: _omit, ...rest } = loadConfig();
-  saveConfig(rest);
+/** reset용: lastSyncDate와 lastSyncVersion을 지워 다음 sync가 토큰·실행시간을 처음부터 보내게 한다. 나머지는 보존. */
+export function clearSyncState({ readConfig = loadConfig, writeConfig = saveConfig } = {}) {
+  const { lastSyncDate: _date, lastSyncVersion: _version, ...rest } = readConfig();
+  writeConfig(rest);
 }
 
 // Gist 소유권 검증용 파일명 — 사용자가 이 이름으로 Gist를 만들어야 한다.
@@ -113,8 +106,8 @@ export function parseGistId(input) {
 
 /** url에 JSON body를 POST하고 {ok, status, body}를 반환한다. 응답이 JSON이 아니면 {error: 원문}으로 감싼다. */
 async function postJson(url, body) {
-  // Node 18+ 전역 fetch 사용 (node-fetch 의존성 불필요).
-  const res = await fetch(url, {
+  // 이름표를 붙이고 지원 종료 헤더를 안내하는 공통 요청
+  const res = await apiFetch(url, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(body),

package/src/index.js

@@ -5,14 +5,14 @@
  *       맨 끝 program.parse()가 argv를 해석해 실제 시동을 건다.
  */
 import { Command } from 'commander';
-import { parseAll } from './parser.js';
-import { loadConfig, loadToken, saveToken, getOrCreateDeviceId, gistLogin, setHookInstalled, getLastSyncDate, saveLastSyncDate, clearLastSyncDate } from './auth.js';
-import { syncRecords, resetData } from './sync.js';
+import { parseLogs } from './parser.js';
+import { loadConfig, loadToken, saveToken, getOrCreateDeviceId, gistLogin, setHookInstalled, clearSyncState } from './auth.js';
+import { resetData } from './sync.js';
+import { runSyncFlow } from './sync-flow.js';
 import { installHook, uninstallHook } from './scheduler.js';
 import { reconcileHookRegistration } from './hook-reconcile.js';
 import { promptFirstRun, promptDashboard, promptAdvanced, confirmReset, pauseForEnter, showError } from './ui.js';
 import { accent } from './gradient.js';
-import { localDateOf } from './lib/dates.js';
 import { claudeDirCandidates } from './parser.js';
 import { checkClaudeRetention, applyRetentionSetting, DEFAULT_CLEANUP_DAYS } from './lib/retention.js';
 import { checkLatestVersion, getUpdateInfo } from './lib/update-check.js';
@@ -126,30 +126,11 @@ async function promptRetentionSetup() {
   }
 }
 
-/** sync 명령 본체: 로컬 로그를 파싱(최초=전체 / 이후=증분)해 서버로 업로드하고, 마지막 sync 날짜를 갱신한다. */
+/** sync 명령 본체: 인증·기기 ID를 확인하고 sync 흐름(sync-flow.js)을 실행한다. */
 async function runSync() {
   const token = requireToken();
   const deviceId = getOrCreateDeviceId();
-  const today = localDateOf(new Date());
-
-  // 최초(lastSyncDate 없음)면 fromDate=null → 전체 히스토리 파싱.
-  // 이후엔 직전 sync일부터 오늘까지 증분만 파싱.
-  const lastSyncDate = getLastSyncDate();
-  const fromDate = lastSyncDate ?? null;
-
-  console.log(`Parsing local logs... (${fromDate ?? 'beginning'} ~ ${today})`);
-  const records = await parseAll(fromDate);
-  console.log(`${records.length} records aggregated (date×model)`);
-  if (records.length === 0) {
-    console.log('Nothing to sync.');
-    saveLastSyncDate(today);
-    return;
-  }
-
-  console.log('Uploading to server...');
-  await syncRecords(API_BASE, token, deviceId, records);
-  saveLastSyncDate(today);
-  console.log('Done! Badge will update shortly.');
+  await runSyncFlow({ apiBase: API_BASE, token, deviceId, parseLogs });
 }
 
 /**
@@ -183,8 +164,8 @@ async function runAdvanced(apiBase, cfg) {
     await pauseForEnter();
     return;
   }
-  // 2단계: 로컬 워터마크 제거 후 전체 재-sync. 재-sync가 실패해도 서버 삭제는 이미 완료됐음을 명확히 안내.
-  clearLastSyncDate();
+  // 2단계: 로컬 워터마크(lastSyncDate·lastSyncVersion) 제거 후 전체 재-sync. 재-sync가 실패해도 서버 삭제는 이미 완료됐음을 명확히 안내.
+  clearSyncState();
   console.log(accent('  [OK] Server data reset.') + ' Re-syncing from scratch...');
   try {
     await runSync();

package/src/lib/config-schema.js

@@ -83,6 +83,7 @@ export function normalizeConfig(raw, today) {
   dropIf('token', isJwtShape);
   dropIf('deviceId', isUuid);                         // 없으면 getOrCreateDeviceId가 재발급
   dropIf('lastSyncDate', (v) => isYmdDate(v, today)); // 없으면 전체 재파싱
+  dropIf('lastSyncVersion', (v) => typeof v === 'string' && v !== ''); // 없으면 실행시간 전체 재전송
   dropIf('hookInstalledAt', isIsoDate);
   dropIf('hookInstalled', (v) => typeof v === 'boolean');
   dropIf('claudePaths', isStringArray);

package/src/lib/retention.js

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync, writeFileSync, renameSync } from 'fs';
-import { join } from 'path';
+import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
 
 // Claude Code의 cleanupPeriodDays(트랜스크립트 보존 기간) 검사·설정.
 // 규칙은 하나: 99999 이상이면 통과, 아니면 동의를 받아 무조건 99999로 설정한다.
@@ -41,9 +41,9 @@ export function checkClaudeRetention(claudeDirs) {
 }
 
 /**
- * settings.json의 cleanupPeriodDays를 무조건 99999로 설정한다 (다른 필드 보존, 원자 쓰기).
+ * settings.json의 cleanupPeriodDays를 무조건 99999로 설정한다 (다른 필드 보존, 원자 쓰기, 상위 폴더가 없으면 0700으로 생성).
  * @param {string} settingsPath checkClaudeRetention()이 돌려준 settings.json 경로
- * @returns {boolean} 성공 여부 — 손상 JSON이면 수정하지 않고 false
+ * @returns {boolean} 성공 여부 — 손상 JSON이면 수정하지 않고 false, 쓰기(폴더 생성 포함)에 실패해도 false
  */
 export function applyRetentionSetting(settingsPath) {
   let config = {};
@@ -57,6 +57,7 @@ export function applyRetentionSetting(settingsPath) {
 
   try {
     const next = { ...config, cleanupPeriodDays: FOREVER_DAYS };
+    mkdirSync(dirname(settingsPath), { recursive: true, mode: 0o700 }); // Claude Code가 이 폴더에 대화 기록을 쌓는다
     const tmpPath = settingsPath + '.tmp';
     writeFileSync(tmpPath, JSON.stringify(next, null, 2) + '\n');
     renameSync(tmpPath, settingsPath); // 같은 디렉터리 내 rename = 원자적 교체

package/src/parser.js

@@ -1,10 +1,8 @@
 import { glob } from 'glob';
 import { homedir } from 'os';
-import { parseClaudeFiles } from './parsers/claude.js';
-import { parseCodexFiles } from './parsers/codex.js';
-import { parseOpencodeFiles } from './parsers/opencode.js';
 import { resolveClaudeDirs, resolveOpencodeDirs } from './lib/paths.js';
 import { getCustomClaudePaths } from './auth.js';
+import { readLogs } from './runtime/read-logs.js';
 
 /**
  * 소스별 파서가 돌려준 항목들을 "날짜|모델" 단위 레코드로 합산한다.
@@ -50,7 +48,8 @@ export function opencodeDirCandidates() {
   });
 }
 
-export async function parseAll(fromDate = null) {
+/** 세 도구의 로그 경로를 기존 탐색 순서대로 찾는다. */
+async function discoverLogPaths() {
   // 경로가 겹쳐도 파일 간 first-wins dedup이 흡수하므로 순서만 보장하면 된다.
   const claudeFiles = [];
   for (const dir of claudeDirCandidates()) {
@@ -64,19 +63,33 @@ export async function parseAll(fromDate = null) {
     ...(await globSorted(`${codexHome}/archived_sessions/**/*.jsonl`)),
   ];
 
-  // opencode는 message(모델·시각)와 part(step-finish 토큰)를 모두 읽어야 조인할 수 있다.
-  // parseOpencodeFiles가 내용으로 분류하므로 두 목록을 합쳐 넘긴다(순서 무관).
+  // 최신 opencode는 data home 바로 아래 opencode.db에 저장한다.
+  // DB가 있으면 그 파일만 직접 읽고(구버전에서 마이그레이션된 JSON과의 이중 집계 방지),
+  // DB가 없는 구버전만 storage/message·part JSON을 읽는다.
+  let opencodeDatabase = null;
   const opencodeFiles = [];
   for (const dir of opencodeDirCandidates()) {
     const base = dir.replaceAll('\\', '/');
-    opencodeFiles.push(...await globSorted(`${base}/storage/message/**/*.json`));
-    opencodeFiles.push(...await globSorted(`${base}/storage/part/**/*.json`));
+    if (!opencodeDatabase) {
+      [opencodeDatabase = null] = await globSorted(`${base}/opencode.db`);
+    }
+    if (!opencodeDatabase) {
+      opencodeFiles.push(...await globSorted(`${base}/storage/message/**/*.json`));
+      opencodeFiles.push(...await globSorted(`${base}/storage/part/**/*.json`));
+    }
   }
 
-  const [claudeEntries, codexEntries, opencodeEntries] = await Promise.all([
-    parseClaudeFiles(claudeFiles),
-    parseCodexFiles(codexFiles),
-    parseOpencodeFiles(opencodeFiles),
-  ]);
-  return aggregateRecords([...claudeEntries, ...codexEntries, ...opencodeEntries], fromDate);
+  return { claudeFiles, codexFiles, opencodeDatabase, opencodeFiles };
+}
+
+/**
+ * 로그를 한 번 읽어 토큰 레코드와 실행시간을 함께 계산한다.
+ * @param {{ tokenFrom: string|null, runtimeFrom: string|null }} range YYYY-MM-DD(포함) 또는 null(전체 기간)
+ * @returns {Promise<{ records: Array<{date: string, model: string, inputTok: number, outputTok: number, cacheReadTok: number, cacheCreateTok: number}>,
+ *   runtimes: Array<{ date: string, source: 'claude'|'codex'|'opencode', model: string, runtimeMs: number }>,
+ *   allSourcesRead: boolean, failedSources: string[] }>}
+ */
+export async function parseLogs({ tokenFrom = null, runtimeFrom = null } = {}) {
+  const { entries, runtimes, allSourcesRead, failedSources } = await readLogs(await discoverLogPaths(), runtimeFrom);
+  return { records: aggregateRecords(entries, tokenFrom), runtimes, allSourcesRead, failedSources };
 }

package/src/parsers/claude.js

@@ -50,9 +50,10 @@ function mergedEntry(existing, usage, timestamp) {
 /**
  * Claude 트랜스크립트 파일들을 응답(dedup된 메시지) 단위 usage 목록으로 파싱한다.
  * @param {string[]} files JSONL 파일 경로 목록 (정렬된 순서 = 파일 간 first-wins 기준)
+ * @param {((record: object, file: string) => void)|null} [onRecord] 파싱한 줄마다 부르는 수집기(예외를 던지지 않아야 한다)
  * @returns {Promise<Array<{date: string, model: string, inputTok: number, outputTok: number, cacheReadTok: number, cacheCreateTok: number}>>}
  */
-export async function parseClaudeFiles(files) {
+export async function parseClaudeFiles(files, onRecord = null) {
   const deduped = new Map(); // key → { file, ts, ...entry }
   const noKey = [];          // dedup 키를 만들 수 없는 라인은 전부 집계
 
@@ -62,6 +63,7 @@ export async function parseClaudeFiles(files) {
       if (!line.trim()) continue;
       try {
         const obj = JSON.parse(line);
+        onRecord?.(obj, file);
         if (obj.type !== 'assistant') continue;
         const msg = obj.message;
         if (!msg?.usage) continue;

package/src/parsers/codex.js

@@ -130,9 +130,10 @@ function resolveIncrement(total, last, previous) {
 /**
  * Codex rollout 파일들을 턴 증분 단위 usage 목록으로 파싱한다.
  * @param {string[]} files JSONL 파일 경로 목록 (정렬된 순서 — sessions를 archived보다 먼저)
+ * @param {((record: object, file: string) => void)|null} [onRecord] 파싱한 줄마다 부르는 수집기(예외를 던지지 않아야 한다)
  * @returns {Promise<Array<{date: string, model: string, inputTok: number, outputTok: number, cacheReadTok: number, cacheCreateTok: number}>>}
  */
-export async function parseCodexFiles(files) {
+export async function parseCodexFiles(files, onRecord = null) {
   const entries = [];
   const seenKeys = new Set(); // 파일 간 replay/복제 dedup
 
@@ -158,6 +159,7 @@ export async function parseCodexFiles(files) {
       if (!line.trim()) continue;
       try {
         const obj = JSON.parse(line);
+        onRecord?.(obj, file);
         const payload = obj.payload;
         if (!payload) continue;
 

package/src/parsers/opencode.js

@@ -1,9 +1,16 @@
 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(storage/part/<messageID>/*.json)를 전부 합산해야 정확하다.
+// 스텝별 토큰이 보존된 step-finish part를 전부 합산해야 정확하다.
 // 전략:
 //  - message(role==='assistant')에서 id→{model, date}를 모으고, step-finish part를 messageID로 조인한다.
 //  - 입력 파일 목록에 message/part가 섞여 오고 순서 보장이 없으므로, 두 맵을 모은 뒤 마지막에 조인한다.
@@ -12,6 +19,25 @@ import { localDateOf } from '../lib/dates.js';
 //    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 ?? {};
@@ -26,6 +52,81 @@ function entryOf(date, model, tokens) {
   };
 }
 
+// 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 파일 경로 목록 (섞여 있어도 됨)

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) };
+}

package/src/runtime/timeline.js

@@ -0,0 +1,117 @@
+import { localDateOf } from '../lib/dates.js';
+
+// 공통 타임라인 합산기. 세 소스의 추출기가 만든 실행 단위를 같은 규칙으로 더한다.
+//  - 실행 단위마다 이벤트를 시간순으로 정렬하고, 턴(시작 ~ 마지막 응답·도구 결과) 안의 간격만 센다.
+//  - 간격 하나는 시작 시점부터 GAP_CAP_MS까지만 센다.
+//  - 로컬 자정에서 나눠 날짜별로 넣고, 간격이 시작될 때 일하던 모델에 귀속한다.
+
+/** 간격 하나에서 세는 최대 길이(ms). */
+const GAP_CAP_MS = 300_000;
+
+/**
+ * 실행시간 계산용 이벤트.
+ * @typedef {object} RuntimeEvent
+ * @property {number} t 시각(epoch ms)
+ * @property {boolean} [start] 턴 시작
+ * @property {boolean} [reply] AI 응답 또는 도구 결과(턴 끝 후보)
+ * @property {string|null} [model] 이 이벤트에서 일한 모델
+ */
+
+/**
+ * 메인 세션·서브에이전트처럼 따로 계산해서 더하는 실행 단위.
+ * @typedef {{ source: 'claude'|'codex'|'opencode', events: RuntimeEvent[] }} RuntimeUnit
+ */
+
+/** <synthetic>처럼 '<'로 시작하는 값은 모델로 치지 않는다(토큰 파서와 같은 기준). */
+function isRealModel(model) {
+  return typeof model === 'string' && model !== '' && !model.startsWith('<');
+}
+
+// (날짜, 소스, 모델)별 누적기. 직전에 쓴 날짜 범위를 캐시해 자정 계산을 줄인다.
+function createBuckets() {
+  const totals = new Map();
+  let dayStart = Infinity;
+  let dayEnd = -Infinity;
+  let date = '';
+
+  // 자정은 달력 연산으로 구해 서머타임 전환일(23·25시간)도 맞게 나눈다.
+  const moveTo = (ms) => {
+    const d = new Date(ms);
+    dayStart = new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+    dayEnd = new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1).getTime();
+    date = localDateOf(d);
+  };
+
+  const add = (source, model, from, to) => {
+    for (let a = from; a < to;) {
+      if (a < dayStart || a >= dayEnd) moveTo(a);
+      const b = dayEnd > a ? Math.min(to, dayEnd) : to; // 날짜 계산이 어긋나도 반복이 멈추게 한다
+      const key = `${date}\u0000${source}\u0000${model}`;
+      const row = totals.get(key);
+      if (row) row.runtimeMs += b - a;
+      else totals.set(key, { date, source, model, runtimeMs: b - a });
+      a = b;
+    }
+  };
+
+  const rows = () => Array.from(totals.values(), (row) => ({ ...row, runtimeMs: Math.round(row.runtimeMs) }))
+    .filter((row) => row.runtimeMs > 0);
+
+  return { add, rows };
+}
+
+// 턴 [from, to] 안의 간격을 더하고, 다음 턴에 넘길 마지막 실제 모델을 돌려준다.
+// 첫 간격은 첫 응답의 모델, 이후 간격은 간격이 시작될 때의 모델에 넣는다.
+function sumTurn(events, from, to, carried, source, buckets) {
+  let model = carried;
+  for (let k = from; k <= to; k++) {
+    if (isRealModel(events[k].model)) { model = events[k].model; break; }
+  }
+  for (let k = from; k < to; k++) {
+    if (isRealModel(events[k].model)) model = events[k].model;
+    if (model === null) continue; // 모델을 알 수 없는 시간은 귀속할 곳이 없다
+    const begin = events[k].t;
+    buckets.add(source, model, begin, Math.min(events[k + 1].t, begin + GAP_CAP_MS));
+  }
+  return isRealModel(events[to].model) ? events[to].model : model;
+}
+
+function sumUnit(unit, buckets) {
+  const events = (unit.events ?? []).filter((e) => Number.isFinite(e?.t)).sort((x, y) => x.t - y.t);
+  let carried = null;
+  let i = events.findIndex((e) => e.start);
+  if (i < 0) return;
+  while (i < events.length) {
+    let next = i + 1;
+    while (next < events.length && !events[next].start) next++;
+    let last = next - 1;
+    while (last >= i && !events[last].reply) last--;
+    if (last >= i) carried = sumTurn(events, i, last, carried, unit.source, buckets);
+    i = next;
+  }
+}
+
+/**
+ * 실행시간 줄을 (날짜, 소스, 모델) 키로 더해 모은다.
+ * @param {Map<string, { date: string, source: string, model: string, runtimeMs: number }>} totals 누적 대상
+ * @param {Array<{ date: string, source: string, model: string, runtimeMs: number }>} rows
+ */
+export function addRuntimeRows(totals, rows) {
+  for (const row of rows) {
+    const key = `${row.date}\u0000${row.source}\u0000${row.model}`;
+    const current = totals.get(key);
+    if (current) current.runtimeMs += row.runtimeMs;
+    else totals.set(key, { ...row });
+  }
+}
+
+/**
+ * 실행 단위들의 이벤트로 (날짜, 소스, 모델)별 실행시간을 계산한다.
+ * @param {RuntimeUnit[]} units
+ * @returns {Array<{ date: string, source: string, model: string, runtimeMs: number }>} runtimeMs는 0 초과 정수
+ */
+export function sumRuntimes(units) {
+  const buckets = createBuckets();
+  for (const unit of units) sumUnit(unit, buckets);
+  return buckets.rows();
+}

package/src/sync-flow.js

@@ -0,0 +1,61 @@
+/**
+ * sync 흐름: 기준 날짜·버전 판단 → 파싱 → 전송 → 설정 저장.
+ * index.js는 불러오는 순간 CLI가 시동되어 테스트할 수 없으므로 흐름을 이 모듈로 분리했다.
+ */
+import { loadConfig, saveConfig } from './auth.js';
+import { syncRecords, printWarning, CLI_VERSION } from './sync.js';
+import { localDateOf } from './lib/dates.js';
+
+/**
+ * 로컬 로그를 파싱해 토큰·실행시간을 서버로 보내고, 모든 묶음이 끝난 뒤 설정을 한 번 저장한다.
+ * 토큰은 lastSyncDate부터, 실행시간은 lastSyncVersion이 지금 버전과 같을 때만 lastSyncDate부터(다르면 전체) 보낸다.
+ * parseLogs는 호출부가 넘기고 나머지 의존성은 실제 구현이 기본값이다.
+ * @param {{apiBase: string, token: string, deviceId: string, parseLogs: Function,
+ *          readConfig?: Function, writeConfig?: Function, fetchImpl?: Function, version?: string,
+ *          today?: string, log?: Function, interactive?: boolean}} deps
+ * @throws {Error} 파싱 실패나 첫 요청 실패 시(설정은 바꾸지 않는다)
+ */
+export async function runSyncFlow({
+  apiBase,
+  token,
+  deviceId,
+  parseLogs,
+  readConfig = loadConfig,
+  writeConfig = saveConfig,
+  fetchImpl = globalThis.fetch,
+  version = CLI_VERSION,
+  today = localDateOf(new Date()), // 시작 시 1회 계산: 자정을 넘겨도 시작일을 저장한다
+  log = console.log,
+  interactive = Boolean(process.stdin.isTTY),
+}) {
+  const warn = (msg) => printWarning(msg, { interactive, log });
+  const { lastSyncDate = null, lastSyncVersion } = readConfig();
+  const tokenFrom = lastSyncDate;
+  const runtimeFrom = lastSyncVersion === version ? tokenFrom : null; // 버전이 다르면 실행시간은 전체 기간
+
+  log(`Parsing local logs... (${tokenFrom ?? 'beginning'} ~ ${today})`);
+  const { records, runtimes, allSourcesRead, failedSources = [] } = await parseLogs({ tokenFrom, runtimeFrom });
+  log(`${records.length} records aggregated (date×model)`);
+  log(`${runtimes.length} runtime records aggregated (date×source×model)`);
+  if (!allSourcesRead) warn(`Could not read ${failedSources.join(', ') || 'some'} logs. They were skipped in this sync.`);
+
+  const hasData = records.length > 0 || runtimes.length > 0;
+  let runtimesOk = true;
+  if (hasData) {
+    log('Uploading to server...');
+    const result = await syncRecords(apiBase, token, deviceId, records, runtimes, { fetchImpl, onNotice: warn });
+    if (result.rejected > 0) warn(`${result.rejected} runtime record(s) were rejected by the server.`);
+    if (result.failure) warn(`Runtime upload incomplete, it will be resent on the next sync: ${result.failure}`);
+    else if (!result.runtimesOk) warn('The server did not confirm runtime records. They will be resent on the next sync.'); // API 롤백으로 실행시간을 모르는 옛 서버를 만난 경우
+    runtimesOk = result.runtimesOk;
+  } else {
+    log('Nothing to sync.');
+  }
+
+  // 모든 묶음 뒤 1회 저장. 전송이 성공하면 버전을 남긴다(못 읽은 도구로 지우면 매일 전체 재전송)
+  const { lastSyncVersion: _previous, ...rest } = readConfig();
+  writeConfig(runtimesOk
+    ? { ...rest, lastSyncDate: today, lastSyncVersion: version }
+    : { ...rest, lastSyncDate: today });
+  if (hasData) log('Done! Badge will update shortly.');
+}

package/src/sync.js

@@ -1,3 +1,17 @@
+import chalk from 'chalk';
+import { createRequire } from 'node:module';
+
+// package.json의 version: 이름표와 lastSyncVersion에 쓴다
+export const CLI_VERSION = createRequire(import.meta.url)('../package.json').version;
+
+// 모든 API 요청에 붙이는 이름표
+const USER_AGENT = `tokenphage-cli/${CLI_VERSION} (${process.platform}; ${process.arch}) node/${process.versions.node}`;
+
+// 서버가 한 요청에 받는 실행시간 최대 개수(SyncRequest.MAX_RECORDS)
+const MAX_RUNTIMES_PER_REQUEST = 10_000;
+
+const UPDATE_HINT = 'Update: npm i -g tokenphage@latest';
+
 /**
  * 서버 HTTP 상태코드를 사용자 대면 메시지로 매핑한다(응답 원문은 노출하지 않음).
  * @param {number} status HTTP 상태코드
@@ -11,27 +25,105 @@ export function mapServerError(status, bodyText) {
     if (lower.includes('deviceid')) return 'Your config file looks corrupted. Run `tokenphage login` to re-authenticate.';
     return 'Request format error. Update the CLI: npm i -g tokenphage@latest';
   }
+  if (status === 410 || status === 426) return `This CLI version is no longer supported. ${UPDATE_HINT}`; // 지원 종료
   if (status >= 500) return 'Server temporarily unavailable. Your existing badge data is safe.';
   return `Server error: ${status}`; // 매핑되지 않은 상태 폴백
 }
 
+/** 경고 1줄을 남긴다. 대화형은 노란색, 헤드리스는 평문(스케줄러 래퍼가 stdout을 sync.log로 보낸다). */
+export function printWarning(msg, { interactive = Boolean(process.stdin.isTTY), log = console.log } = {}) {
+  const line = `! ${msg}`;
+  log(interactive ? chalk.yellow(line) : line);
+}
+
+/** Link 헤더에서 rel="deprecation" 주소를 찾는다. 없으면 null. */
+function deprecationLink(link) {
+  for (const part of (link ?? '').split(/,(?=\s*<)/)) {
+    const [, url, params = ''] = part.match(/<([^>]*)>(.*)/) ?? [];
+    const rel = params.match(/;\s*rel\s*=\s*"?([^";]*)/i)?.[1] ?? '';
+    if (url && rel.toLowerCase().split(/\s+/).includes('deprecation')) return url;
+  }
+  return null;
+}
+
+/** 응답의 Deprecation·Sunset·Link(rel="deprecation") 헤더로 지원 종료 안내 1줄을 만든다. 없으면 null. */
+function deprecationNotice(headers) {
+  if (typeof headers?.get !== 'function') return null; // 헤더가 없는 응답도 통과
+  const deprecation = headers.get('deprecation');
+  const sunset = headers.get('sunset');
+  const link = deprecationLink(headers.get('link'));
+  if (!deprecation && !sunset && !link) return null;
+  const until = sunset ? ` and stops working after ${sunset}` : '';
+  const details = link ? ` (details: ${link})` : '';
+  return `This CLI version is deprecated${until}. ${UPDATE_HINT}${details}`;
+}
+
 /**
- * 집계된 토큰 사용 기록을 서버에 업로드한다 (POST /api/sync).
- * 사용자는 서버가 JWT(Bearer)에서 식별하고, 본문에 deviceId와 records를 담아 보낸다.
+ * API 공통 요청: 이름표(User-Agent)를 붙이고, 응답에 지원 종료 헤더가 있으면 onNotice로 안내한다.
+ * @param {string} url
+ * @param {object} init fetch 옵션
+ * @param {{fetchImpl?: Function, onNotice?: (msg: string) => void}} [deps]
+ * @returns {Promise<Response>}
+ */
+export async function apiFetch(url, init, { fetchImpl = globalThis.fetch, onNotice = printWarning } = {}) {
+  const res = await fetchImpl(url, { ...init, headers: { ...init.headers, 'User-Agent': USER_AGENT } });
+  const notice = deprecationNotice(res.headers);
+  if (notice) onNotice(notice);
+  return res;
+}
+
+/** 2xx 응답 본문의 실행시간 결과({accepted, rejected})를 읽는다. 없거나 형식이 다르면 null. */
+async function runtimeResult(res) {
+  try {
+    const result = JSON.parse(await res.text())?.runtimes;
+    return Number.isInteger(result?.accepted) && Number.isInteger(result?.rejected) ? result : null;
+  } catch {
+    return null; // 빈 본문(API 롤백으로 만난 옛 API)·비JSON
+  }
+}
+
+/**
+ * 토큰 레코드와 실행시간을 서버에 업로드한다 (POST /api/sync).
+ * 토큰은 첫 요청에 모두 싣고, 실행시간은 10,000개씩 나눠 남은 묶음을 records: []와 함께 보낸다.
+ * 실행시간이 없으면 runtimes 칸을 빼 지금과 같은 {deviceId, records}를 보낸다.
  * @param {string} apiBase  API 서버 base URL
  * @param {string} token    Bearer JWT
  * @param {string} deviceId 기기 식별 UUID
  * @param {Array<{date:string, model:string, inputTok:number, outputTok:number, cacheReadTok:number, cacheCreateTok:number}>} records 날짜·모델별 집계 레코드
- * @throws {Error} 2xx가 아니면 mapServerError 메시지로 throw
+ * @param {Array<{date:string, source:string, model:string, runtimeMs:number}>} [runtimes] 날짜·도구·모델별 실행시간
+ * @param {{fetchImpl?: Function, onNotice?: (msg: string) => void}} [deps]
+ * @returns {Promise<{runtimesOk: boolean, rejected: number, failure: string|null}>}
+ *   runtimesOk는 실행시간을 모두 보냈고 응답마다 결과가 있을 때 true, failure는 후속 요청 실패 사유
+ * @throws {Error} 첫 요청이 2xx가 아니면 mapServerError 메시지로 throw
  */
-export async function syncRecords(apiBase, token, deviceId, records) {
-  // Node 18+ 전역 fetch 사용 (node-fetch 의존성 불필요).
-  const res = await fetch(`${apiBase}/api/sync`, {
+export async function syncRecords(apiBase, token, deviceId, records, runtimes = [], { fetchImpl, onNotice = printWarning } = {}) {
+  let noticed = false; // 묶음이 여러 개여도 지원 종료 안내는 1줄
+  const post = (body) => apiFetch(`${apiBase}/api/sync`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },
-    body: JSON.stringify({ deviceId, records }),
-  });
+    body: JSON.stringify(body),
+  }, { fetchImpl, onNotice: (msg) => { if (!noticed) onNotice(msg); noticed = true; } });
+
+  // 첫 요청: 토큰 전부와 첫 실행시간 묶음. 실패하면 지금처럼 throw
+  const first = runtimes.slice(0, MAX_RUNTIMES_PER_REQUEST);
+  const res = await post(first.length ? { deviceId, records, runtimes: first } : { deviceId, records });
   if (!res.ok) throw new Error(mapServerError(res.status, await res.text()));
+  if (!first.length) return { runtimesOk: true, rejected: 0, failure: null };
+
+  let result = await runtimeResult(res);
+  let rejected = result?.rejected ?? 0;
+  // 후속 요청: 남은 실행시간만. 결과가 없거나 실패하면 멈추고 미완료로 돌려준다
+  for (let i = MAX_RUNTIMES_PER_REQUEST; result && i < runtimes.length; i += MAX_RUNTIMES_PER_REQUEST) {
+    try {
+      const next = await post({ deviceId, records: [], runtimes: runtimes.slice(i, i + MAX_RUNTIMES_PER_REQUEST) });
+      if (!next.ok) return { runtimesOk: false, rejected, failure: mapServerError(next.status, await next.text()) };
+      result = await runtimeResult(next);
+    } catch (err) {
+      return { runtimesOk: false, rejected, failure: err.message };
+    }
+    rejected += result?.rejected ?? 0;
+  }
+  return { runtimesOk: result !== null, rejected, failure: null };
 }
 
 /**
@@ -40,7 +132,7 @@ export async function syncRecords(apiBase, token, deviceId, records) {
  * @param {string} token  Bearer JWT
  */
 export async function resetData(apiBase, token) {
-  const res = await fetch(`${apiBase}/api/reset`, {
+  const res = await apiFetch(`${apiBase}/api/reset`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },
   });