opencode-metrics-plugin 0.3.5 → 0.4.2

package/dist/metrics/runtime.d.ts

@@ -6,6 +6,12 @@ export interface MetricsRuntimeOptions extends Omit<MetricsEngineOptions, 'enabl
     enabled?: boolean;
     /** 事件写盘（events/<sessionId>.log；steps 全文的数据源） */
     eventLogging?: boolean;
+    /**
+     * 会话 agent 白名单（通配符 `*`，如 ["android-to-hmos-*", "build"]）：
+     * 根会话的 agent 命中任一模式才记录（快照/事件日志/上传全不产生），子会话随父判定；
+     * 缺省/空数组 = 不过滤，记录全部会话（向后兼容）。
+     */
+    agents?: string[];
     /** 上传子系统配置（DESIGN.md §13.8）；enabled:true 才会创建管理器 */
     upload?: UploadConfig;
 }
@@ -18,6 +24,11 @@ export declare function createMetricsRuntime(opts?: MetricsRuntimeOptions): {
     eventLogger: import("./eventlog/event-logger.js").EventLogger | null;
     engine: import("./types.js").MetricsEngine;
     uploadManager: import("./upload/uploadManager.js").UploadManager | null;
+    sessionFilter: {
+        active: boolean;
+        shouldTrackEvent: (event: import("./sessionFilter.js").SessionFilterEvent) => boolean;
+        shouldTrackSession: (sessionId: string) => boolean;
+    };
     /** opencode event hook：`async ({ event }) => { runtime.event({ event }) }` */
     event(input: {
         event: {

package/dist/metrics/runtime.js

@@ -1,5 +1,6 @@
 import { createMetricsEngine } from './engine/engine.js';
 import { createEventLogger } from './eventlog/event-logger.js';
+import { createSessionFilter } from './sessionFilter.js';
 import { resolveDirs } from './dirs.js';
 import { createUploadManager } from './upload/uploadManager.js';
 /**
@@ -17,6 +18,8 @@ export function createMetricsRuntime(opts = {}) {
     const eventLogger = (opts.eventLogging ?? true)
         ? createEventLogger(true, false, { eventsDir: dirs.eventsDir })
         : null;
+    // 会话 agent 过滤：event 入口统一拦截，事件日志/引擎/上传三个子系统一次挡住
+    const sessionFilter = createSessionFilter(opts.agents);
     // 上传管理器旁路挂在 runtime.event 上（在 engine.ingest 之后，保证触发时快照已落盘）
     const uploadManager = createUploadManager({
         config: opts.upload,
@@ -32,8 +35,11 @@ export function createMetricsRuntime(opts = {}) {
         eventLogger,
         engine,
         uploadManager,
+        sessionFilter,
         /** opencode event hook：`async ({ event }) => { runtime.event({ event }) }` */
         event(input) {
+            if (!sessionFilter.shouldTrackEvent(input.event))
+                return;
             eventLogger?.log(input.event);
             engine.ingest(input.event);
             uploadManager?.observe(input.event);

package/dist/metrics/sessionFilter.d.ts

@@ -0,0 +1,12 @@
+export interface SessionFilterEvent {
+    type: string;
+    properties?: Record<string, unknown>;
+}
+/** 通配符转正则：* → 任意串，其余字符按字面匹配；整串匹配，大小写敏感 */
+export declare function compileAgentPatterns(patterns: readonly string[]): RegExp[];
+export declare function createSessionFilter(agents?: readonly string[]): {
+    active: boolean;
+    shouldTrackEvent: (event: SessionFilterEvent) => boolean;
+    shouldTrackSession: (sessionId: string) => boolean;
+};
+export type SessionFilter = ReturnType<typeof createSessionFilter>;

package/dist/metrics/sessionFilter.js

@@ -0,0 +1,104 @@
+// 会话 agent 过滤器：按根会话的 agent 通配匹配决定是否记录，子会话随父判定。
+//
+// 设计要点：
+// - 判定信号：session.created / session.updated 的 properties.info.agent（实测会话首个事件即携带）；
+//   message.updated 的 info.agent 作兜底（session 事件缺 agent 时）。agent 首次非空即终判，不再翻案。
+// - fail-open：agent 始终未知的会话默认记录，防止 opencode 事件结构变化导致漏采。
+// - 子会话（info.parentID）不独立判定，解析到根会话后跟随其判定；父未判定时同样放行。
+// - 未配置 agents（缺省/空数组/全空串）时过滤器不激活，所有事件直通（向后兼容）。
+/** 通配符转正则：* → 任意串，其余字符按字面匹配；整串匹配，大小写敏感 */
+export function compileAgentPatterns(patterns) {
+    const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return patterns.map((p) => new RegExp(`^${p.split("*").map(escape).join(".*")}$`));
+}
+export function createSessionFilter(agents) {
+    const patterns = (agents ?? []).filter((p) => typeof p === "string" && p.length > 0);
+    const active = patterns.length > 0;
+    const regexes = active ? compileAgentPatterns(patterns) : [];
+    const decisions = new Map();
+    const childToParent = new Map();
+    function matchesAgent(agent) {
+        return regexes.some((re) => re.test(agent));
+    }
+    /** 沿 parentID 链向上找根会话（防环，最多 10 层） */
+    function resolveRoot(sessionId) {
+        let root = sessionId;
+        for (let i = 0; i < 10; i++) {
+            const parent = childToParent.get(root);
+            if (!parent)
+                break;
+            root = parent;
+        }
+        return root;
+    }
+    function decide(rootId, agent) {
+        const existing = decisions.get(rootId);
+        if (existing === "in" || existing === "out")
+            return;
+        decisions.set(rootId, matchesAgent(agent) ? "in" : "out");
+    }
+    /** 会话级判定：供 system.transform 等按 sessionId 查询的入口 */
+    function shouldTrackSession(sessionId) {
+        if (!active)
+            return true;
+        return decisions.get(resolveRoot(sessionId)) !== "out";
+    }
+    function extractSessionId(props) {
+        const sessionID = props.sessionID;
+        if (typeof sessionID === "string" && sessionID)
+            return sessionID;
+        const info = props.info;
+        const id = info?.id;
+        if (typeof id === "string" && id)
+            return id;
+        return undefined;
+    }
+    /**
+     * 事件级判定 + 状态机推进；返回 false 表示该事件所属会话不在记录范围。
+     * 无法归属会话的事件放行（引擎侧自会丢弃）。
+     */
+    function shouldTrackEvent(event) {
+        if (!active)
+            return true;
+        const props = event.properties;
+        if (!props)
+            return true;
+        if (event.type === "session.created" || event.type === "session.updated") {
+            const info = props.info;
+            const id = info?.id;
+            if (typeof id === "string" && id) {
+                const parentID = info.parentID;
+                if (typeof parentID === "string" && parentID) {
+                    childToParent.set(id, parentID);
+                }
+                else {
+                    const agent = info.agent;
+                    if (typeof agent === "string" && agent)
+                        decide(id, agent);
+                }
+            }
+        }
+        else if (event.type === "message.updated") {
+            // 兜底：session 事件一直没带 agent 时，用消息的 agent 定案（仅根会话）
+            const sessionID = props.sessionID;
+            const info = props.info;
+            const agent = info?.agent;
+            if (typeof sessionID === "string" && sessionID && typeof agent === "string" && agent && !childToParent.has(sessionID)) {
+                decide(resolveRoot(sessionID), agent);
+            }
+        }
+        else if (event.type === "session.deleted") {
+            // 清理：根会话删除即移除判定；子会话删除移除映射
+            const sid = extractSessionId(props);
+            if (sid) {
+                childToParent.delete(sid);
+                decisions.delete(sid);
+            }
+        }
+        const sid = extractSessionId(props);
+        if (!sid)
+            return true;
+        return shouldTrackSession(sid);
+    }
+    return { active, shouldTrackEvent, shouldTrackSession };
+}

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

@@ -2,15 +2,12 @@ import type { MetricsDirs } from "../dirs.js";
 import type { SessionMetricsState } from "../engine/state.js";
 import type { RoundSnapshot, MetricsOutput } from "../types.js";
 /**
- * 把会话当前状态落盘为快照文件（读旧文件 → 合并 → 原子覆盖写）。
- * 可重复调用，不会造成数据重复累计。
+ * 刷新会话的工程代码行多维统计（30s 节流；候选根集合变化立即重扫）。
+ * 扫描口径见 analysis/codelines.ts；找不到鸿蒙工程根时全维度保持 0。
  *
- * @param sessionId 会话 id，快照文件名为 `<sessionId>.json`
- * @param state     会话状态，写盘成功后原地刷新差量基线
- * @param now       本次快照的结束时间（ms）
- * @param dirs      输出目录；缺省用进程级默认目录
- * @returns         本次由内存态构建的快照（未与旧文件合并的那份）
+ * @param state 会话状态（结果原地写入 state.codeLines）
  */
+export declare function refreshCodeLineStats(state: SessionMetricsState): void;
 declare function flushMetrics(sessionId: string, state: SessionMetricsState, now: number, dirs?: Partial<MetricsDirs>): MetricsOutput;
 /**
  * 处理一轮会话结束：保存本轮 round 快照并落盘。
@@ -19,6 +16,15 @@ declare function flushMetrics(sessionId: string, state: SessionMetricsState, now
  * @param sessionId 会话 id
  * @param dirs      输出目录；缺省用进程级默认目录
  */
+/**
+ * 轮闭合前的等待结算（0.4.1 活跃口径）：把仍挂起的 question/permission/retry
+ * 截断入本轮累加器，并把挂起计时重锚到闭合时刻——等待若延续到下一轮，
+ * 只在新轮计尾段，跨轮拆分总量不丢、不双计。
+ *
+ * @param state 会话状态（就地结算累加器与挂起计时）
+ * @param now   轮闭合时刻（ms）
+ */
+export declare function finalizeRoundWaits(state: SessionMetricsState, now: number): void;
 /**
  * 从当前轮累计态构建轮快照；空轮（无 token 且无工具调用）返回 null（天然防重）。
  *
@@ -26,7 +32,7 @@ declare function flushMetrics(sessionId: string, state: SessionMetricsState, now
  * @param now   结算时刻（ms）
  */
 export declare function buildRoundSnapshot(state: SessionMetricsState, now: number): RoundSnapshot | null;
-/** 重置轮累计态，开始新轮（不改动 stage 相关状态）。 */
+/** 重置轮累计态，开始新轮（不改动 stage 相关状态；等待挂起计时由 finalizeRoundWaits 结算）。 */
 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

@@ -5,6 +5,7 @@ import { createTokenUsage } from "../types.js";
 import { getMetricsDir } from "../dirs.js";
 import { buildSteps, extractStepContent } from "./steps.js";
 import { mergeMetricsOutput } from "./merge.js";
+import { discoverHarmonyRoots, scanCodeLines } from "../analysis/codelines.js";
 function filterByKeys(source, keys) {
     const result = new Map();
     for (const key of keys) {
@@ -24,7 +25,40 @@ function filterByKeys(source, keys) {
  * @param dirs      输出目录；缺省用进程级默认目录
  * @returns         本次由内存态构建的快照（未与旧文件合并的那份）
  */
+/** 代码行扫描节流间隔：活跃会话 checkpoint 频率远高于此，避免重复扫盘 */
+const CODE_SCAN_THROTTLE_MS = 30_000;
+/**
+ * 刷新会话的工程代码行多维统计（30s 节流；候选根集合变化立即重扫）。
+ * 扫描口径见 analysis/codelines.ts；找不到鸿蒙工程根时全维度保持 0。
+ *
+ * @param state 会话状态（结果原地写入 state.codeLines）
+ */
+export function refreshCodeLineStats(state) {
+    try {
+        const candidates = [state.sessionMeta.workingDirectory, ...state.codeRootCandidates]
+            .filter((dir) => typeof dir === "string" && dir.length > 0);
+        const rootsKey = [...candidates]
+            .map((dir) => (process.platform === "win32" ? dir.toLowerCase() : dir))
+            .sort()
+            .join("|");
+        const now = Date.now();
+        if (state._lastCodeScanAt > 0 &&
+            now - state._lastCodeScanAt < CODE_SCAN_THROTTLE_MS &&
+            state._codeScanRootsKey === rootsKey) {
+            return;
+        }
+        const roots = discoverHarmonyRoots(candidates, state.startTime);
+        state.codeLines = scanCodeLines(roots);
+        state._lastCodeScanAt = now;
+        state._codeScanRootsKey = rootsKey;
+    }
+    catch {
+        // 扫描失败保持上次结果（或全 0），不影响快照其余字段
+    }
+}
 function flushMetrics(sessionId, state, now, dirs) {
+    // 代码行多维统计（节流扫描，见 refreshCodeLineStats）
+    refreshCodeLineStats(state);
     // Finalize agent usage for current agent
     if (state.agent.current) {
         const elapsed = now - state.agent.lastSwitchTime;
@@ -36,6 +70,16 @@ function flushMetrics(sessionId, state, now, dirs) {
     }
     const endTime = now;
     const duration = endTime - state.startTime;
+    // AI 活跃统计（0.4.1 起）：Σ 已闭合轮 activeDuration + 等待明细（进行中的开轮不计，闭合后下次 flush 补齐）
+    const aiActiveDuration = state.rounds.reduce((sum, r) => sum + (r.activeDuration ?? r.duration ?? 0), 0);
+    const roundsDuration = state.rounds.reduce((sum, r) => sum + (r.duration || 0), 0);
+    const waitBreakdown = {
+        questionMs: state.rounds.reduce((sum, r) => sum + (r.questionMs ?? 0), 0),
+        permissionMs: state.rounds.reduce((sum, r) => sum + (r.permissionMs ?? 0), 0),
+        retryMs: state.rounds.reduce((sum, r) => sum + (r.retryMs ?? 0), 0),
+        retryCount: state.rounds.reduce((sum, r) => sum + (r.retryCount ?? 0), 0),
+        otherIdleMs: Math.max(0, duration - roundsDuration),
+    };
     // Calculate cache hit rate
     const denom = state.tokens.input + state.tokens.cacheRead;
     const cacheHitRate = denom > 0 ? state.tokens.cacheRead / denom : 0;
@@ -223,6 +267,9 @@ function flushMetrics(sessionId, state, now, dirs) {
         startTime: state.startTime,
         endTime,
         duration,
+        aiActiveDuration,
+        aiActiveRatio: duration > 0 ? aiActiveDuration / duration : 0,
+        waitBreakdown,
         systemPrompts,
         rounds: state.rounds,
         tokens: (() => {
@@ -260,7 +307,11 @@ function flushMetrics(sessionId, state, now, dirs) {
         })),
         header,
         codeStats: {
-            etsLines: state.compileStats.etsLines,
+            etsLines: state.codeLines.etsLines,
+            cLines: state.codeLines.cLines,
+            cppLines: state.codeLines.cppLines,
+            testLines: state.codeLines.testLines,
+            businessCodeLines: state.codeLines.businessCodeLines,
             buildSuccess: state.compileStats.lastBuildSuccess,
             fixCompileCount: state.compileStats.hvigorwCalls,
             totalCompileErrors: state.compileStats.hvigorwErrors,
@@ -394,6 +445,33 @@ function flushMetrics(sessionId, state, now, dirs) {
  * @param sessionId 会话 id
  * @param dirs      输出目录；缺省用进程级默认目录
  */
+/**
+ * 轮闭合前的等待结算（0.4.1 活跃口径）：把仍挂起的 question/permission/retry
+ * 截断入本轮累加器，并把挂起计时重锚到闭合时刻——等待若延续到下一轮，
+ * 只在新轮计尾段，跨轮拆分总量不丢、不双计。
+ *
+ * @param state 会话状态（就地结算累加器与挂起计时）
+ * @param now   轮闭合时刻（ms）
+ */
+export function finalizeRoundWaits(state, now) {
+    // 未答的权限询问：截断入本轮并移除（后续 replied 到达时无条目即忽略，防跨轮双计）
+    for (const [id, pending] of state._pendingPermissionAsks) {
+        state._roundPermissionMs += Math.max(0, now - pending.askedAt);
+        state._pendingPermissionAsks.delete(id);
+    }
+    // 挂起中的限流重试：截断入本轮，起点重锚（计数已在 retry 事件时入账，此处只补时长）
+    if (state._retryStartedAt !== null) {
+        state._roundRetryMs += Math.max(0, now - state._retryStartedAt);
+        state._retryStartedAt = now;
+    }
+    // 仍在等待回答的 question 工具：截断入本轮，startMs 重锚（completed 事件只补尾段）
+    for (const tc of state.toolCallMap.values()) {
+        if (tc.tool === "question" && tc.status === "running" && tc.startMs > 0 && tc.startMs < now) {
+            state._roundQuestionMs += now - tc.startMs;
+            tc.startMs = now;
+        }
+    }
+}
 /**
  * 从当前轮累计态构建轮快照；空轮（无 token 且无工具调用）返回 null（天然防重）。
  *
@@ -401,16 +479,34 @@ function flushMetrics(sessionId, state, now, dirs) {
  * @param now   结算时刻（ms）
  */
 export function buildRoundSnapshot(state, now) {
-    const isEmptyRound = state._roundTokens.total === 0 && state._roundToolCalls === 0;
+    // 空轮判定：无 token、无工具调用且无任何等待（限流/审批/提问）才视为空轮丢弃。
+    // 仅含等待的轮（如纯限流挂起）仍占用墙钟，须保留以维持 activeDuration 扣减恒等式。
+    const isEmptyRound = state._roundTokens.total === 0
+        && state._roundToolCalls === 0
+        && state._roundQuestionMs === 0
+        && state._roundPermissionMs === 0
+        && state._roundRetryMs === 0
+        && state._roundRetryCount === 0;
     if (isEmptyRound)
         return null;
     const firstTokenLatency = state._hasTextPart && state._firstEventTime > 0
         ? state._firstTextTime - state._firstEventTime
         : 0;
+    const duration = now - state._roundStartTime;
+    // 活跃口径（0.4.1 起）：轮墙钟减已知等待，各项 clamp 到 [0, duration]，合计下限 0
+    const clampWait = (v) => Math.max(0, Math.min(v, duration));
+    const questionMs = clampWait(state._roundQuestionMs);
+    const permissionMs = clampWait(state._roundPermissionMs);
+    const retryMs = clampWait(state._roundRetryMs);
     return {
         startTime: state._roundStartTime,
         roundIndex: state.rounds.length,
-        duration: now - state._roundStartTime,
+        duration,
+        activeDuration: Math.max(0, duration - questionMs - permissionMs - retryMs),
+        questionMs,
+        permissionMs,
+        retryMs,
+        retryCount: state._roundRetryCount,
         firstTokenLatency,
         tokens: { ...state._roundTokens },
         toolCalls: state._roundToolCalls,
@@ -418,7 +514,7 @@ export function buildRoundSnapshot(state, now) {
         userMessage: state._pendingUserMessage.length > 0 ? [...state._pendingUserMessage] : undefined,
     };
 }
-/** 重置轮累计态，开始新轮（不改动 stage 相关状态）。 */
+/** 重置轮累计态，开始新轮（不改动 stage 相关状态；等待挂起计时由 finalizeRoundWaits 结算）。 */
 export function resetRoundState(state, now) {
     state._roundStartTime = now;
     state._firstEventTime = 0;
@@ -428,6 +524,10 @@ export function resetRoundState(state, now) {
     state._roundTokens = createTokenUsage();
     state._roundToolCalls = 0;
     state._roundErrors = 0;
+    state._roundQuestionMs = 0;
+    state._roundPermissionMs = 0;
+    state._roundRetryMs = 0;
+    state._roundRetryCount = 0;
     state._pendingUserMessage = [];
     state._roundFirstBuildTracked = false;
 }
@@ -437,6 +537,7 @@ function handleSessionIdle(state, sessionId, dirs) {
     if (state._roundIdleProcessed) {
         return;
     }
+    finalizeRoundWaits(state, now);
     const round = buildRoundSnapshot(state, now);
     if (round)
         state.rounds.push(round);

package/dist/metrics/snapshot/merge.js

@@ -57,7 +57,6 @@ function mergeChildMetrics(parent, child, meta) {
     // 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;
@@ -207,6 +206,18 @@ export function mergeMetricsOutput(existing, fresh, baseline) {
             ...fresh.rounds.filter(r => !existingRoundIndices.has(r.roundIndex)),
         ].sort((a, b) => a.roundIndex - b.roundIndex);
     })();
+    // AI 活跃统计（0.4.1 起）：从合并后的轮数组重算——fresh 重启后可能只含新段，
+    // 不能直接展开 fresh 汇总；旧轮（0.4.0 快照）缺 activeDuration 回退按 duration 计（视为全活跃），
+    // 等待明细缺省按 0。与 planning 同思路：合并方从合并后明细重新推导。
+    const aiActiveDuration = rounds.reduce((sum, r) => sum + (r.activeDuration ?? r.duration ?? 0), 0);
+    const roundsDuration = rounds.reduce((sum, r) => sum + (r.duration || 0), 0);
+    const waitBreakdown = {
+        questionMs: rounds.reduce((sum, r) => sum + (r.questionMs ?? 0), 0),
+        permissionMs: rounds.reduce((sum, r) => sum + (r.permissionMs ?? 0), 0),
+        retryMs: rounds.reduce((sum, r) => sum + (r.retryMs ?? 0), 0),
+        retryCount: rounds.reduce((sum, r) => sum + (r.retryCount ?? 0), 0),
+        otherIdleMs: Math.max(0, duration - roundsDuration),
+    };
     // Steps：进程重启后 orderCounter 从 0 重编，fresh 的 index 与磁盘 existing 撞车，
     // 且时间上更晚的新步骤被排到列表头部；resume 重灌轮的时间戳全新，index 与时间戳都无法跨进程关联。
     // 统一策略：按 startTime:endTime 去重（防同进程重放，fresh wins）后，
@@ -494,18 +505,24 @@ export function mergeMetricsOutput(existing, fresh, baseline) {
         };
     })();
     // codeStats 顶层分两类处理：累计型（fixCompileCount/totalCompileErrors）按差量并入；
-    // 快照型（etsLines/buildSuccess/firstBuildPassRate/firstBuildPerRound）在 fresh 无构建迹象
-    // （全零/空）时保留 existing——重启进程没跑过 hvigorw，fresh 全零是"不知道"而非"清零"。
+    // 快照型（代码行五维/buildSuccess/firstBuildPassRate/firstBuildPerRound）在 fresh
+    // 有值（>0）时取 fresh——工程全量扫描的时效值，fresh 无值保留 existing
+    // （重启进程未扫到工程是"不知道"而非"清零"）。
     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
+    const freshHasBuild = fresh.codeStats.businessCodeLines > 0
         || fresh.codeStats.fixCompileCount > (baseline?.fixCompileCount ?? 0)
         || totalCompileErrors > existing.codeStats.totalCompileErrors
         || fresh.codeStats.firstBuildPerRound.length > 0;
+    const pickLineCount = (freshValue, existingValue) => (freshValue ?? 0) > 0 ? freshValue : (existingValue ?? 0);
     const codeStats = {
-        etsLines: fresh.codeStats.etsLines > 0 ? fresh.codeStats.etsLines : existing.codeStats.etsLines,
+        etsLines: pickLineCount(fresh.codeStats.etsLines, existing.codeStats.etsLines),
+        cLines: pickLineCount(fresh.codeStats.cLines, existing.codeStats.cLines),
+        cppLines: pickLineCount(fresh.codeStats.cppLines, existing.codeStats.cppLines),
+        testLines: pickLineCount(fresh.codeStats.testLines, existing.codeStats.testLines),
+        businessCodeLines: pickLineCount(fresh.codeStats.businessCodeLines, existing.codeStats.businessCodeLines),
         buildSuccess: freshHasBuild ? fresh.codeStats.buildSuccess : existing.codeStats.buildSuccess,
         fixCompileCount,
         totalCompileErrors,
@@ -526,6 +543,9 @@ export function mergeMetricsOutput(existing, fresh, baseline) {
         startTime,
         endTime: fresh.endTime,
         duration,
+        aiActiveDuration,
+        aiActiveRatio: duration > 0 ? aiActiveDuration / duration : 0,
+        waitBreakdown,
         systemPrompts,
         rounds,
         tokens,

package/dist/metrics/types.d.ts

@@ -85,7 +85,6 @@ export interface CompileStats {
     hvigorwCalls: number;
     hvigorwErrors: number;
     lastBuildSuccess: boolean;
-    etsLines: number;
     firstBuildPerRound: boolean[];
     errorCodes: Map<string, {
         count: number;
@@ -163,12 +162,35 @@ export interface RoundSnapshot {
     startTime?: number;
     roundIndex: number;
     duration: number;
+    /** AI 活跃时长（0.4.1 起）= duration − questionMs − permissionMs − retryMs（下限 0）；旧快照缺省，合并回退按 duration 计 */
+    activeDuration?: number;
+    /** question 工具等待用户回答累计（ms，0.4.1 起） */
+    questionMs?: number;
+    /** 权限审批等待累计（ms，0.4.1 起） */
+    permissionMs?: number;
+    /** 限流重试挂起累计（ms，0.4.1 起） */
+    retryMs?: number;
+    /** 限流重试次数（0.4.1 起） */
+    retryCount?: number;
     firstTokenLatency: number;
     tokens: TokenUsage;
     toolCalls: number;
     errors: number;
     userMessage?: string[];
 }
+/** 会话级等待扣减明细（0.4.1 起）：duration = aiActiveDuration + 各等待项之和 */
+export interface WaitBreakdown {
+    /** question 工具等待用户回答累计（ms） */
+    questionMs: number;
+    /** 权限审批等待累计（ms） */
+    permissionMs: number;
+    /** 限流重试挂起累计（ms） */
+    retryMs: number;
+    /** 限流重试次数 */
+    retryCount: number;
+    /** 轮间空闲：墙钟未被任何已闭合轮覆盖的部分（ms） */
+    otherIdleMs: number;
+}
 export interface SubAgentOutput {
     sessionId: string;
     agent: string;
@@ -201,6 +223,12 @@ export interface MetricsOutput {
     startTime: number;
     endTime: number;
     duration: number;
+    /** AI 活跃时长（0.4.1 起）：Σ 轮 activeDuration（轮墙钟减去已知等待，step 间死时间计入活跃） */
+    aiActiveDuration?: number;
+    /** AI 活跃占比 = aiActiveDuration / duration（0-1，0.4.1 起） */
+    aiActiveRatio?: number;
+    /** 等待扣减明细（0.4.1 起） */
+    waitBreakdown?: WaitBreakdown;
     systemPrompts: Record<string, string[]>;
     rounds: RoundSnapshot[];
     tokens: TokenUsage & {
@@ -235,7 +263,16 @@ export interface MetricsOutput {
     }>;
     header: SessionMeta;
     codeStats: {
+        /** 排除测试的 .ets 行数（0.4.2 起为工程全量扫描口径，非 write 工具累计） */
         etsLines: number;
+        /** 排除测试的 C（.c/.h）行数 */
+        cLines: number;
+        /** 排除测试的 C++（.cpp/.cc/.cxx/.hpp 等）行数 */
+        cppLines: number;
+        /** 测试代码行数（ohosTest、test 等目录子树与 .test.、.spec. 命名文件，任意语言） */
+        testLines: number;
+        /** 实际业务代码总量 = ets + C + C++ + 测试（= 全量；构建/配置文件不计入） */
+        businessCodeLines: number;
         buildSuccess: boolean;
         fixCompileCount: number;
         totalCompileErrors: number;

package/dist/metrics/upload/scenarios.js

@@ -6,7 +6,9 @@ const BUILTIN_SCENARIOS = {
         events: ["dispose", "session.deleted"],
         tools: ["task"],
     },
-    "git-commit": { label: "git", commands: ["\\bgit\\s+commit\\b"] },
+    // git 与 commit 之间允许 ≤4 个选项（如 -c user.name=x、-C <path>、--no-verify），
+    // 但选项必须以 - 开头——避免把 "git log --grep=commit" 一类误判为提交
+    "git-commit": { label: "git", commands: ["\\bgit\\s+(?:-{1,2}[\\w.-]+(?:[ =][^\\s]+)?\\s+){0,4}commit\\b"] },
 };
 /**
  * 合并内置场景与 opencode.json 配置：内置 key 深合并（label/commands/events/tools

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

@@ -1,5 +1,5 @@
 import type { MetricsDirs } from "../dirs.js";
-import type { UploadConfig } from "./types.js";
+import type { UploadConfig, UploadPackage } from "./types.js";
 export interface UploadManagerOptions {
     config?: UploadConfig;
     /** 实例目录（metricsDir/eventsDir/uploadStagingDir） */
@@ -23,6 +23,21 @@ export interface UploadManager {
  * @param options 配置与目录
  */
 export declare function createUploadManager(options: UploadManagerOptions): UploadManager | null;
+/**
+ * 启动清扫暂存目录顶层：崩溃遗留的完整三件套（tar.gz + json + meta.json）
+ * 移入 failed/ 同构目录并入队重传；孤立文件与组装目录直接删除。
+ *
+ * 两遍扫描：第一遍只处理 .tar.gz（三件套校验 → rescue 或删 tar.gz，并标记
+ * 三个文件名已处理）。字母序下 .json/.meta.json 先于 .tar.gz 迭代，若单遍
+ * 边迭代边删 .json，会在 tar.gz 校验前破坏三件套——完整崩溃遗留包必然被
+ * 误判"不完整"而销毁（曾连续销毁终态包）。第二遍才清理无 tar.gz 对应的
+ * 孤儿 .json/meta 与组装残留。
+ *
+ * @param stagingDir    暂存目录
+ * @param rescueEnabled 失败保留开关（false 时完整三件套也直接删除，旧行为）
+ * @returns             可补偿重传的包列表（顶层遗留部分）
+ */
+export declare function sweepStagingDirectory(stagingDir: string, rescueEnabled: boolean): UploadPackage[];
 /**
  * 记录会话终态包已成功上云。
  * 快照原件（metrics/<sessionId>.json）会永久保留为本地记录，
@@ -41,7 +56,10 @@ export interface OrphanSnapshot {
 }
 /**
  * 扫描目录选出孤儿快照候选：mtime 静默 [idleMs, maxAgeMs] 且不在活跃集的快照。
- * 上传成功后快照即被删除，"文件仍在"天然等价于"终态未传出"。
+ * 快照原件永久保留为本地记录，"已传标记"是防重复上传的依据。
+ * 时效判断：标记只证明"标记时刻之前的快照已上云"——会话在中途终态触发
+ * （task 完成/session.deleted）上传后仍可能继续运行并更新快照，因此快照
+ * mtime 晚于标记时间（超出 60s 缓冲）仍视为孤儿，补传最终态。
  *
  * @param metricsDir 快照目录
  * @param idleMs     静默下限（毫秒）