opencode-metrics-plugin 0.1.5

package/dist/metrics-output.js

@@ -0,0 +1,673 @@
+import * as fs from "fs";
+import * as path from "path";
+import { log } from "./logger.js";
+import { createTokenUsage } from "./metrics-types.js";
+import { getMetricsDir, getSummaryFile } from "./dirs.js";
+import { upsertSessionSnapshot } from "./summary-store.js";
+import { buildSteps, extractStepContent } from "./metrics-steps.js";
+function filterByKeys(source, keys) {
+    const result = new Map();
+    for (const key of keys) {
+        const val = source.get(key);
+        if (val !== undefined)
+            result.set(key, val);
+    }
+    return result;
+}
+function flushMetrics(sessionId, state, now, dirs) {
+    // Finalize agent usage for current agent
+    if (state.agent.current) {
+        const elapsed = now - state.agent.lastSwitchTime;
+        const prev = state.agent.usage.get(state.agent.current) ?? 0;
+        state.agent.usage.set(state.agent.current, prev + elapsed);
+    }
+    const endTime = now;
+    const duration = endTime - state.startTime;
+    // Calculate cache hit rate
+    const denom = state.tokens.input + state.tokens.cacheRead;
+    const cacheHitRate = denom > 0 ? state.tokens.cacheRead / denom : 0;
+    // Build tool distribution from Map to Record
+    const toolDistribution = {};
+    for (const [tool, stats] of state.tools.distribution) {
+        toolDistribution[tool] = {
+            calls: stats.calls,
+            errors: stats.errors,
+            avgDuration: stats.calls > 0 ? stats.totalDuration / stats.calls : 0,
+            maxDuration: stats.maxDuration,
+        };
+    }
+    // Build model token distribution from Map to Record
+    const modelTokenDistribution = {};
+    for (const [modelId, tokens] of state.model.tokenDistribution) {
+        modelTokenDistribution[modelId] = { ...tokens };
+    }
+    // Build agent usage from Map to Record
+    const agentUsage = {};
+    for (const [agent, usage] of state.agent.usage) {
+        agentUsage[agent] = usage;
+    }
+    const totalCompleted = state.tools.completedCalls + state.tools.errorCalls;
+    const successRate = totalCompleted > 0 ? state.tools.completedCalls / totalCompleted : 0;
+    // Consolidate header with agent/model info
+    const header = {
+        ...state.sessionMeta,
+        sessionId,
+        startTime: new Date(state.startTime).toISOString(),
+        agent: state.agent.current || state.sessionMeta.agent,
+        agentSwitches: state.agent.switches,
+        agentUsage,
+        model: state.model.current || state.sessionMeta.model,
+        modelSwitches: state.model.switches,
+        modelTokenDistribution,
+    };
+    // Aggregate parent step tokens from messageMap (covers message.updated without step-finish)
+    const parentStepTokens = createTokenUsage();
+    for (const entry of state.messageMap.values()) {
+        parentStepTokens.input += entry.tokens.input;
+        parentStepTokens.output += entry.tokens.output;
+        parentStepTokens.reasoning += entry.tokens.reasoning;
+        parentStepTokens.cacheRead += entry.tokens.cacheRead;
+        parentStepTokens.cacheWrite += entry.tokens.cacheWrite;
+        parentStepTokens.total += entry.tokens.total;
+    }
+    // Extract content from parent log once (sub-agent events are also written here)
+    const allContentMaps = extractStepContent(sessionId, { eventsDir: dirs?.eventsDir });
+    // Count parent steps (messages with finish + tokens)
+    const parentStepCount = [...state.messageMap.values()].filter(m => m.finish && m.tokens.total > 0).length;
+    // Build sub-agents first so we can aggregate their tokens/tools
+    const subagents = [];
+    let subAgentTotalCalls = 0;
+    let subAgentStepCount = 0;
+    const subAgentTokens = createTokenUsage();
+    log.info("[Metrics] flushMetrics subagents", { sessionId, subAgentsCount: state.subAgents.size, subAgentsKeys: [...state.subAgents.keys()] });
+    for (const [childId, sub] of state.subAgents) {
+        // Filter content maps to this sub-agent's message IDs
+        const subMsgIds = new Set(sub.messageMap.keys());
+        const subContentMaps = {
+            textMap: filterByKeys(allContentMaps.textMap, subMsgIds),
+            reasoningMap: filterByKeys(allContentMaps.reasoningMap, subMsgIds),
+            toolOutputMap: allContentMaps.toolOutputMap,
+        };
+        const steps = buildSteps(sub, subContentMaps);
+        // Aggregate sub-agent tokens from messageMap
+        const subTokens = createTokenUsage();
+        for (const entry of sub.messageMap.values()) {
+            subTokens.input += entry.tokens.input;
+            subTokens.output += entry.tokens.output;
+            subTokens.reasoning += entry.tokens.reasoning;
+            subTokens.cacheRead += entry.tokens.cacheRead;
+            subTokens.cacheWrite += entry.tokens.cacheWrite;
+            subTokens.total += entry.tokens.total;
+        }
+        // Aggregate sub-agent tool stats + distribution from toolCallMap
+        let totalCalls = 0;
+        let completedCalls = 0;
+        let errorCalls = 0;
+        const subDistribution = {};
+        let subSlowestCall = { tool: "", duration: 0 };
+        for (const tc of sub.toolCallMap.values()) {
+            if (tc.status === "completed") {
+                totalCalls++;
+                completedCalls++;
+            }
+            else if (tc.status === "error") {
+                totalCalls++;
+                errorCalls++;
+            }
+            if (tc.status === "completed" || tc.status === "error") {
+                const duration = tc.endMs && tc.startMs ? tc.endMs - tc.startMs : 0;
+                const stats = subDistribution[tc.tool] ?? { calls: 0, errors: 0, totalDuration: 0, maxDuration: 0 };
+                stats.calls++;
+                stats.totalDuration += duration;
+                if (duration > stats.maxDuration)
+                    stats.maxDuration = duration;
+                if (tc.status === "error")
+                    stats.errors++;
+                subDistribution[tc.tool] = stats;
+                if (duration > subSlowestCall.duration)
+                    subSlowestCall = { tool: tc.tool, duration };
+            }
+        }
+        const subSuccessRate = totalCalls > 0 ? completedCalls / totalCalls : 0;
+        // Convert distribution totalDuration 鈫?avgDuration
+        const distribution = {};
+        for (const [tool, stats] of Object.entries(subDistribution)) {
+            distribution[tool] = {
+                calls: stats.calls,
+                errors: stats.errors,
+                avgDuration: stats.calls > 0 ? stats.totalDuration / stats.calls : 0,
+                maxDuration: stats.maxDuration,
+            };
+        }
+        // Accumulate into parent totals
+        subAgentTokens.input += subTokens.input;
+        subAgentTokens.output += subTokens.output;
+        subAgentTokens.reasoning += subTokens.reasoning;
+        subAgentTokens.cacheRead += subTokens.cacheRead;
+        subAgentTokens.cacheWrite += subTokens.cacheWrite;
+        subAgentTokens.total += subTokens.total;
+        subAgentTotalCalls += totalCalls;
+        subAgentStepCount += steps.length;
+        subagents.push({
+            sessionId: childId,
+            agent: sub.agentName,
+            title: sub.title,
+            steps,
+            tokens: subTokens,
+            tools: {
+                totalCalls,
+                invalidCalls: 0,
+                successRate: subSuccessRate,
+                distribution,
+                slowestCall: subSlowestCall,
+            },
+            ...(sub._pendingUserMessage.length > 0
+                ? { userMessages: [...sub._pendingUserMessage] }
+                : {}),
+        });
+    }
+    // Build planning metrics 鈥?summary from last call's todos, history in calls[]
+    const planning = (() => {
+        const calls = state.planningCalls;
+        const rounds = calls.length;
+        const empty = {
+            planningRounds: 0, totalPlanningDuration: 0, avgPlanningDuration: 0,
+            totalTasks: 0, completedTasks: 0, inProgressTasks: 0, pendingTasks: 0,
+            completionRate: 0, priorityDistribution: {}, calls: [],
+        };
+        if (rounds === 0)
+            return empty;
+        const totalDuration = calls.reduce((sum, c) => sum + c.durationMs, 0);
+        const lastTodos = calls[calls.length - 1].todos;
+        const totalTasks = lastTodos.length;
+        const completedTasks = lastTodos.filter(t => t.status === "completed").length;
+        const inProgressTasks = lastTodos.filter(t => t.status === "in_progress").length;
+        const pendingTasks = lastTodos.filter(t => t.status === "pending").length;
+        const priorityDistribution = {};
+        for (const t of lastTodos) {
+            priorityDistribution[t.priority] = (priorityDistribution[t.priority] || 0) + 1;
+        }
+        return {
+            planningRounds: rounds,
+            totalPlanningDuration: totalDuration,
+            avgPlanningDuration: Math.round(totalDuration / rounds),
+            totalTasks,
+            completedTasks,
+            inProgressTasks,
+            pendingTasks,
+            completionRate: totalTasks > 0 ? completedTasks / totalTasks : 0,
+            priorityDistribution,
+            calls,
+        };
+    })();
+    const systemPrompts = {};
+    for (const [modelId, system] of state.systemPrompts) {
+        systemPrompts[modelId] = system;
+    }
+    const output = {
+        sessionId,
+        startTime: state.startTime,
+        endTime,
+        duration,
+        systemPrompts,
+        rounds: state.rounds,
+        tokens: (() => {
+            const totalTokens = Math.max(state.tokens.total, parentStepTokens.total) + subAgentTokens.total;
+            const totalSteps = parentStepCount + subAgentStepCount;
+            return {
+                // Use the larger of step-finish tokens or messageMap tokens for parent
+                input: Math.max(state.tokens.input, parentStepTokens.input) + subAgentTokens.input,
+                output: Math.max(state.tokens.output, parentStepTokens.output) + subAgentTokens.output,
+                reasoning: Math.max(state.tokens.reasoning, parentStepTokens.reasoning) + subAgentTokens.reasoning,
+                cacheRead: Math.max(state.tokens.cacheRead, parentStepTokens.cacheRead) + subAgentTokens.cacheRead,
+                cacheWrite: Math.max(state.tokens.cacheWrite, parentStepTokens.cacheWrite) + subAgentTokens.cacheWrite,
+                total: totalTokens,
+                cacheHitRate,
+                avgTokensPerStep: totalSteps > 0 ? Math.round(totalTokens / totalSteps) : 0,
+            };
+        })(),
+        tools: {
+            totalCalls: state.tools.totalCalls + subAgentTotalCalls,
+            invalidCalls: state.tools.invalidCalls,
+            successRate,
+            distribution: toolDistribution,
+            slowestCall: state.tools.slowestCall,
+        },
+        compactions: state.compactions,
+        anomaly: state.anomaly,
+        stages: state.stages.map(s => ({
+            stage: s.stage,
+            duration: s.endTime - s.startTime,
+            hvigorwCalls: s.hvigorwCalls,
+            tokens: { ...s.tokens },
+        })),
+        header,
+        codeStats: {
+            etsLines: state.compileStats.etsLines,
+            buildSuccess: state.compileStats.lastBuildSuccess,
+            fixCompileCount: state.compileStats.hvigorwCalls,
+            totalCompileErrors: state.compileStats.hvigorwErrors,
+            firstBuildPerRound: state.compileStats.firstBuildPerRound,
+            firstBuildPassRate: state.compileStats.firstBuildPerRound.length > 0
+                ? state.compileStats.firstBuildPerRound.filter(Boolean).length / state.compileStats.firstBuildPerRound.length
+                : 0,
+            errorCodes: [...state.compileStats.errorCodes.entries()]
+                .map(([code, info]) => ({ code, ...info }))
+                .sort((a, b) => b.count - a.count),
+            warnings: (() => {
+                const entries = [];
+                const byType = {};
+                let total = 0;
+                for (const [type, info] of state.compileStats.warnings) {
+                    byType[type] = info.count;
+                    total += info.count;
+                    for (const entry of info.entries)
+                        entries.push(entry);
+                }
+                return { total, byType, entries };
+            })(),
+            fixCycles: {
+                successRate: state.compileStats.fixCycles.length > 0
+                    ? state.compileStats.fixCycles.filter(c => c.successTime > 0).length / state.compileStats.fixCycles.length
+                    : 0,
+                avgAttempts: state.compileStats.fixCycles.length > 0
+                    ? state.compileStats.fixCycles.reduce((sum, c) => sum + c.attempts, 0) / state.compileStats.fixCycles.length
+                    : 0,
+                cycles: state.compileStats.fixCycles.map(c => ({
+                    success: c.successTime > 0,
+                    attempts: c.attempts,
+                    codeChanges: c.codeChanges,
+                    durationMs: c.successTime > 0 ? c.successTime - c.failTime : 0,
+                })),
+            },
+            moduleTimings: [...state.compileStats.moduleTimings.entries()]
+                .map(([module, timing]) => ({
+                module,
+                totalDurationMs: timing.totalDuration,
+                taskCount: timing.taskCount,
+                slowestTask: timing.slowestTask,
+            }))
+                .sort((a, b) => b.totalDurationMs - a.totalDurationMs),
+        },
+        responseLength: [...state.textLengthMap.values()].reduce((sum, len) => sum + len, 0),
+        skills: [...state.skillCallMap.values()].map(entry => ({
+            skillName: entry.skillName,
+            status: entry.status,
+        })),
+        skillSearches: [...state.skillSearchMap.values()].map(entry => ({
+            query: entry.query,
+            skillPath: entry.skillPath,
+            topK: entry.topK,
+            output: entry.output,
+            durationMs: entry.endMs && entry.startMs ? entry.endMs - entry.startMs : 0,
+            followUpReads: entry.followUpReads.map(r => r.filePath),
+        })),
+        planning,
+        steps: buildSteps(state, {
+            textMap: filterByKeys(allContentMaps.textMap, new Set(state.messageMap.keys())),
+            reasoningMap: filterByKeys(allContentMaps.reasoningMap, new Set(state.messageMap.keys())),
+            toolOutputMap: allContentMaps.toolOutputMap,
+        }),
+        subagents,
+    };
+    try {
+        const metricsDir = dirs?.metricsDir ?? getMetricsDir();
+        fs.mkdirSync(metricsDir, { recursive: true });
+        const filePath = path.join(metricsDir, `${sessionId}.json`);
+        let merged = { ...output, source: "live" };
+        try {
+            const existingRaw = fs.readFileSync(filePath, "utf-8");
+            const existingOutput = JSON.parse(existingRaw);
+            merged = { ...mergeMetricsOutput(existingOutput, output), source: "live" };
+        }
+        catch {
+            // File doesn't exist or is corrupted 鈥?use fresh output
+        }
+        const tmpPath = filePath + ".tmp";
+        fs.writeFileSync(tmpPath, JSON.stringify(merged, null, 2));
+        fs.renameSync(tmpPath, filePath);
+        // 摘要/详情双表联动入库（force：与文件同拍最新；缺省写全局共享库，显式 summaryFile 可隔离）
+        const summaryFile = dirs?.summaryFile ?? getSummaryFile();
+        upsertSessionSnapshot(summaryFile, merged, filePath, "force");
+    }
+    catch (err) {
+        log.info("Failed to flush metrics", { sessionId, error: String(err) });
+    }
+    return output;
+}
+function handleSessionIdle(state, sessionId, dirs) {
+    const now = Date.now();
+    // Build round snapshot
+    const roundDuration = now - state._roundStartTime;
+    const firstTokenLatency = state._hasTextPart && state._firstEventTime > 0
+        ? state._firstTextTime - state._firstEventTime
+        : 0;
+    // Skip duplicate session.idle 鈥?round was already created
+    if (state._roundIdleProcessed) {
+        return;
+    }
+    const isEmptyRound = state._roundTokens.total === 0 && state._roundToolCalls === 0;
+    // Only create round snapshot for non-empty rounds
+    if (!isEmptyRound) {
+        const round = {
+            roundIndex: state.rounds.length,
+            duration: roundDuration,
+            firstTokenLatency,
+            tokens: { ...state._roundTokens },
+            toolCalls: state._roundToolCalls,
+            errors: state._roundErrors,
+            userMessage: state._pendingUserMessage.length > 0 ? [...state._pendingUserMessage] : undefined,
+        };
+        state.rounds.push(round);
+    }
+    state._roundIdleProcessed = true;
+    // Reset per-round state
+    state._roundStartTime = now;
+    state._firstEventTime = 0;
+    state._firstTextTime = 0;
+    state._hasFirstEvent = false;
+    state._hasTextPart = false;
+    state._roundTokens = createTokenUsage();
+    state._roundToolCalls = 0;
+    state._roundErrors = 0;
+    state._pendingUserMessage = [];
+    state._roundFirstBuildTracked = false;
+    // Finalize current stage
+    if (state.currentStage) {
+        state.currentStage.endTime = now;
+        state.currentStage.tokens = { ...state._stageTokens };
+        if (state.currentStage.stage === "build") {
+            state.currentStage.hvigorwCalls = state.compileStats.hvigorwCalls;
+        }
+        state.stages.push(state.currentStage);
+        state.currentStage = null;
+    }
+    state.lastStageEndTime = now;
+    state._stageTokens = createTokenUsage();
+    // Flush metrics to disk
+    state.endTime = now;
+    state._idleFlushed = true;
+    return flushMetrics(sessionId, state, now, dirs);
+}
+function mergeChildMetrics(parent, child, meta) {
+    // Merge tokens
+    parent.tokens.input += child.tokens.input;
+    parent.tokens.output += child.tokens.output;
+    parent.tokens.reasoning += child.tokens.reasoning;
+    parent.tokens.cacheRead += child.tokens.cacheRead;
+    parent.tokens.cacheWrite += child.tokens.cacheWrite;
+    parent.tokens.total += child.tokens.total;
+    // Merge tools
+    parent.tools.totalCalls += child.tools.totalCalls;
+    parent.tools.invalidCalls += child.tools.invalidCalls;
+    parent.tools.completedCalls += child.tools.completedCalls;
+    parent.tools.errorCalls += child.tools.errorCalls;
+    if (child.tools.slowestCall.duration > parent.tools.slowestCall.duration) {
+        parent.tools.slowestCall = { ...child.tools.slowestCall };
+    }
+    for (const [tool, stats] of child.tools.distribution) {
+        const existing = parent.tools.distribution.get(tool) ?? { calls: 0, errors: 0, totalDuration: 0, maxDuration: 0 };
+        existing.calls += stats.calls;
+        existing.errors += stats.errors;
+        existing.totalDuration += stats.totalDuration;
+        if (stats.maxDuration > existing.maxDuration)
+            existing.maxDuration = stats.maxDuration;
+        parent.tools.distribution.set(tool, existing);
+    }
+    // Merge compactions
+    parent.compactions += child.compactions;
+    // Merge anomaly
+    if (child.anomaly.triggered) {
+        parent.anomaly.triggered = true;
+        parent.anomaly.events.push(...child.anomaly.events);
+    }
+    // Merge rounds (skip empty rounds)
+    for (const round of child.rounds) {
+        if (round.tokens.total > 0 || round.toolCalls > 0) {
+            parent.rounds.push({ ...round, roundIndex: parent.rounds.length });
+        }
+    }
+    // Merge stages (skip stages with no tokens 鈥?these correspond to empty rounds)
+    for (const stage of child.stages) {
+        if (stage.tokens.total > 0) {
+            parent.stages.push({ ...stage });
+        }
+    }
+    // Store child maps in subAgents (not merged into parent)
+    parent.subAgents.set(meta.childId, {
+        sessionId: meta.childId,
+        agentName: meta.agentName,
+        title: meta.title,
+        messageMap: child.messageMap,
+        toolCallMap: child.toolCallMap,
+        textLengthMap: child.textLengthMap,
+        orderCounter: 0,
+        _userMessageIds: new Set(),
+        _pendingUserMessage: [],
+    });
+    // Merge compileStats (additive)
+    parent.compileStats.hvigorwCalls += child.compileStats.hvigorwCalls;
+    parent.compileStats.hvigorwErrors += child.compileStats.hvigorwErrors;
+    parent.compileStats.etsLines += child.compileStats.etsLines;
+    // lastBuildSuccess: take child's value if child had any builds
+    if (child.compileStats.hvigorwCalls > 0 || child.compileStats.hvigorwErrors > 0) {
+        parent.compileStats.lastBuildSuccess = child.compileStats.lastBuildSuccess;
+    }
+    // Merge firstBuildPerRound
+    parent.compileStats.firstBuildPerRound.push(...child.compileStats.firstBuildPerRound);
+    // Merge errorCodes
+    for (const [code, info] of child.compileStats.errorCodes) {
+        const existing = parent.compileStats.errorCodes.get(code);
+        if (existing) {
+            existing.count += info.count;
+        }
+        else {
+            parent.compileStats.errorCodes.set(code, { ...info });
+        }
+    }
+    // Merge warnings
+    for (const [type, info] of child.compileStats.warnings) {
+        const existing = parent.compileStats.warnings.get(type);
+        if (existing) {
+            existing.count += info.count;
+            existing.entries.push(...info.entries);
+        }
+        else {
+            parent.compileStats.warnings.set(type, { count: info.count, entries: [...info.entries] });
+        }
+    }
+    // Merge moduleTimings
+    for (const [module, timing] of child.compileStats.moduleTimings) {
+        const existing = parent.compileStats.moduleTimings.get(module);
+        if (existing) {
+            existing.totalDuration += timing.totalDuration;
+            existing.taskCount += timing.taskCount;
+            if (timing.slowestTask.duration > existing.slowestTask.duration) {
+                existing.slowestTask = { ...timing.slowestTask };
+            }
+        }
+        else {
+            parent.compileStats.moduleTimings.set(module, { ...timing, slowestTask: { ...timing.slowestTask } });
+        }
+    }
+    // Merge fixCycles
+    parent.compileStats.fixCycles.push(...child.compileStats.fixCycles.map(c => ({ ...c })));
+    // Merge skillCallMap
+    for (const [callID, entry] of child.skillCallMap) {
+        if (!parent.skillCallMap.has(callID)) {
+            parent.skillCallMap.set(callID, { ...entry });
+        }
+    }
+    // Merge skillSearchMap
+    for (const [callID, entry] of child.skillSearchMap) {
+        if (!parent.skillSearchMap.has(callID)) {
+            parent.skillSearchMap.set(callID, {
+                ...entry,
+                followUpReads: [...entry.followUpReads],
+            });
+        }
+    }
+    // Merge htmlPreviewMsgId (take first non-null)
+    if (!parent.htmlPreviewMsgId && child.htmlPreviewMsgId) {
+        parent.htmlPreviewMsgId = child.htmlPreviewMsgId;
+    }
+    // Merge planning data
+    parent.planningCalls.push(...child.planningCalls);
+}
+export function mergeMetricsOutput(existing, fresh) {
+    if (!existing)
+        return fresh;
+    // startTime: min of both
+    const startTime = Math.min(existing.startTime, fresh.startTime);
+    // duration: fresh.endTime - min startTime
+    const duration = fresh.endTime - startTime;
+    // Rounds: keep existing, append fresh rounds with new indices only
+    // roundIndex resets on restart, so we can't use it as a dedup key with fresh-wins.
+    // Strategy: existing rounds are always kept; fresh rounds are added only if their
+    // index doesn't already exist in existing. This preserves old session data.
+    const existingRoundIndices = new Set(existing.rounds.map(r => r.roundIndex));
+    const rounds = [
+        ...existing.rounds,
+        ...fresh.rounds.filter(r => !existingRoundIndices.has(r.roundIndex)),
+    ].sort((a, b) => a.roundIndex - b.roundIndex);
+    // Steps: append with dedup by startTime+endTime (fresh wins on collision)
+    const stepSeen = new Set();
+    const steps = [];
+    for (const s of fresh.steps) {
+        const k = `${s.startTime}:${s.endTime}`;
+        stepSeen.add(k);
+        steps.push(s);
+    }
+    for (const s of existing.steps) {
+        if (!stepSeen.has(`${s.startTime}:${s.endTime}`))
+            steps.push(s);
+    }
+    // Subagents: append with dedup by sessionId (fresh wins)
+    const subagentMap = new Map();
+    for (const s of existing.subagents)
+        subagentMap.set(s.sessionId, s);
+    for (const s of fresh.subagents)
+        subagentMap.set(s.sessionId, s);
+    const subagents = [...subagentMap.values()];
+    // Planning: append calls with dedup by callID (existing wins on collision)
+    const callSeen = new Set();
+    const mergedCalls = [];
+    for (const c of existing.planning.calls) {
+        if (!callSeen.has(c.callID)) {
+            callSeen.add(c.callID);
+            mergedCalls.push(c);
+        }
+    }
+    for (const c of fresh.planning.calls) {
+        if (!callSeen.has(c.callID)) {
+            callSeen.add(c.callID);
+            mergedCalls.push(c);
+        }
+    }
+    const planning = {
+        ...fresh.planning,
+        calls: mergedCalls,
+    };
+    // Skills: append with dedup by skillName (fresh wins)
+    const skillMap = new Map();
+    for (const s of existing.skills)
+        skillMap.set(s.skillName, s);
+    for (const s of fresh.skills)
+        skillMap.set(s.skillName, s);
+    const skills = [...skillMap.values()];
+    // SkillSearches: append with dedup by query+skillPath (fresh wins)
+    const searchMap = new Map();
+    for (const s of existing.skillSearches)
+        searchMap.set(`${s.query}:${s.skillPath}`, s);
+    for (const s of fresh.skillSearches)
+        searchMap.set(`${s.query}:${s.skillPath}`, s);
+    const skillSearches = [...searchMap.values()];
+    // codeStats.errorCodes: merge by code, accumulate count, keep existing type/message
+    const errorCodeMap = new Map();
+    for (const e of existing.codeStats.errorCodes)
+        errorCodeMap.set(e.code, { ...e });
+    for (const e of fresh.codeStats.errorCodes) {
+        const prev = errorCodeMap.get(e.code);
+        if (prev) {
+            prev.count += e.count;
+            // keep existing type/message
+        }
+        else {
+            errorCodeMap.set(e.code, { ...e });
+        }
+    }
+    const errorCodes = [...errorCodeMap.values()];
+    // codeStats.warnings: merge by type, accumulate count, append entries
+    const warnByType = { ...existing.codeStats.warnings.byType };
+    const warnEntries = [...existing.codeStats.warnings.entries];
+    let warnTotal = existing.codeStats.warnings.total;
+    for (const [type, count] of Object.entries(fresh.codeStats.warnings.byType)) {
+        warnByType[type] = (warnByType[type] || 0) + count;
+        warnTotal += count;
+    }
+    warnEntries.push(...fresh.codeStats.warnings.entries);
+    const warnings = { total: warnTotal, byType: warnByType, entries: warnEntries };
+    // codeStats.moduleTimings: merge by module, accumulate totalDuration/taskCount, max slowestTask
+    const moduleMap = new Map();
+    for (const m of existing.codeStats.moduleTimings)
+        moduleMap.set(m.module, { ...m, slowestTask: { ...m.slowestTask } });
+    for (const m of fresh.codeStats.moduleTimings) {
+        const prev = moduleMap.get(m.module);
+        if (prev) {
+            prev.totalDurationMs += m.totalDurationMs;
+            prev.taskCount += m.taskCount;
+            if (m.slowestTask.duration > prev.slowestTask.duration) {
+                prev.slowestTask = { ...m.slowestTask };
+            }
+        }
+        else {
+            moduleMap.set(m.module, { ...m, slowestTask: { ...m.slowestTask } });
+        }
+    }
+    const moduleTimings = [...moduleMap.values()];
+    // codeStats.fixCycles: append (skip dedup)
+    const fixCycles = {
+        ...fresh.codeStats.fixCycles,
+        cycles: [...existing.codeStats.fixCycles.cycles, ...fresh.codeStats.fixCycles.cycles],
+    };
+    // codeStats.firstBuildPerRound: fresh accumulates all rounds, use fresh
+    const firstBuildPerRound = fresh.codeStats.firstBuildPerRound;
+    // systemPrompts: union of keys, fresh values win
+    const systemPrompts = { ...existing.systemPrompts };
+    for (const [key, val] of Object.entries(fresh.systemPrompts)) {
+        systemPrompts[key] = val;
+    }
+    return {
+        sessionId: fresh.sessionId,
+        startTime,
+        endTime: fresh.endTime,
+        duration,
+        systemPrompts,
+        rounds,
+        tokens: fresh.tokens,
+        tools: fresh.tools,
+        compactions: fresh.compactions,
+        anomaly: fresh.anomaly,
+        stages: fresh.stages,
+        header: fresh.header,
+        codeStats: {
+            etsLines: fresh.codeStats.etsLines,
+            buildSuccess: fresh.codeStats.buildSuccess,
+            fixCompileCount: fresh.codeStats.fixCompileCount,
+            totalCompileErrors: fresh.codeStats.totalCompileErrors,
+            firstBuildPerRound,
+            firstBuildPassRate: fresh.codeStats.firstBuildPassRate,
+            errorCodes,
+            warnings,
+            fixCycles,
+            moduleTimings,
+        },
+        responseLength: fresh.responseLength,
+        skills,
+        skillSearches,
+        steps,
+        subagents,
+        planning,
+    };
+}
+export { flushMetrics, handleSessionIdle, mergeChildMetrics };

package/dist/metrics-steps.d.ts

@@ -0,0 +1,19 @@
+import type { MessageEntry, ToolCallEntry, StepData } from "./metrics-types.js";
+declare function buildSteps(maps: {
+    messageMap: Map<string, MessageEntry>;
+    toolCallMap: Map<string, ToolCallEntry>;
+    textLengthMap: Map<string, number>;
+}, contentMaps?: {
+    textMap: Map<string, string>;
+    reasoningMap: Map<string, string>;
+    toolOutputMap: Map<string, string>;
+}): StepData[];
+declare function extractStepContent(sessionId: string, opts?: {
+    eventsDir?: string;
+    filterMsgIds?: Set<string>;
+}): {
+    textMap: Map<string, string>;
+    reasoningMap: Map<string, string>;
+    toolOutputMap: Map<string, string>;
+};
+export { buildSteps, extractStepContent };