opencode-metrics-plugin 0.1.5 → 0.2.1

package/dist/{metrics-output.js → metrics/snapshot/flush.js}

@@ -1,10 +1,10 @@
 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";
+import { log } from "../../shared/log.js";
+import { createTokenUsage } from "../types.js";
+import { getMetricsDir } from "../dirs.js";
+import { buildSteps, extractStepContent } from "./steps.js";
+import { mergeMetricsOutput } from "./merge.js";
 function filterByKeys(source, keys) {
     const result = new Map();
     for (const key of keys) {
@@ -326,9 +326,6 @@ function flushMetrics(sessionId, state, now, dirs) {
         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) });
@@ -389,285 +386,4 @@ function handleSessionIdle(state, sessionId, dirs) {
     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 };
+export { flushMetrics, handleSessionIdle };

package/dist/metrics/snapshot/merge.d.ts

@@ -0,0 +1,9 @@
+import type { MetricsOutput } from "../types.js";
+import type { SessionMetricsState } from "../engine/state.js";
+declare function mergeChildMetrics(parent: SessionMetricsState, child: SessionMetricsState, meta: {
+    childId: string;
+    agentName: string;
+    title: string;
+}): void;
+export declare function mergeMetricsOutput(existing: MetricsOutput | null, fresh: MetricsOutput): MetricsOutput;
+export { mergeChildMetrics };

package/dist/metrics/snapshot/merge.js

@@ -0,0 +1,282 @@
+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 { mergeChildMetrics };

package/dist/{metrics-steps.d.ts → metrics/snapshot/steps.d.ts}

@@ -1,4 +1,4 @@
-import type { MessageEntry, ToolCallEntry, StepData } from "./metrics-types.js";
+import type { MessageEntry, ToolCallEntry, StepData } from "../types.js";
 declare function buildSteps(maps: {
     messageMap: Map<string, MessageEntry>;
     toolCallMap: Map<string, ToolCallEntry>;

package/dist/{metrics-steps.js → metrics/snapshot/steps.js}

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
-import { getEventsDir } from "./dirs.js";
+import { getEventsDir } from "../dirs.js";
 function buildSteps(maps, contentMaps) {
     const sorted = [...maps.messageMap.values()]
         .filter(m => m.finish && m.tokens.total > 0)