crewx 0.9.0-rc.2 → 0.9.0-rc.21

package/dist-server/domain/thread/thread.service.js

@@ -17,6 +17,8 @@ const sdk_1 = require("@crewx/sdk");
 const thread_repository_js_1 = require("../../repository/thread.repository.js");
 const crewx_pool_service_js_1 = require("../../modules/crewx-pool.service.js");
 const workspace_context_store_js_1 = require("../../common/workspace-context.store.js");
+const stdout_json_fallback_js_1 = require("../../common/task-log/stdout-json-fallback.js");
+const overdrive_types_js_1 = require("./overdrive.types.js");
 let ThreadService = ThreadService_1 = class ThreadService {
     threadRepo;
     crewxPool;
@@ -45,7 +47,7 @@ let ThreadService = ThreadService_1 = class ThreadService {
         // Sort
         const sort = params.sort || 'updatedAt';
         const order = params.order || 'desc';
-        filtered.sort((a, b) => {
+        const sortCompare = (a, b) => {
             let cmp = 0;
             if (sort === 'messageCount') {
                 cmp = (a.message_count ?? 0) - (b.message_count ?? 0);
@@ -57,12 +59,27 @@ let ThreadService = ThreadService_1 = class ThreadService {
                 cmp = new Date(a.updated_at).getTime() - new Date(b.updated_at).getTime();
             }
             return order === 'asc' ? cmp : -cmp;
-        });
-        // Pagination
+        };
+        filtered.sort(sortCompare);
         const total = filtered.length;
         const limit = this.normalizeLimit(params.limit, 50, 200);
         const offset = this.normalizeOffset(params.offset);
-        const paged = filtered.slice(offset, offset + limit);
+        let paged;
+        if (params.pinnedFirst === false) {
+            // Pure sort order (e.g. sidebar recent list) — pinned threads are not
+            // separated out, so the page reflects a plain updatedAt/createdAt slice.
+            paged = filtered.slice(offset, offset + limit);
+        }
+        else {
+            // Pinned threads must always be visible regardless of the pagination cutoff —
+            // otherwise threads pinned long ago silently fall out of the top-N window as
+            // newer threads accumulate. Pinned rows are shown in full, sorted by the user's
+            // manual pinOrder; only the unpinned remainder is paginated by limit/offset.
+            const pinnedRows = filtered.filter((r) => !!(r.pinned ?? 0));
+            const unpinnedRows = filtered.filter((r) => !(r.pinned ?? 0));
+            pinnedRows.sort((a, b) => this.getPinOrder(a) - this.getPinOrder(b));
+            paged = [...pinnedRows, ...unpinnedRows.slice(offset, offset + limit)];
+        }
         // Batch-fetch tasks for paged threads
         const threadIds = paged.map((r) => r.id);
         const tasksByThread = this.threadRepo.batchFetchTasks(threadIds, workspaceId);
@@ -101,6 +118,7 @@ let ThreadService = ThreadService_1 = class ThreadService {
             updatedAt: threadRow.updated_at,
             pinned: !!(threadRow.pinned ?? 0),
             starred: !!(threadRow.starred ?? 0),
+            overdrive: (0, overdrive_types_js_1.parseOverdriveSummary)(threadRow.metadata),
             totals: {
                 taskCount: stats.taskCount,
                 inputTokens: stats.inputTokens,
@@ -195,11 +213,11 @@ let ThreadService = ThreadService_1 = class ThreadService {
             callerAgentId: row.caller_agent_id || undefined,
         };
         if (wantLogs) {
-            result.logs = this.parseLogs(row.logs, limit, this.extractAdapterKey(row));
+            result.logs = this.parseLogs(row.logs, limit, this.extractAdapterKey(row)).logs;
         }
         if (wantChildren && children) {
             result.childTasks = children.map((child) => {
-                const logs = this.parseLogs(child.logs, 1, this.extractAdapterKey(child));
+                const { logs } = this.parseLogs(child.logs, 1, this.extractAdapterKey(child));
                 return {
                     taskId: child.id,
                     agentId: child.agent_id || '',
@@ -241,12 +259,28 @@ let ThreadService = ThreadService_1 = class ThreadService {
         const newTaskId = (0, sdk_1.generateId)('tsk');
         const agentRef = `@${task.agent_id}`;
         const mode = task.mode ?? 'execute';
+        const originalMetadata = this.parseTaskMetadata(task.metadata);
+        const originalProvider = this.readString(originalMetadata.provider) ?? undefined;
+        const originalWasOverdrive = originalMetadata.overdrive === true;
+        const originalOverdriveMode = originalMetadata.overdriveState === 'latch' ? 'latch' : 'count';
         const crewx = await this.crewxPool.getForCurrentRequest();
         const sdkOptions = {
             threadId,
             taskId: newTaskId,
             platform: 'cli',
-            metadata: { thread: threadId, parentTaskId: null, retriedFromTaskId: taskId },
+            model: task.model ?? undefined,
+            provider: originalProvider,
+            ...(originalWasOverdrive ? { overdrive: { mode: originalOverdriveMode } } : {}),
+            metadata: {
+                thread: threadId,
+                parentTaskId: null,
+                retriedFromTaskId: taskId,
+                ...(originalWasOverdrive ? {
+                    overdrive: true,
+                    overdriveState: originalOverdriveMode,
+                    overdriveMode: mode,
+                } : {}),
+            },
             cwd: (0, workspace_context_store_js_1.getWorkspacePath)(),
         };
         const sdkCall = mode === 'execute'
@@ -309,6 +343,7 @@ let ThreadService = ThreadService_1 = class ThreadService {
                     ?? sessionId
                     ?? this.extractProviderSessionIdFromLogs(task.logs);
                 const providerSessionReady = this.hasProviderResumableContext(task.logs, provider);
+                const { logs: taskLogs, progressSteps } = this.parseLogs(task.logs, 50, this.extractAdapterKey(task));
                 messages.push({
                     id: `${task.id}-assistant`,
                     role: 'assistant',
@@ -330,7 +365,8 @@ let ThreadService = ThreadService_1 = class ThreadService {
                             totalCostUsd,
                             sessionId,
                             error: task.error || null,
-                            logs: this.parseLogs(task.logs, 50, this.extractAdapterKey(task)),
+                            logs: taskLogs,
+                            progressSteps,
                             callerAgentId: task.caller_agent_id ?? null,
                             metadata: {
                                 ...taskMetadata,
@@ -369,7 +405,6 @@ let ThreadService = ThreadService_1 = class ThreadService {
         return cleanLines.join('\n').trim();
     }
     toSummary = (row) => {
-        const meta = row.metadata ? JSON.parse(row.metadata) : {};
         return {
             threadId: row.id,
             platform: row.platform || 'cli',
@@ -379,65 +414,24 @@ let ThreadService = ThreadService_1 = class ThreadService {
             updatedAt: row.updated_at,
             pinned: !!(row.pinned ?? 0),
             starred: !!(row.starred ?? 0),
-            pinOrder: meta.pinOrder ?? 0,
+            pinOrder: this.getPinOrder(row),
+            overdrive: (0, overdrive_types_js_1.parseOverdriveSummary)(row.metadata),
         };
     };
-    validateId(id) {
-        if (!/^[\w\p{L}\p{N}._-]+$/u.test(id)) {
-            throw new common_1.BadRequestException('Invalid ID format');
-        }
-    }
-    /**
-     * Returns true when the raw stdout line is a known metadata-only JSON event that
-     * should be silently dropped rather than shown as raw text.
-     *
-     * Covers Claude, Codex, and OpenCode stream-json protocols.
-     * Only called after parseStdoutEvent() returns [] (no displayable entries).
-     * Partial / truncated JSON → JSON.parse throws → returns false (keep raw text fallback).
-     *
-     * @see TaskService.shouldSkipRawStdoutJsonFallback — keep in sync
-     */
-    shouldSkipRawStdoutJsonFallback(message) {
-        const trimmed = message.trimStart();
-        if (!trimmed.startsWith('{'))
-            return false;
-        let obj;
+    getPinOrder(row) {
+        if (!row.metadata)
+            return 0;
         try {
-            obj = JSON.parse(trimmed);
+            return JSON.parse(row.metadata).pinOrder ?? 0;
         }
         catch {
-            return false;
-        }
-        const type = obj.type;
-        if (typeof type !== 'string')
-            return false;
-        // Claude stream-json metadata events
-        if (type === 'assistant' ||
-            type === 'user' ||
-            type === 'system' ||
-            type === 'result' ||
-            type === 'rate_limit_event') {
-            return true;
-        }
-        // Codex metadata-only events
-        if (type === 'thread.started' ||
-            type === 'turn.started' ||
-            type === 'turn.completed' ||
-            type === 'turn.failed' ||
-            type === 'item.updated') {
-            return true;
-        }
-        // Codex item.started/item.completed reach this function only after
-        // parseStdoutEvent() returned no displayable entries. Skip raw fallback while
-        // preserving the original line in tasks.logs for future reprocessing.
-        if (type === 'item.started' || type === 'item.completed') {
-            return true;
+            return 0;
         }
-        // OpenCode metadata-only events
-        if (type === 'step_start' || type === 'step_finish') {
-            return true;
+    }
+    validateId(id) {
+        if (!/^[\w\p{L}\p{N}._-]+$/u.test(id)) {
+            throw new common_1.BadRequestException('Invalid ID format');
         }
-        return false;
     }
     normalizeLimit(limit, fallback, max) {
         const num = Number(limit);
@@ -459,16 +453,16 @@ let ThreadService = ThreadService_1 = class ThreadService {
     /** @see TaskService.parseLogs — 동일 역할, ACP 파싱 로직 동기화 필요 */
     parseLogs(logsJson, logLimit, providerId) {
         if (!logsJson)
-            return [];
+            return { logs: [], progressSteps: [] };
         let rawLogs;
         try {
             rawLogs = JSON.parse(logsJson);
         }
         catch {
-            return [];
+            return { logs: [], progressSteps: [] };
         }
         if (!Array.isArray(rawLogs))
-            return [];
+            return { logs: [], progressSteps: [] };
         const entries = [];
         for (const log of rawLogs) {
             if (log.level === 'stdout') {
@@ -480,7 +474,7 @@ let ThreadService = ThreadService_1 = class ThreadService {
                     }
                     // Parsed successfully but no displayable entries.
                     // Skip fallback if the raw message is a known metadata-only stream-json event type.
-                    if (this.shouldSkipRawStdoutJsonFallback(log.message))
+                    if ((0, stdout_json_fallback_js_1.shouldSkipRawStdoutJsonFallback)(log.message, providerId))
                         continue;
                 }
                 catch { /* adapter parse failure — fallback to text */ }
@@ -490,13 +484,12 @@ let ThreadService = ThreadService_1 = class ThreadService {
                 entries.push(...(0, sdk_1.defaultParseEvent)(log.message, log.timestamp));
             }
         }
-        // Pipeline: merge consecutive text → deduplicate tool_use → logLimit slice
+        // Pipeline: merge consecutive text → deduplicate tool_use → [branch: text-only slice(-200) = progressSteps] → logLimit slice = logs
         const merged = this.mergeConsecutiveText(entries);
         const deduped = this.deduplicateToolUse(merged);
-        if (deduped.length > logLimit) {
-            return deduped.slice(deduped.length - logLimit);
-        }
-        return deduped;
+        const progressSteps = deduped.filter((e) => e.type === 'text').slice(-200);
+        const logs = deduped.length > logLimit ? deduped.slice(deduped.length - logLimit) : deduped;
+        return { logs, progressSteps };
     }
     /** Merge consecutive type=text entries into one while preserving message boundaries. */
     mergeConsecutiveText(entries) {
@@ -596,6 +589,11 @@ let ThreadService = ThreadService_1 = class ThreadService {
                 if (claudeSessionId) {
                     return claudeSessionId;
                 }
+                // OpenCode: every event carries a top-level `sessionID` (e.g. step_start/tool_use/text).
+                const opencodeSessionId = this.readString(message.sessionID);
+                if (opencodeSessionId) {
+                    return opencodeSessionId;
+                }
             }
             catch {
                 // Ignore non-JSON log lines.
@@ -631,6 +629,9 @@ let ThreadService = ThreadService_1 = class ThreadService {
                 if (providerKey === 'codex' && this.isCodexResumableEvent(message)) {
                     return true;
                 }
+                if (providerKey === 'opencode' && this.isOpencodeResumableEvent(message)) {
+                    return true;
+                }
             }
             catch {
                 // Ignore non-JSON log lines.
@@ -638,6 +639,18 @@ let ThreadService = ThreadService_1 = class ThreadService {
         }
         return false;
     }
+    isOpencodeResumableEvent(message) {
+        const type = typeof message.type === 'string' ? message.type : '';
+        if (type === 'tool_use') {
+            return true;
+        }
+        if (type === 'text') {
+            const part = message.part;
+            const text = part?.text;
+            return typeof text === 'string' && text.trim().length > 0;
+        }
+        return false;
+    }
     isClaudeResumableEvent(message) {
         if (message.type !== 'assistant') {
             return false;

package/dist-server/domain/usage/usage.controller.js

@@ -46,6 +46,14 @@ let UsageController = class UsageController {
         const data = this.usageService.getProviderUsage(from, to, workspace);
         return { success: true, data };
     }
+    // USG.MODEL: 모델별 사용량 집계
+    getModelUsage(from, to, workspace) {
+        if (!from || !to) {
+            throw new common_1.BadRequestException('Both "from" and "to" query parameters are required (ISO 8601)');
+        }
+        const data = this.usageService.getModelUsage(from, to, workspace);
+        return { success: true, data };
+    }
     // USG.LIMITS: 구독 한도 조회
     async getSubscriptionLimits() {
         const data = await this.usageService.getSubscriptionLimits();
@@ -125,6 +133,16 @@ __decorate([
     __metadata("design:paramtypes", [String, String, String]),
     __metadata("design:returntype", void 0)
 ], UsageController.prototype, "getProviderUsage", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'USG.MODEL', summary: 'Get per-model usage aggregation' }),
+    (0, common_1.Get)('models'),
+    __param(0, (0, common_1.Query)('from')),
+    __param(1, (0, common_1.Query)('to')),
+    __param(2, (0, common_1.Query)('workspace')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", void 0)
+], UsageController.prototype, "getModelUsage", null);
 __decorate([
     (0, swagger_1.ApiOperation)({ operationId: 'USG.LIMITS', summary: 'Get subscription limit windows (Codex + Claude)' }),
     (0, common_1.Get)('limits'),

package/dist-server/domain/usage/usage.module.js

@@ -17,5 +17,6 @@ exports.UsageModule = UsageModule = __decorate([
     (0, common_1.Module)({
         controllers: [usage_controller_js_1.UsageController],
         providers: [usage_service_js_1.UsageService],
+        exports: [usage_service_js_1.UsageService],
     })
 ], UsageModule);

package/dist-server/domain/usage/usage.service.js

@@ -62,7 +62,14 @@ const CACHE_MAX_SIZE = 10;
 const CACHE_CLEANUP_INTERVAL = 5 * 60 * 1000; // 5분
 const CLAUDE_OAUTH_CACHE_TTL = 5 * 60 * 1000; // 5분
 const GLM_OAUTH_CACHE_TTL = 5 * 60 * 1000; // 5분
+const CODEX_CACHE_TTL = 5 * 60 * 1000; // 5분
 const OAUTH_FAIL_CACHE_TTL = 30 * 1000; // 30s — short TTL for null (failed) responses
+// --- USR: Usage-report-only aggregation constants ---
+// Rework 판정 임계 — thread 연속호출 간격(분). 실DB 검증: docs/research/ai-skill-report.md §9/§10 (core_dev, WI-20260704-020)
+const REWORK_THRESHOLD_MINUTES = 5;
+// failed 3-way 분류 패턴 (WI-20260704-020 §Side-effect risk areas)
+const USER_STOP_ERROR_RE = /Stopped by user|사용자에 의해 중지됨|SIGTERM 143/i;
+const AGENT_BUG_ERROR_RE = /ACP|orphaned|AGENT_NOT_FOUND|프로세스\s*오류/i;
 let UsageService = UsageService_1 = class UsageService {
     taskRepository;
     projectRepository;
@@ -72,6 +79,7 @@ let UsageService = UsageService_1 = class UsageService {
     cleanupInterval;
     claudeOAuthCache = null;
     glmCache = null;
+    codexCache = null;
     constructor(taskRepository, projectRepository, snapshotRepo) {
         this.taskRepository = taskRepository;
         this.projectRepository = projectRepository;
@@ -231,6 +239,179 @@ let UsageService = UsageService_1 = class UsageService {
         };
         return { from, to, providers, totals };
     }
+    // --- USG.MODEL: Model usage aggregation ---
+    getModelUsage(from, to, workspace) {
+        const rows = this.taskRepository.getModelUsage(from, to, workspace);
+        const grandTotalTokens = rows.reduce((sum, r) => sum + r.totalTokens, 0);
+        const models = rows
+            .map((r) => ({
+            model: r.model,
+            provider: r.provider,
+            totalTokens: r.totalTokens,
+            inputTokens: r.inputTokens,
+            outputTokens: r.outputTokens,
+            cachedInputTokens: r.cachedInputTokens,
+            totalCost: r.costUsd,
+            taskCount: r.totalTasks,
+            activeDurationMs: r.activeDurationMs,
+            sharePercent: grandTotalTokens > 0
+                ? Math.round((r.totalTokens / grandTotalTokens) * 10000) / 100
+                : 0,
+            lastActiveAt: r.lastActiveAt,
+        }))
+            .sort((a, b) => b.totalCost - a.totalCost);
+        const totals = {
+            totalTokens: grandTotalTokens,
+            totalCost: rows.reduce((sum, r) => sum + r.costUsd, 0),
+            totalTasks: rows.reduce((sum, r) => sum + r.totalTasks, 0),
+            totalActiveDurationMs: rows.reduce((sum, r) => sum + r.activeDurationMs, 0),
+        };
+        return { from, to, models, totals };
+    }
+    // --- USR: Rework rate (thread consecutive-call heuristic) ---
+    //
+    // Not a direct DB column — best-effort heuristic per docs/research/ai-skill-report.md §2.1:
+    // "재작업률"은 절대값이 아니라 상대·추세로만 해석해야 한다.
+    getReworkRate(from, to, workspace) {
+        const rows = this.taskRepository.getTasksForReport(from, to, workspace);
+        const qualifying = rows.filter((r) => r.agentId !== 'workflow' && (r.status === 'success' || r.status === 'completed') && r.threadId !== null);
+        // Rows already ordered by started_at ASC (SQL ORDER BY) — group while preserving order.
+        const lastSeenByThread = new Map();
+        let reworkCount = 0;
+        for (const row of qualifying) {
+            const threadId = row.threadId;
+            const prevAt = lastSeenByThread.get(threadId);
+            if (prevAt) {
+                const gapMinutes = (Date.parse(row.startedAt) - Date.parse(prevAt)) / 60000;
+                if (gapMinutes <= REWORK_THRESHOLD_MINUTES)
+                    reworkCount++;
+            }
+            lastSeenByThread.set(threadId, row.startedAt);
+        }
+        const threadedTasks = qualifying.length;
+        const reworkPct = threadedTasks > 0 ? Math.round((reworkCount / threadedTasks) * 1000) / 10 : 0;
+        return { threadedTasks, reworkCount, reworkPct };
+    }
+    // --- USR: Hourly usage (KST 4-slot) ---
+    getHourlyUsage(from, to, workspace) {
+        const rows = this.taskRepository.getTasksForReport(from, to, workspace).filter((r) => r.agentId !== 'workflow');
+        const buckets = {
+            dawn: { total: 0, failed: 0 },
+            morning: { total: 0, failed: 0 },
+            afternoon: { total: 0, failed: 0 },
+            night: { total: 0, failed: 0 },
+        };
+        for (const row of rows) {
+            const kstHour = new Date(Date.parse(row.startedAt) + 9 * 60 * 60 * 1000).getUTCHours();
+            const slot = this.kstHourToSlot(kstHour);
+            buckets[slot].total++;
+            if (row.status === 'failed')
+                buckets[slot].failed++;
+        }
+        const slotOrder = ['dawn', 'morning', 'afternoon', 'night'];
+        const slots = slotOrder.map((slot) => {
+            const b = buckets[slot];
+            return {
+                slot,
+                total: b.total,
+                failPct: b.total > 0 ? Math.round((b.failed / b.total) * 1000) / 10 : 0,
+            };
+        });
+        return { slots };
+    }
+    kstHourToSlot(kstHour) {
+        if (kstHour >= 6 && kstHour <= 11)
+            return 'morning';
+        if (kstHour >= 12 && kstHour <= 17)
+            return 'afternoon';
+        if (kstHour >= 18 && kstHour <= 23)
+            return 'night';
+        return 'dawn';
+    }
+    // --- USR: Failure 3-way breakdown ---
+    //
+    // user_stop / agent_bug are excluded from the failure rate — only true_fail counts
+    // (docs/wi/WI-20260704-020.md §Side-effect risk areas).
+    getFailureBreakdown(from, to, workspace) {
+        const rows = this.taskRepository.getTasksForReport(from, to, workspace).filter((r) => r.agentId !== 'workflow');
+        let userStop = 0;
+        let agentBug = 0;
+        let trueFail = 0;
+        for (const row of rows) {
+            if (row.status !== 'failed')
+                continue;
+            const error = row.error ?? '';
+            if (USER_STOP_ERROR_RE.test(error)) {
+                userStop++;
+            }
+            else if (AGENT_BUG_ERROR_RE.test(error)) {
+                agentBug++;
+            }
+            else {
+                trueFail++;
+            }
+        }
+        const total = rows.length;
+        const failPct = total > 0 ? Math.round((trueFail / total) * 1000) / 10 : 0;
+        return { total, userStop, agentBug, trueFail, failPct };
+    }
+    // --- USR: Agent success rate + rework rate (WI-20260705-001) ---
+    //
+    // Per-agent breakdown for the "partner-fit" section — reuses the exact same 3-way
+    // classification as getFailureBreakdown (agent_bug/user_stop excluded from the failure
+    // count, only true_fail counts) so that per-agent rates stay consistent with the global
+    // failureBreakdown. Rework detection reuses the same REWORK_THRESHOLD_MINUTES heuristic
+    // as getReworkRate (thread-partitioned, globally ordered), attributing each detected
+    // rework event to the agent of the later (follow-up) call.
+    getAgentSuccess(from, to, workspace) {
+        const rows = this.taskRepository.getTasksForReport(from, to, workspace).filter((r) => r.agentId !== 'workflow');
+        const byAgent = new Map();
+        const getAcc = (agentId) => {
+            let acc = byAgent.get(agentId);
+            if (!acc) {
+                acc = { taskCount: 0, trueFail: 0, reworkCount: 0 };
+                byAgent.set(agentId, acc);
+            }
+            return acc;
+        };
+        for (const row of rows) {
+            const acc = getAcc(row.agentId);
+            acc.taskCount++;
+            if (row.status === 'failed') {
+                const error = row.error ?? '';
+                if (!USER_STOP_ERROR_RE.test(error) && !AGENT_BUG_ERROR_RE.test(error)) {
+                    acc.trueFail++;
+                }
+            }
+        }
+        // Rows already ordered by started_at ASC (SQL ORDER BY) — same qualifying filter as
+        // getReworkRate, thread-partitioned globally (not per-agent).
+        const qualifying = rows.filter((r) => (r.status === 'success' || r.status === 'completed') && r.threadId !== null);
+        const lastSeenByThread = new Map();
+        for (const row of qualifying) {
+            const threadId = row.threadId;
+            const prevAt = lastSeenByThread.get(threadId);
+            if (prevAt) {
+                const gapMinutes = (Date.parse(row.startedAt) - Date.parse(prevAt)) / 60000;
+                if (gapMinutes <= REWORK_THRESHOLD_MINUTES) {
+                    getAcc(row.agentId).reworkCount++;
+                }
+            }
+            lastSeenByThread.set(threadId, row.startedAt);
+        }
+        const agents = Array.from(byAgent.entries()).map(([agentId, acc]) => {
+            const successCount = acc.taskCount - acc.trueFail;
+            return {
+                agentId,
+                taskCount: acc.taskCount,
+                successCount,
+                successPct: acc.taskCount > 0 ? Math.round((successCount / acc.taskCount) * 1000) / 10 : 0,
+                reworkCount: acc.reworkCount,
+                reworkPct: acc.taskCount > 0 ? Math.round((acc.reworkCount / acc.taskCount) * 1000) / 10 : 0,
+            };
+        });
+        return { agents };
+    }
     /** Convert UTC ISO string to local date string (YYYY-MM-DD) using timezone. */
     utcToLocalDate(utcIso, tz) {
         try {
@@ -518,6 +699,15 @@ let UsageService = UsageService_1 = class UsageService {
         return { fromIso: from.toISOString(), toIso };
     }
     async parseCodexLimits() {
+        const now = Date.now();
+        if (this.oauthCacheValid(this.codexCache, now, CODEX_CACHE_TTL)) {
+            return this.codexCache.data;
+        }
+        const result = this.computeCodexLimits();
+        this.codexCache = { data: result, ts: now };
+        return result;
+    }
+    computeCodexLimits() {
         try {
             const sessionsDir = path.join(os.homedir(), '.codex', 'sessions');
             const jsonlFile = this.findLatestCodexJsonl(sessionsDir);
@@ -536,10 +726,7 @@ let UsageService = UsageService_1 = class UsageService {
                     const rateLimits = payload?.['rate_limits'];
                     if (!rateLimits)
                         continue;
-                    return {
-                        fiveHour: this.extractCodexWindow(rateLimits['primary']),
-                        weekly: this.extractCodexWindow(rateLimits['secondary']),
-                    };
+                    return this.classifyCodexLimits(rateLimits);
                 }
                 catch {
                     // partial write — try next line
@@ -587,6 +774,61 @@ let UsageService = UsageService_1 = class UsageService {
             return null;
         }
     }
+    /**
+     * Classify Codex rate_limits.primary/secondary into fiveHour/weekly by window_minutes
+     * (WI-20260713-001). Codex CLI payload slot order (primary/secondary) is not stable —
+     * some accounts send primary=weekly with secondary=null. window_minutes value is the
+     * only reliable discriminator:
+     *   - 299~300  -> fiveHour
+     *   - 10079~10080 -> weekly
+     * Legacy fallback (positional primary->fiveHour, secondary->weekly) is applied only
+     * when window_minutes is entirely absent AND both primary+secondary are present
+     * (old dual-slot format). A single present slot with no window_minutes, or a
+     * present-but-unrecognized window_minutes value, is left unclassified rather than
+     * guessed.
+     */
+    classifyCodexLimits(rateLimits) {
+        const primary = rateLimits['primary'];
+        const secondary = rateLimits['secondary'];
+        const primaryIsObj = typeof primary === 'object' && primary !== null;
+        const secondaryIsObj = typeof secondary === 'object' && secondary !== null;
+        let fiveHour = null;
+        let weekly = null;
+        const classifySlot = (slot) => {
+            const wm = slot['window_minutes'];
+            if (typeof wm !== 'number')
+                return 'absent';
+            if (wm >= 299 && wm <= 300)
+                return 'fiveHour';
+            if (wm >= 10079 && wm <= 10080)
+                return 'weekly';
+            return 'unrecognized';
+        };
+        if (primaryIsObj) {
+            const cls = classifySlot(primary);
+            if (cls === 'fiveHour')
+                fiveHour = this.extractCodexWindow(primary);
+            else if (cls === 'weekly')
+                weekly = this.extractCodexWindow(primary);
+        }
+        if (secondaryIsObj) {
+            const cls = classifySlot(secondary);
+            if (cls === 'fiveHour')
+                fiveHour = this.extractCodexWindow(secondary);
+            else if (cls === 'weekly')
+                weekly = this.extractCodexWindow(secondary);
+        }
+        // Absent-only legacy fallback — requires both slots present (old dual-slot shape).
+        if (primaryIsObj && secondaryIsObj) {
+            if (fiveHour === null && classifySlot(primary) === 'absent') {
+                fiveHour = this.extractCodexWindow(primary);
+            }
+            if (weekly === null && classifySlot(secondary) === 'absent') {
+                weekly = this.extractCodexWindow(secondary);
+            }
+        }
+        return { fiveHour, weekly };
+    }
     extractCodexWindow(raw) {
         if (!raw || typeof raw !== 'object')
             return null;

package/dist-server/domain/usage-report/dto/usage-report.dto.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });