opencode-metrics-plugin 0.3.4 → 0.3.5

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.3.5（2026-09-15）
+
+- 修复「重启 + resume 续跑」系列数据损坏：steps 重复乱序、planning 清零、tokens/工具统计丢段、agent/model 归因丢失；累加字段改差量并入，连发消息即切轮、退出兜底补轮。
+- 上传修复：退出 opencode（含 Ctrl+C）时当场完成上传；没传完的下次启动自动补传；不再丢失"上传完成"日志。
+
 ## 0.3.4（2026-09-14）
 
 - 修复 0.3.3 发布事故：package.json 误带 UTF-8 BOM，npm 可安装但 opencode 解析插件清单失败并**静默跳过加载**——所有 0.3.3 用户完全不采集、不上传、日志无任何痕迹。升级本版后必须删除插件缓存并重启 opencode（Windows `%USERPROFILE%\.cache\opencode\packages\opencode-metrics-plugin*`，macOS `~/Library/Caches/opencode/packages/` 同名目录）；事故期间未采集的会话无法补录，装好后孤儿补传会自动补传 7 天内未上终态的历史快照。

package/dist/metrics/engine/engine.js

@@ -1,7 +1,7 @@
 import { TRACKED_EVENT_TYPES } from "../types.js";
 import { createSessionMetrics } from "./state.js";
 import { handlePartUpdated, handleSessionUpdated, handleMessageUpdated, handleSubAgentParts } from "./handlers.js";
-import { handleSessionIdle, flushMetrics } from "../snapshot/flush.js";
+import { handleSessionIdle, flushMetrics, buildRoundSnapshot } from "../snapshot/flush.js";
 import { clearStepContentCache } from "../snapshot/steps.js";
 import { mergeChildMetrics } from "../snapshot/merge.js";
 import { resolveDirs } from "../dirs.js";
@@ -90,6 +90,11 @@ export function createMetricsEngine(opts = {}) {
      * @param now       结束时刻（ms）
      */
     function finalizeAndFlush(sessionId, state, now) {
+        // 兜底补轮：退出/删除前最后一次交互往往等不到 session.idle（约 1 分钟静止判定），
+        // 此处把未闭合的非空轮收掉（空轮返回 null，已 idle 过的轮累计已重置、同样为 null，天然防重）
+        const pendingRound = buildRoundSnapshot(state, now);
+        if (pendingRound)
+            state.rounds.push(pendingRound);
         if (state.currentStage) {
             state.currentStage.endTime = now;
             state.currentStage.tokens = { ...state._stageTokens };

package/dist/metrics/engine/handlers.js

@@ -1,5 +1,6 @@
 import { createTokenUsage } from "../types.js";
 import { parseHvigorwOutput } from "../analysis/hvigor.js";
+import { buildRoundSnapshot, resetRoundState } from "../snapshot/flush.js";
 // ─── Input Simplification ────────────────────────────────────────────────────
 function simplifyInput(raw) {
     if (!raw)
@@ -472,8 +473,17 @@ function handleMessageUpdated(state, props) {
     // Track user message IDs so we can capture their text from message.part.updated
     if (info.role === "user") {
         const msgId = info.id;
-        if (msgId)
+        if (msgId && !state._userMessageIds.has(msgId)) {
+            // 新用户消息 = 天然轮边界：先收掉当前非空轮（不再等 idle 静止判定），
+            // 快速连发多条不再被合并进同一轮；resume 重放期间轮累计为空，
+            // buildRoundSnapshot 返回 null 无副作用，重放结束后首条真实消息正常开新轮
+            const round = buildRoundSnapshot(state, Date.now());
+            if (round) {
+                state.rounds.push(round);
+                resetRoundState(state, Date.now());
+            }
             state._userMessageIds.add(msgId);
+        }
         state._roundIdleProcessed = false;
         return;
     }

package/dist/metrics/engine/state.d.ts

@@ -22,6 +22,51 @@ export interface FlushBaseline {
         taskCount: number;
     }>;
     fixCycleCount: number;
+    /** 顶层 tokens 快照（差量 = 下次 fresh − 本值；重启后 baseline 为空即全量并入） */
+    tokens: {
+        input: number;
+        output: number;
+        reasoning: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+    /** 工具计数快照（distribution 存每 tool 总量，用于算 calls/errors/totalDuration 差量） */
+    tools: {
+        totalCalls: number;
+        invalidCalls: number;
+        distribution: Record<string, {
+            calls: number;
+            errors: number;
+            totalDuration: number;
+            maxDuration: number;
+        }>;
+    };
+    /** 压缩次数快照 */
+    compactions: number;
+    /** 回复总字符数快照 */
+    responseLength: number;
+    /** anomaly.events 数组长度快照（events 只追加） */
+    anomalyEventsTotal: number;
+    /** stages 数组长度快照（stages 只追加） */
+    stagesTotal: number;
+    /** header 归因切换计数快照（差量 = fresh − 本值） */
+    agentSwitches: number;
+    modelSwitches: number;
+    /** 各 agent 累计使用时长快照（毫秒） */
+    agentUsage: Record<string, number>;
+    /** 各模型 token 分布快照（state 内存态全量） */
+    modelTokenDistribution: Record<string, {
+        input: number;
+        output: number;
+        reasoning: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    }>;
+    /** 编译修复次数与累计错误数快照（codeStats 累计型） */
+    fixCompileCount: number;
+    totalCompileErrors: number;
 }
 export interface SessionMetricsState {
     sessionId: string;

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

@@ -1,6 +1,6 @@
 import type { MetricsDirs } from "../dirs.js";
 import type { SessionMetricsState } from "../engine/state.js";
-import type { MetricsOutput } from "../types.js";
+import type { RoundSnapshot, MetricsOutput } from "../types.js";
 /**
  * 把会话当前状态落盘为快照文件（读旧文件 → 合并 → 原子覆盖写）。
  * 可重复调用，不会造成数据重复累计。
@@ -19,5 +19,14 @@ declare function flushMetrics(sessionId: string, state: SessionMetricsState, now
  * @param sessionId 会话 id
  * @param dirs      输出目录；缺省用进程级默认目录
  */
+/**
+ * 从当前轮累计态构建轮快照；空轮（无 token 且无工具调用）返回 null（天然防重）。
+ *
+ * @param state 会话状态（读取轮累计字段，不修改）
+ * @param now   结算时刻（ms）
+ */
+export declare function buildRoundSnapshot(state: SessionMetricsState, now: number): RoundSnapshot | null;
+/** 重置轮累计态，开始新轮（不改动 stage 相关状态）。 */
+export declare function resetRoundState(state: SessionMetricsState, now: number): void;
 declare function handleSessionIdle(state: SessionMetricsState, sessionId: string, dirs?: Partial<MetricsDirs>): MetricsOutput | undefined;
 export { flushMetrics, handleSessionIdle };

package/dist/metrics/snapshot/flush.js

@@ -219,21 +219,25 @@ function flushMetrics(sessionId, state, now, dirs) {
     }
     const output = {
         sessionId,
+        procStartTime: state.startTime,
         startTime: state.startTime,
         endTime,
         duration,
         systemPrompts,
         rounds: state.rounds,
         tokens: (() => {
-            const totalTokens = Math.max(state.tokens.total, parentStepTokens.total) + subAgentTokens.total;
+            // step-finish 增量口径优先（真实消耗）；消息口径（每轮含全上下文）仅增量缺失时兜底。
+            // 旧实现取两者 max 会把消息口径的虚高值（resume 重放历史消息时尤为严重）混进顶层统计。
+            const preferState = state.tokens.total > 0;
+            const base = preferState ? state.tokens : parentStepTokens;
+            const totalTokens = base.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,
+                input: base.input + subAgentTokens.input,
+                output: base.output + subAgentTokens.output,
+                reasoning: base.reasoning + subAgentTokens.reasoning,
+                cacheRead: base.cacheRead + subAgentTokens.cacheRead,
+                cacheWrite: base.cacheWrite + subAgentTokens.cacheWrite,
                 total: totalTokens,
                 cacheHitRate,
                 avgTokensPerStep: totalSteps > 0 ? Math.round(totalTokens / totalSteps) : 0,
@@ -347,6 +351,35 @@ function flushMetrics(sessionId, state, now, dirs) {
             warningEntriesTotal: output.codeStats.warnings.entries.length,
             moduleTimings: Object.fromEntries(output.codeStats.moduleTimings.map(m => [m.module, { totalDuration: m.totalDurationMs, taskCount: m.taskCount }])),
             fixCycleCount: output.codeStats.fixCycles.cycles.length,
+            tokens: {
+                input: output.tokens.input,
+                output: output.tokens.output,
+                reasoning: output.tokens.reasoning,
+                cacheRead: output.tokens.cacheRead,
+                cacheWrite: output.tokens.cacheWrite,
+                total: output.tokens.total,
+            },
+            tools: {
+                totalCalls: output.tools.totalCalls,
+                invalidCalls: output.tools.invalidCalls,
+                distribution: Object.fromEntries(Object.entries(output.tools.distribution).map(([tool, d]) => [
+                    tool,
+                    { calls: d.calls, errors: d.errors, totalDuration: d.avgDuration * d.calls, maxDuration: d.maxDuration },
+                ])),
+            },
+            compactions: output.compactions,
+            responseLength: output.responseLength,
+            anomalyEventsTotal: output.anomaly.events.length,
+            stagesTotal: output.stages.length,
+            agentSwitches: output.header.agentSwitches,
+            modelSwitches: output.header.modelSwitches,
+            agentUsage: { ...output.header.agentUsage },
+            modelTokenDistribution: Object.fromEntries(Object.entries(output.header.modelTokenDistribution ?? {}).map(([model, dist]) => [
+                model,
+                { input: dist.input, output: dist.output, reasoning: dist.reasoning, cacheRead: dist.cacheRead, cacheWrite: dist.cacheWrite, total: dist.total },
+            ])),
+            fixCompileCount: output.codeStats.fixCompileCount,
+            totalCompileErrors: output.codeStats.totalCompileErrors,
         };
     }
     catch (err) {
@@ -361,33 +394,32 @@ function flushMetrics(sessionId, state, now, dirs) {
  * @param sessionId 会话 id
  * @param dirs      输出目录；缺省用进程级默认目录
  */
-function handleSessionIdle(state, sessionId, dirs) {
-    const now = Date.now();
-    // Build round snapshot
-    const roundDuration = now - state._roundStartTime;
+/**
+ * 从当前轮累计态构建轮快照；空轮（无 token 且无工具调用）返回 null（天然防重）。
+ *
+ * @param state 会话状态（读取轮累计字段，不修改）
+ * @param now   结算时刻（ms）
+ */
+export function buildRoundSnapshot(state, now) {
+    const isEmptyRound = state._roundTokens.total === 0 && state._roundToolCalls === 0;
+    if (isEmptyRound)
+        return null;
     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
+    return {
+        startTime: state._roundStartTime,
+        roundIndex: state.rounds.length,
+        duration: now - state._roundStartTime,
+        firstTokenLatency,
+        tokens: { ...state._roundTokens },
+        toolCalls: state._roundToolCalls,
+        errors: state._roundErrors,
+        userMessage: state._pendingUserMessage.length > 0 ? [...state._pendingUserMessage] : undefined,
+    };
+}
+/** 重置轮累计态，开始新轮（不改动 stage 相关状态）。 */
+export function resetRoundState(state, now) {
     state._roundStartTime = now;
     state._firstEventTime = 0;
     state._firstTextTime = 0;
@@ -398,6 +430,19 @@ function handleSessionIdle(state, sessionId, dirs) {
     state._roundErrors = 0;
     state._pendingUserMessage = [];
     state._roundFirstBuildTracked = false;
+}
+function handleSessionIdle(state, sessionId, dirs) {
+    const now = Date.now();
+    // Skip duplicate session.idle — round was already created
+    if (state._roundIdleProcessed) {
+        return;
+    }
+    const round = buildRoundSnapshot(state, now);
+    if (round)
+        state.rounds.push(round);
+    state._roundIdleProcessed = true;
+    // Reset per-round state
+    resetRoundState(state, now);
     // Finalize current stage
     if (state.currentStage) {
         state.currentStage.endTime = now;

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

@@ -6,11 +6,11 @@ declare function mergeChildMetrics(parent: SessionMetricsState, child: SessionMe
     title: string;
 }): void;
 /**
- * 合并磁盘旧快照与内存新快照：覆盖类字段取新值，累加类字段只补差量。
+ * 合并磁盘旧快照与内存新快照：覆盖类字段取新值，累加类字段按差量并入。
  *
  * @param existing 磁盘上的旧快照；null 时直接返回 fresh
  * @param fresh    由当前内存态构建的新快照
- * @param baseline 上次 flush 时累加字段的累计值，用于计算本次差量；null 时累加字段全量并入
+ * @param baseline 上次 flush 时累加字段的累计快照，用于计算本次差量；null 时累加字段全量并入
  * @returns        合并后的快照，可安全反复写盘
  */
 export declare function mergeMetricsOutput(existing: MetricsOutput | null, fresh: MetricsOutput, baseline?: FlushBaseline | null): MetricsOutput;

package/dist/metrics/snapshot/merge.js

@@ -124,11 +124,47 @@ function mergeChildMetrics(parent, child, meta) {
     parent.planningCalls.push(...child.planningCalls);
 }
 /**
- * 合并磁盘旧快照与内存新快照：覆盖类字段取新值，累加类字段只补差量。
+ * 基于规划调用列表重算 planning 汇总字段（口径与 flush 构建时一致：
+ * 任务统计取最后一轮 todos，时长为全部轮次累加）。用于快照合并——
+ * 合并方无法信任任何一方的汇总（fresh 可能是重启后的空态），只能从合并后的 calls 重新推导。
+ */
+function summarizePlanningCalls(calls) {
+    if (calls.length === 0) {
+        return {
+            planningRounds: 0, totalPlanningDuration: 0, avgPlanningDuration: 0,
+            totalTasks: 0, completedTasks: 0, inProgressTasks: 0, pendingTasks: 0,
+            completionRate: 0, priorityDistribution: {}, calls: [],
+        };
+    }
+    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: calls.length,
+        totalPlanningDuration: totalDuration,
+        avgPlanningDuration: Math.round(totalDuration / calls.length),
+        totalTasks,
+        completedTasks,
+        inProgressTasks,
+        pendingTasks,
+        completionRate: totalTasks > 0 ? completedTasks / totalTasks : 0,
+        priorityDistribution,
+        calls,
+    };
+}
+/**
+ * 合并磁盘旧快照与内存新快照：覆盖类字段取新值，累加类字段按差量并入。
  *
  * @param existing 磁盘上的旧快照；null 时直接返回 fresh
  * @param fresh    由当前内存态构建的新快照
- * @param baseline 上次 flush 时累加字段的累计值，用于计算本次差量；null 时累加字段全量并入
+ * @param baseline 上次 flush 时累加字段的累计快照，用于计算本次差量；null 时累加字段全量并入
  * @returns        合并后的快照，可安全反复写盘
  */
 export function mergeMetricsOutput(existing, fresh, baseline) {
@@ -138,27 +174,58 @@ export function mergeMetricsOutput(existing, fresh, baseline) {
     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)
+    // Rounds：重启后内存态的 roundIndex 从 0 重编，与磁盘 existing 语义错位。
+    // 用双方首轮的 startTime 判断进程关系：
+    //  - 首轮起点一致 → 同进程（fresh 是全量态），fresh 即权威；
+    //  - 不一致 / existing 无 startTime（旧版快照，插件升级必重启）→ 重启，existing 全保留
+    //    + fresh 尾部追加重编（不丢重启后的真实新轮）；
+    //  - fresh 无 startTime（旧版代码产物）→ 回退旧策略 existing wins by index。
+    const rounds = (() => {
+        const f0 = fresh.rounds[0]?.startTime;
+        const e0 = existing.rounds[0]?.startTime;
+        if (f0 !== undefined) {
+            if (e0 !== undefined && f0 === e0) {
+                // 同进程：fresh 是全量态（首轮起点一致），直接采用并按其自身顺序编号
+                return fresh.rounds.map((r, i) => ({ ...r, roundIndex: i }));
+            }
+            // 重启（含 existing 为旧版快照无 startTime：插件升级必然重启进程，fresh 只含新段）
+            // existing 全保留 + fresh 轮追加尾部并重编 index，不再"撞 index 丢 fresh"；
+            // 追加前按轮特征去重——同轮双份（idle 建轮后紧接 checkpoint 再 flush 一次）只保留一份
+            const roundKey = (r) => `${r.startTime ?? 0}|${r.duration}|${(r.userMessage ?? []).join("\u0000")}|${r.toolCalls}|${r.tokens.total}`;
+            const seenRounds = new Set(existing.rounds.map(roundKey));
+            return [
+                ...existing.rounds,
+                ...fresh.rounds
+                    .filter(r => !seenRounds.has(roundKey(r)))
+                    .map((r, i) => ({ ...r, roundIndex: existing.rounds.length + i })),
+            ];
+        }
+        // fresh 由旧版代码产生（无 startTime）：回退旧策略 existing wins by index
+        const existingRoundIndices = new Set(existing.rounds.map(r => r.roundIndex));
+        return [
+            ...existing.rounds,
+            ...fresh.rounds.filter(r => !existingRoundIndices.has(r.roundIndex)),
+        ].sort((a, b) => a.roundIndex - b.roundIndex);
+    })();
+    // Steps：进程重启后 orderCounter 从 0 重编，fresh 的 index 与磁盘 existing 撞车，
+    // 且时间上更晚的新步骤被排到列表头部；resume 重灌轮的时间戳全新，index 与时间戳都无法跨进程关联。
+    // 统一策略：按 startTime:endTime 去重（防同进程重放，fresh wins）后，
+    // 全部条目按 startTime 升序排序并重编 index —— 时间是跨进程唯一可信的顺序，
+    // index 撞车与"新步骤跳到头部"同时消除，不丢弃任何真实轮次。
     const stepSeen = new Set();
-    const steps = [];
+    const stepMerged = [];
     for (const s of fresh.steps) {
         const k = `${s.startTime}:${s.endTime}`;
         stepSeen.add(k);
-        steps.push(s);
+        stepMerged.push(s);
     }
     for (const s of existing.steps) {
         if (!stepSeen.has(`${s.startTime}:${s.endTime}`))
-            steps.push(s);
+            stepMerged.push(s);
     }
+    const steps = stepMerged
+        .sort((a, b) => a.startTime - b.startTime)
+        .map((s, i) => ({ ...s, index: i }));
     // Subagents: append with dedup by sessionId (fresh wins)
     const subagentMap = new Map();
     for (const s of existing.subagents)
@@ -181,10 +248,11 @@ export function mergeMetricsOutput(existing, fresh, baseline) {
             mergedCalls.push(c);
         }
     }
-    const planning = {
-        ...fresh.planning,
-        calls: mergedCalls,
-    };
+    // 汇总字段基于合并后的 calls 重算，不能取 fresh 的汇总：
+    // 进程重启后内存态 planningCalls 为空（fresh 汇总全零），但磁盘上已有历史规划轮次，
+    // 直接展开 fresh 会把汇总清零，造成"calls 有数据、汇总全 0"的不一致。
+    mergedCalls.sort((a, b) => a.startTime - b.startTime);
+    const planning = summarizePlanningCalls(mergedCalls);
     // Skills: append with dedup by skillName (fresh wins)
     const skillMap = new Map();
     for (const s of existing.skills)
@@ -272,39 +340,202 @@ export function mergeMetricsOutput(existing, fresh, baseline) {
                 : []),
         ],
     };
-    // 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;
     }
+    // 顶层统计字段的差量并入：fresh 是当前内存态累计，existing 是上次落盘的合并结果。
+    // 差量 = fresh − baseline（baseline 为上次 flush 时的 fresh 快照）：
+    // - 同进程反复 flush：差量为本次新增量，existing + 差量 = 全量，不双计；
+    // - 重启后 baseline 为空：差量 = fresh 全量，天然跨进程相加；
+    // - resume 渐进重放期间：每次只并入重放新增量，不会用中间态覆盖已并入的旧段
+    //   （这是进程标记方案的缺陷：重放未完成时 fresh 非全量，fresh-wins 会冲掉旧段）。
+    // 派生值（命中率/均步 token/平均耗时/成功率）用合并后基数重算。
+    const tokensInc = {
+        input: Math.max(0, fresh.tokens.input - (baseline?.tokens.input ?? 0)),
+        output: Math.max(0, fresh.tokens.output - (baseline?.tokens.output ?? 0)),
+        reasoning: Math.max(0, fresh.tokens.reasoning - (baseline?.tokens.reasoning ?? 0)),
+        cacheRead: Math.max(0, fresh.tokens.cacheRead - (baseline?.tokens.cacheRead ?? 0)),
+        cacheWrite: Math.max(0, fresh.tokens.cacheWrite - (baseline?.tokens.cacheWrite ?? 0)),
+    };
+    const tokensTotalRaw = existing.tokens.input + tokensInc.input
+        + existing.tokens.output + tokensInc.output
+        + existing.tokens.reasoning + tokensInc.reasoning
+        + existing.tokens.cacheRead + tokensInc.cacheRead
+        + existing.tokens.cacheWrite + tokensInc.cacheWrite;
+    const tokens = {
+        input: existing.tokens.input + tokensInc.input,
+        output: existing.tokens.output + tokensInc.output,
+        reasoning: existing.tokens.reasoning + tokensInc.reasoning,
+        cacheRead: existing.tokens.cacheRead + tokensInc.cacheRead,
+        cacheWrite: existing.tokens.cacheWrite + tokensInc.cacheWrite,
+        total: tokensTotalRaw,
+        cacheHitRate: tokensTotalRaw > 0
+            ? (existing.tokens.cacheRead + tokensInc.cacheRead) / Math.max(1, existing.tokens.input + tokensInc.input + existing.tokens.cacheRead + tokensInc.cacheRead)
+            : 0,
+        avgTokensPerStep: steps.length > 0 ? Math.round(tokensTotalRaw / steps.length) : 0,
+    };
+    const toolsIncTotal = Math.max(0, fresh.tools.totalCalls - (baseline?.tools.totalCalls ?? 0));
+    const toolsIncInvalid = Math.max(0, fresh.tools.invalidCalls - (baseline?.tools.invalidCalls ?? 0));
+    const distribution = {};
+    for (const [tool, d] of Object.entries(existing.tools.distribution))
+        distribution[tool] = { ...d };
+    let incErrors = 0;
+    for (const [tool, d] of Object.entries(fresh.tools.distribution)) {
+        const base = baseline?.tools.distribution[tool];
+        const incCalls = Math.max(0, d.calls - (base?.calls ?? 0));
+        const incErrors_ = Math.max(0, d.errors - (base?.errors ?? 0));
+        const incDuration = Math.max(0, d.avgDuration * d.calls - (base?.totalDuration ?? 0));
+        if (incCalls === 0 && incErrors_ === 0 && incDuration === 0)
+            continue;
+        incErrors += incErrors_;
+        const prev = distribution[tool];
+        if (prev) {
+            const calls = prev.calls + incCalls;
+            const totalDuration = prev.avgDuration * prev.calls + incDuration;
+            distribution[tool] = {
+                calls,
+                errors: prev.errors + incErrors_,
+                avgDuration: calls > 0 ? totalDuration / calls : 0,
+                maxDuration: Math.max(prev.maxDuration, d.maxDuration),
+            };
+        }
+        else {
+            distribution[tool] = {
+                calls: incCalls,
+                errors: incErrors_,
+                avgDuration: incCalls > 0 ? incDuration / incCalls : 0,
+                maxDuration: d.maxDuration,
+            };
+        }
+    }
+    const mergedTotalCalls = existing.tools.totalCalls + toolsIncTotal;
+    const mergedInvalidCalls = existing.tools.invalidCalls + toolsIncInvalid;
+    const tools = {
+        totalCalls: mergedTotalCalls,
+        invalidCalls: mergedInvalidCalls,
+        successRate: (() => {
+            if (mergedTotalCalls <= 0)
+                return 0;
+            const incValid = Math.max(0, toolsIncTotal - toolsIncInvalid - incErrors);
+            const existingValid = existing.tools.successRate * existing.tools.totalCalls;
+            return (existingValid + incValid) / mergedTotalCalls;
+        })(),
+        distribution,
+        slowestCall: fresh.tools.slowestCall.duration >= existing.tools.slowestCall.duration
+            ? fresh.tools.slowestCall
+            : existing.tools.slowestCall,
+    };
+    const compactions = existing.compactions + Math.max(0, fresh.compactions - (baseline?.compactions ?? 0));
+    // anomaly.events 是事件类型名的并集（数组天然去重），直接合并
+    const anomaly = {
+        triggered: existing.anomaly.triggered || fresh.anomaly.triggered,
+        events: [...new Set([...existing.anomaly.events, ...fresh.anomaly.events])],
+    };
+    // stages 只追加：并入基线长度之后的新增尾部
+    const stagesBaseline = baseline?.stagesTotal ?? 0;
+    const stages = fresh.stages.length > stagesBaseline
+        ? [...existing.stages, ...fresh.stages.slice(stagesBaseline)]
+        : [...existing.stages];
+    const responseLength = existing.responseLength + Math.max(0, fresh.responseLength - (baseline?.responseLength ?? 0));
+    // Header 字段级合并：resume 进程的 fresh 是"非全量态"——未收到 session.updated 前
+    // agent/model/workingDirectory 为空（"不知道"，不是"变成空"），startTime 是进程时间
+    // 而非会话时间。规则：非空才覆盖（真实状态更新）、startTime 取更早（会话真实起点）、
+    // 计数与分布按差量并入（跨进程累计，同进程反复 flush 不双计）。
+    const header = (() => {
+        const agentUsage = { ...existing.header.agentUsage };
+        for (const [agent, ms] of Object.entries(fresh.header.agentUsage ?? {})) {
+            const inc = Math.max(0, ms - (baseline?.agentUsage[agent] ?? 0));
+            agentUsage[agent] = (agentUsage[agent] ?? 0) + inc;
+        }
+        const modelTokenDistribution = {};
+        for (const [model, dist] of Object.entries(existing.header.modelTokenDistribution ?? {})) {
+            modelTokenDistribution[model] = { ...dist };
+        }
+        for (const [model, dist] of Object.entries(fresh.header.modelTokenDistribution ?? {})) {
+            const base = baseline?.modelTokenDistribution[model];
+            const inc = {
+                input: Math.max(0, dist.input - (base?.input ?? 0)),
+                output: Math.max(0, dist.output - (base?.output ?? 0)),
+                reasoning: Math.max(0, dist.reasoning - (base?.reasoning ?? 0)),
+                cacheRead: Math.max(0, dist.cacheRead - (base?.cacheRead ?? 0)),
+                cacheWrite: Math.max(0, dist.cacheWrite - (base?.cacheWrite ?? 0)),
+                total: 0,
+            };
+            inc.total = inc.input + inc.output + inc.reasoning + inc.cacheRead + inc.cacheWrite;
+            const prev = modelTokenDistribution[model];
+            if (prev) {
+                prev.input += inc.input;
+                prev.output += inc.output;
+                prev.reasoning += inc.reasoning;
+                prev.cacheRead += inc.cacheRead;
+                prev.cacheWrite += inc.cacheWrite;
+                prev.total += inc.total;
+            }
+            else {
+                modelTokenDistribution[model] = inc;
+            }
+        }
+        return {
+            ...fresh.header,
+            agent: fresh.header.agent || existing.header.agent,
+            model: fresh.header.model || existing.header.model,
+            workingDirectory: fresh.header.workingDirectory || existing.header.workingDirectory,
+            // ISO 字符串可字典序比较：取更早者保留会话真实开始时间（进程重启不重置会话起点）
+            startTime: fresh.header.startTime < existing.header.startTime
+                ? fresh.header.startTime
+                : existing.header.startTime,
+            title: fresh.header.title ?? existing.header.title,
+            agentSwitches: existing.header.agentSwitches + Math.max(0, fresh.header.agentSwitches - (baseline?.agentSwitches ?? 0)),
+            modelSwitches: existing.header.modelSwitches + Math.max(0, fresh.header.modelSwitches - (baseline?.modelSwitches ?? 0)),
+            agentUsage,
+            modelTokenDistribution,
+        };
+    })();
+    // codeStats 顶层分两类处理：累计型（fixCompileCount/totalCompileErrors）按差量并入；
+    // 快照型（etsLines/buildSuccess/firstBuildPassRate/firstBuildPerRound）在 fresh 无构建迹象
+    // （全零/空）时保留 existing——重启进程没跑过 hvigorw，fresh 全零是"不知道"而非"清零"。
+    const fixCompileCount = existing.codeStats.fixCompileCount
+        + Math.max(0, fresh.codeStats.fixCompileCount - (baseline?.fixCompileCount ?? 0));
+    const totalCompileErrors = existing.codeStats.totalCompileErrors
+        + Math.max(0, fresh.codeStats.totalCompileErrors - (baseline?.totalCompileErrors ?? 0));
+    const freshHasBuild = fresh.codeStats.etsLines > 0
+        || fresh.codeStats.fixCompileCount > (baseline?.fixCompileCount ?? 0)
+        || totalCompileErrors > existing.codeStats.totalCompileErrors
+        || fresh.codeStats.firstBuildPerRound.length > 0;
+    const codeStats = {
+        etsLines: fresh.codeStats.etsLines > 0 ? fresh.codeStats.etsLines : existing.codeStats.etsLines,
+        buildSuccess: freshHasBuild ? fresh.codeStats.buildSuccess : existing.codeStats.buildSuccess,
+        fixCompileCount,
+        totalCompileErrors,
+        firstBuildPerRound: fresh.codeStats.firstBuildPerRound.length > 0
+            ? fresh.codeStats.firstBuildPerRound
+            : existing.codeStats.firstBuildPerRound,
+        firstBuildPassRate: fresh.codeStats.firstBuildPerRound.length > 0
+            ? fresh.codeStats.firstBuildPassRate
+            : existing.codeStats.firstBuildPassRate,
+        errorCodes,
+        warnings,
+        fixCycles,
+        moduleTimings,
+    };
     return {
         sessionId: fresh.sessionId,
+        procStartTime: fresh.procStartTime,
         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,
+        tokens,
+        tools,
+        compactions,
+        anomaly,
+        stages,
+        header,
+        codeStats,
+        responseLength,
         skills,
         skillSearches,
         steps,

package/dist/metrics/types.d.ts

@@ -159,6 +159,8 @@ export interface StepData {
     reasoning: string;
 }
 export interface RoundSnapshot {
+    /** 轮次开始时间戳（0.2.2 起；旧快照缺省，合并时回退按 index 对齐） */
+    startTime?: number;
     roundIndex: number;
     duration: number;
     firstTokenLatency: number;
@@ -194,6 +196,8 @@ export interface MetricsOutput {
     sessionId: string;
     /** 快照来源标记（0.2.0 起仅 live） */
     source?: "live";
+    /** 产生本快照的进程标记（state 创建时刻，0.3.5 起）：同值=同进程；缺省=旧版快照 */
+    procStartTime?: number;
     startTime: number;
     endTime: number;
     duration: number;

package/dist/metrics/upload/agcUploader.d.ts

@@ -46,6 +46,12 @@ export interface AgcUploader {
      * @param uploadPackage 归档产物（含双文件与路径元数据）
      */
     uploadPackage(uploadPackage: UploadPackage): Promise<UploadOutcome>;
+    /**
+     * 预热 token：提前走一遍获取/读缓存流程并落盘缓存（结果忽略）。
+     * 进程启动时后台调用，dispose 触发的上传即可直接读缓存，
+     * 不必在退出的 10-60s 窗口内等首次 token 网络往返（最长 30s）。
+     */
+    warmup(): Promise<void>;
 }
 /**
  * 创建 AGC 上传器（token 自动获取与缓存 + 流式 PUT）。

package/dist/metrics/upload/agcUploader.js

@@ -4,6 +4,7 @@ import * as https from "node:https";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
+import { log } from "../../shared/log.js";
 import { sanitizeNameSegment } from "./types.js";
 /** region → 默认域名映射（未显式配置 api_domain/storage_domain 时使用） */
 const REGION_DOMAINS = {
@@ -82,6 +83,15 @@ export function createAgcUploader(credentials) {
                 return archiveOutcome;
             return uploadFile(credentials, tokenOutcome.token, uploadPackage.snapshot.filePath, `${remoteBase}.json`);
         },
+        async warmup() {
+            const outcome = await getAccessToken(credentials);
+            if (outcome.ok) {
+                log.info("[Metrics] AGC token 预热完成");
+            }
+            else {
+                log.warn("[Metrics] AGC token 预热失败（不影响运行，dispose 上传时仍会重试）", { reason: outcome.reason });
+            }
+        },
     };
 }
 /** 获取 access token：优先读缓存（留 60s 余量），否则 client_credentials 换取并写缓存 */

package/dist/metrics/upload/types.d.ts

@@ -57,6 +57,11 @@ export interface OrphanRescueConfig {
     /** 快照最大补传年龄（天，缺省 7，超过视为陈旧放弃） */
     maxAgeDays?: number;
 }
+/** 退出排空配置 */
+export interface DisposeConfig {
+    /** dispose 排空上传队列的超时（毫秒，缺省 60000）；超时未完成任务移入 failed/ 下次补偿 */
+    drainMs?: number;
+}
 /** opencode.json 的 upload 配置整块（§13.8） */
 export interface UploadConfig {
     /** 上传总开关，缺省 true（装上即上传）；false 显式关闭 */
@@ -73,6 +78,7 @@ export interface UploadConfig {
     retry?: UploadRetryConfig;
     retryRescue?: RetryRescueConfig;
     orphanRescue?: OrphanRescueConfig;
+    dispose?: DisposeConfig;
 }
 /** 暂存目录内的单个上传文件（归档包或快照） */
 export interface UploadPackageFile {

package/dist/metrics/upload/uploadManager.js

@@ -25,6 +25,9 @@ export function createUploadManager(options) {
     const uploader = createAgcUploader(credentialsResult.credentials);
     const scenarios = resolveScenarios(config.scenarios);
     const directories = options.dirs;
+    // token 预热：启动即后台获取并落缓存，dispose 触发的上传直接读缓存，
+    // 避免在退出窗口（drain 超时）内等首次 token 网络往返（最长 30s）
+    void uploader.warmup();
     // 终态场景标签集合：这些标签的包上传成功即写已传标记（孤儿扫描防重依据）
     const terminalLabels = new Set(scenarios
         .filter((s) => s.enabled && (s.events.includes("session.deleted") || s.toolNames.length > 0))
@@ -251,7 +254,23 @@ export function createUploadManager(options) {
                 await triggerUpload(sessionId, scenario.label);
             }
         }
-        await queue.drain(10_000);
+        // 排空超时可配（默认 60s）：归档同步完成，token 已预热读缓存，
+        // 剩余耗时只有上传本身；超时未完成的任务移入 failed/ 由下次启动补偿
+        const drainMs = config.dispose?.drainMs ?? 60_000;
+        const drained = await queue.drain(drainMs);
+        if (drained) {
+            log.info("[Metrics] dispose 排空完成", { timeoutMs: drainMs });
+            return;
+        }
+        const leftover = queue.snapshotPending();
+        for (const pkg of leftover) {
+            const metaPath = pkg.archive.filePath.replace(/\.tar\.gz$/, ".meta.json");
+            movePackageIntoFailed(directories.uploadStagingDir, pkg, metaPath);
+        }
+        log.warn("[Metrics] dispose 排空超时，剩余任务已移入 failed 待下次补偿", {
+            timeoutMs: drainMs,
+            remaining: leftover.length + (queue.pendingCount() - leftover.length),
+        });
     }
     /** 终态场景标签：事件含 session.deleted 的启用场景，缺省回退 session-end */
     function terminalScenarioLabel() {
@@ -345,6 +364,7 @@ function sweepStagingDirectory(stagingDir, rescueEnabled) {
         const names = new Set(entries);
         const handled = new Set(["failed"]);
         let removed = 0;
+        const removedNames = [];
         for (const entry of entries) {
             if (handled.has(entry))
                 continue;
@@ -358,6 +378,7 @@ function sweepStagingDirectory(stagingDir, rescueEnabled) {
                 else {
                     fs.rmSync(path.join(stagingDir, entry), { force: true });
                     removed++;
+                    removedNames.push(entry);
                 }
                 handled.add(entry);
                 handled.add(`${base}.json`);
@@ -367,10 +388,11 @@ function sweepStagingDirectory(stagingDir, rescueEnabled) {
             if (entry.endsWith(".json") || entry.startsWith(".assembly-")) {
                 fs.rmSync(path.join(stagingDir, entry), { recursive: true, force: true });
                 removed++;
+                removedNames.push(entry);
             }
         }
         if (removed > 0)
-            log.info("[Metrics] 启动清扫暂存目录", { stagingDir, removed });
+            log.info("[Metrics] 启动清扫暂存目录", { stagingDir, removed, removedNames });
     }
     catch {
         // 目录不存在：无需处理

package/dist/metrics/upload/uploadQueue.d.ts

@@ -24,6 +24,8 @@ export interface UploadQueue {
     drain(timeoutMs: number): Promise<boolean>;
     /** 当前待处理与进行中的任务数 */
     pendingCount(): number;
+    /** 未开始执行的待处理任务快照（dispose 超时善后用） */
+    snapshotPending(): UploadPackage[];
 }
 /**
  * 创建串行上传队列：任务按入队顺序逐个执行，

package/dist/metrics/upload/uploadQueue.js

@@ -70,6 +70,9 @@ export function createUploadQueue(options) {
         pendingCount() {
             return pending.length + (processing ? 1 : 0);
         },
+        snapshotPending() {
+            return [...pending];
+        },
     };
 }
 function sleep(ms) {

package/dist/plugin.js

@@ -1,6 +1,6 @@
 import { createMetricsRuntime } from "./metrics/runtime.js";
 import { resolvePluginConfig } from "./metrics/configLoader.js";
-import { log } from "./shared/log.js";
+import { log, flushLogs } from "./shared/log.js";
 /**
  * opencode 插件入口。
  *
@@ -47,6 +47,8 @@ export const MetricsPlugin = async (input, options) => {
             runtime.engine.dispose();
             await runtime.uploadManager?.dispose();
             log.info("[MetricsPlugin] disposed");
+            // 冲刷日志缓冲（500ms 定时落盘）：退出窗口内的"上传完成/排空"日志不再丢失
+            flushLogs();
         },
     };
     return hooks;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-metrics-plugin",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "opencode plugin: auto-records every session's metrics (tokens/rounds/steps/sub-agents/hvigor builds) to snapshot JSON. Zero DB, zero config. Pair with session-viewer for visualization.",
   "type": "module",
   "license": "MIT",