opencode-metrics-plugin 0.4.0 → 0.4.2

package/CHANGELOG.md

@@ -1,9 +1,23 @@
 # Changelog
 
+## 0.4.2（2026-09-16）
+
+- **代码行多维统计**（工程全量扫描口径，替代 write 工具累计）：`codeStats` 新增 `cLines` / `cppLines` / `testLines` / `businessCodeLines`，`etsLines` 改为鸿蒙工程全量扫描（排除测试）。根发现 = 会话工作目录 + bash workdir + write/edit 文件目录（向上提升到鸿蒙工程根 + 安卓工程的兄弟鸿蒙工程探测，mtime 时间窗防邻居混入）；`.h` 计入 C、`.hpp` 等计入 C++（头文件统一归入语言维度）；测试目录（ohosTest/test/mock 等）子树与 `.test.`/`.spec.` 命名文件计为测试维度（任意语言，不与语言维度重复计数）；构建/配置文件（hvigorfile.ts、CMakeLists.txt、.json5）不计入。flush 时 30s 节流扫描，候选根集合变化立即重扫。配套 session-viewer Code Stats 卡片展示五维。
+- **修复 droid2hmos 包装器构建漏记**：`droid2hmos build/test harmony` 内部执行 hvigorw 但命令行不含 hvigorw、输出仅状态摘要（hvigor 原始输出按迁移工作台规则重定向日志文件）——按命令形态识别为构建调用，摘要含 `failed` 标记判失败（曾致整个迁移会话 codeStats 构建统计为空）。
+- **修复 git commit 场景漏触发**：内置 git-commit 正则支持 `git` 与 `commit` 之间出现选项（`-c user.name=x`、`-C <path>`、`--no-verify` 等，≤4 个），`git log` 类命令不误报（曾致 `git -c … commit` 形式的提交全部漏上传）。
+- **修复启动清扫误删完整上传包**：清扫改两遍扫描——第一遍只处理 `.tar.gz`（三件套校验→移入 failed/ 待重传，并标记保护），第二遍清理孤儿 `.json`/组装残留。字母序下单遍边迭代边删 `.json` 会必然破坏三件套校验，崩溃遗留的完整包被当垃圾销毁（曾连续销毁终态包致云端缺 43 分钟数据）。
+- **孤儿补传 .sent 时效判断**：已传标记只证明"标记时刻之前的快照已上云"，快照 mtime 晚于标记时间（>60s 缓冲）仍纳入孤儿补传——中途终态触发（task 完成/session.deleted）上传后继续运行的会话，最终态不再永久漏传。
+
+## 0.4.1（2026-09-16）
+
+- 新增 **AI 活跃时长**指标（快照顶层 `aiActiveDuration` / `aiActiveRatio` / `waitBreakdown`，轮级 `activeDuration` / `questionMs` / `permissionMs` / `retryMs` / `retryCount`）：从轮墙钟中扣减已知等待——question 工具等待用户回答、权限审批（`permission.asked`/`replied` 按 ID 配对，两事件键名不对称：`id` vs `requestID`）、apikey 限流挂起（`session.status` retry→busy 状态机）；step 间死时间计入活跃。`waitBreakdown.otherIdleMs` 为轮间空闲，满足恒等式 `duration = aiActiveDuration + questionMs + permissionMs + retryMs + otherIdleMs`。
+- 轮闭合时未决等待截断入轮（孤儿权限询问、挂起重试、未答 question），计时重锚防跨轮双计；子代理会话的权限/限流/question 等待同样扣减父轮。
+- 合并兼容：旧版（≤0.4.0）快照无新字段，合并时旧轮回退按 `duration` 计（视为全活跃）；会话级汇总从合并后轮数组重算，重启不丢不双计。配套 session-viewer 已做前向兼容（快照有值优先，旧快照回退 viewer 侧推导）。
+
 ## 0.4.0（2026-09-15）
 
 - 新增会话 agent 白名单 `agents`（支持 `*` 通配，如 `["android-to-hmos-*", "build"]`）：配置后只有根会话 agent 命中任一模式才记录——快照、事件日志、system prompt、上传全不产生；子会话（task/explore 等）随父会话判定正常并入；agent 未知的会话默认记录（fail-open）。缺省/空数组 = 不过滤全记（向后兼容）。
-- 典型用法：全局 `~/.config/opencode/opencode.json` 注册 `["opencode-metrics-plugin", { "agents": ["android-to-hmos-*"] }]`，实现「插件处处加载、只统计迁移 agent 的会话」，不受 opencode 项目级配置发现的 git 边界限制。注意项目 `.opencode/opencode-metrics.json(c)` 存在时仍会完全接管（含 `agents`），接管文件需同步配置。
+- 典型用法：全局 `~/.config/opencode/opencode.json` 注册 `["opencode-metrics-plugin", { "agents": ["android-to-hmos-00-orchestrator"] }]`，实现「插件处处加载、只统计迁移 agent 的会话」，不受 opencode 项目级配置发现的 git 边界限制。注意项目 `.opencode/opencode-metrics.json(c)` 存在时仍会完全接管（含 `agents`），接管文件需同步配置。
 
 ## 0.3.5（2026-09-15）
 

package/dist/metrics/analysis/codelines.d.ts

@@ -0,0 +1,39 @@
+/**
+ * codelines.ts — 会话关联鸿蒙工程的代码行多维统计。
+ *
+ * 口径（0.4.2 起，替代旧的 write 工具累计口径）：
+ *   - etsLines / cLines / cppLines：排除测试代码的各语言非空行数（.h 计入 C、
+ *     .hpp 等计入 C++，头文件统一归入语言维度）；
+ *   - testLines：测试目录（ohosTest/test/tests/mock/mocks/__tests__）子树及
+ *     *.test.* / *.spec.* 文件的代码行（任意语言，不与语言维度重复计数）；
+ *   - businessCodeLines：实际业务代码总量 = ets + C + C++ + 测试（构建/配置
+ *     文件 hvigorfile.ts、CMakeLists.txt、.json5 等不计入，故等于全量）。
+ *
+ * 根发现：候选路径（会话工作目录 + bash workdir + write/edit 文件目录）向上
+ * 提升到鸿蒙工程根（标记文件）；非鸿蒙目录（如安卓源工程）在父目录一级探测
+ * 兄弟鸿蒙工程（mtime ≥ 会话起点，防邻居旧工程混入）。
+ */
+export interface CodeLineStats {
+    etsLines: number;
+    cLines: number;
+    cppLines: number;
+    testLines: number;
+    /** 实际业务代码总量 = ets + C + C++ + 测试（= 全量） */
+    businessCodeLines: number;
+}
+/**
+ * 从候选路径集合发现鸿蒙工程根：向上提升（≤8 层）+ 安卓工程的兄弟鸿蒙工程
+ * 探测（父目录一级，mtime 时间窗 [sessionStartedAt-60s, ∞)）。
+ *
+ * @param candidates       候选路径（工作目录 / bash workdir / write|edit 文件目录）
+ * @param sessionStartedAt 会话起点（毫秒），兄弟工程 mtime 时间窗下界
+ * @returns                去重后的鸿蒙工程根绝对路径数组
+ */
+export declare function discoverHarmonyRoots(candidates: readonly string[], sessionStartedAt: number): string[];
+/**
+ * 扫描鸿蒙工程根集合，输出多维代码行统计。语言判定基于扩展名；测试目录
+ * 子树与测试命名文件全部计入 testLines，不与语言维度重复计数。
+ *
+ * @param roots 鸿蒙工程根绝对路径数组（重叠根自动按文件去重）
+ */
+export declare function scanCodeLines(roots: readonly string[]): CodeLineStats;

package/dist/metrics/analysis/codelines.js

@@ -0,0 +1,225 @@
+/**
+ * codelines.ts — 会话关联鸿蒙工程的代码行多维统计。
+ *
+ * 口径（0.4.2 起，替代旧的 write 工具累计口径）：
+ *   - etsLines / cLines / cppLines：排除测试代码的各语言非空行数（.h 计入 C、
+ *     .hpp 等计入 C++，头文件统一归入语言维度）；
+ *   - testLines：测试目录（ohosTest/test/tests/mock/mocks/__tests__）子树及
+ *     *.test.* / *.spec.* 文件的代码行（任意语言，不与语言维度重复计数）；
+ *   - businessCodeLines：实际业务代码总量 = ets + C + C++ + 测试（构建/配置
+ *     文件 hvigorfile.ts、CMakeLists.txt、.json5 等不计入，故等于全量）。
+ *
+ * 根发现：候选路径（会话工作目录 + bash workdir + write/edit 文件目录）向上
+ * 提升到鸿蒙工程根（标记文件）；非鸿蒙目录（如安卓源工程）在父目录一级探测
+ * 兄弟鸿蒙工程（mtime ≥ 会话起点，防邻居旧工程混入）。
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+/** 鸿蒙工程标记：命中其一即视为工程根 */
+const HARMONY_MARKERS = ["oh-package.json5", "build-profile.json5", "hvigorfile.ts", "AppScope"];
+/** 扫描时跳过的目录名（小写）；ohosTest/test 等测试目录不跳过、整树计为测试 */
+const EXCLUDED_DIRS = new Set([
+    "oh_modules", "node_modules", "build", ".hvigor", ".cxx", ".preview",
+    ".git", ".clangd", ".idea", ".vscode", ".cache", "cxx-deps",
+]);
+/** 目录名命中（小写）即整棵子树视为测试代码 */
+const TEST_DIRS = new Set(["ohostest", "test", "tests", "mock", "mocks", "__tests__"]);
+/** 文件名命中即视为测试代码（任意目录下） */
+const TEST_FILE_RE = /\.(test|spec)\.[^.]+$/;
+const CPP_EXTS = new Set([".cpp", ".cc", ".cxx", ".hpp", ".hh", ".hxx"]);
+const C_EXTS = new Set([".c", ".h"]);
+/** Windows 大小写不敏感的路径归一化键 */
+function normKey(p) {
+    const resolved = path.resolve(p);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function hasHarmonyMarkers(dir) {
+    try {
+        return HARMONY_MARKERS.some((marker) => fs.existsSync(path.join(dir, marker)));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 从候选路径集合发现鸿蒙工程根：向上提升（≤8 层）+ 安卓工程的兄弟鸿蒙工程
+ * 探测（父目录一级，mtime 时间窗 [sessionStartedAt-60s, ∞)）。
+ *
+ * @param candidates       候选路径（工作目录 / bash workdir / write|edit 文件目录）
+ * @param sessionStartedAt 会话起点（毫秒），兄弟工程 mtime 时间窗下界
+ * @returns                去重后的鸿蒙工程根绝对路径数组
+ */
+export function discoverHarmonyRoots(candidates, sessionStartedAt) {
+    const roots = [];
+    const seen = new Set();
+    const pushRoot = (dir) => {
+        const key = normKey(dir);
+        if (!seen.has(key)) {
+            seen.add(key);
+            roots.push(dir);
+        }
+    };
+    for (const candidate of candidates) {
+        if (!candidate || typeof candidate !== "string")
+            continue;
+        let dir;
+        try {
+            dir = path.resolve(candidate);
+        }
+        catch {
+            continue;
+        }
+        if (seen.has(normKey(dir)))
+            continue;
+        // ① 向上提升到鸿蒙工程根
+        let found = null;
+        let cursor = dir;
+        for (let i = 0; i < 8; i++) {
+            if (hasHarmonyMarkers(cursor)) {
+                found = cursor;
+                break;
+            }
+            const parent = path.dirname(cursor);
+            if (parent === cursor)
+                break;
+            cursor = parent;
+        }
+        if (found) {
+            pushRoot(found);
+            continue;
+        }
+        // ② 非鸿蒙目录（如安卓源工程根/子目录）：父目录一级探测兄弟鸿蒙工程
+        try {
+            const parent = path.dirname(dir);
+            for (const entry of fs.readdirSync(parent, { withFileTypes: true })) {
+                if (!entry.isDirectory())
+                    continue;
+                const sibling = path.join(parent, entry.name);
+                if (normKey(sibling) === normKey(dir))
+                    continue;
+                if (seen.has(normKey(sibling)))
+                    continue;
+                if (!hasHarmonyMarkers(sibling))
+                    continue;
+                // mtime 时间窗：兄弟工程须在会话起点后仍被写过（留 60s 时钟余量）
+                try {
+                    if (fs.statSync(sibling).mtimeMs < sessionStartedAt - 60_000)
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+                pushRoot(sibling);
+            }
+        }
+        catch {
+            // 父目录不可读：跳过兄弟探测
+        }
+    }
+    return roots;
+}
+/** 统计单个文件的非空行数（读取失败返回 0） */
+function countNonEmptyLines(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        let count = 0;
+        for (const line of content.split(/\r?\n/)) {
+            if (line.length > 0)
+                count++;
+        }
+        return count;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * 扫描鸿蒙工程根集合，输出多维代码行统计。语言判定基于扩展名；测试目录
+ * 子树与测试命名文件全部计入 testLines，不与语言维度重复计数。
+ *
+ * @param roots 鸿蒙工程根绝对路径数组（重叠根自动按文件去重）
+ */
+export function scanCodeLines(roots) {
+    const stats = {
+        etsLines: 0, cLines: 0, cppLines: 0, testLines: 0, businessCodeLines: 0,
+    };
+    const seenFiles = new Set();
+    const classifyFile = (filePath, inTestDir) => {
+        const ext = path.extname(filePath).toLowerCase();
+        let lang = null;
+        if (ext === ".ets")
+            lang = "ets";
+        else if (C_EXTS.has(ext))
+            lang = "c";
+        else if (CPP_EXTS.has(ext))
+            lang = "cpp";
+        if (!lang)
+            return;
+        const key = normKey(filePath);
+        if (seenFiles.has(key))
+            return;
+        seenFiles.add(key);
+        const lines = countNonEmptyLines(filePath);
+        if (inTestDir || TEST_FILE_RE.test(path.basename(filePath))) {
+            stats.testLines += lines;
+        }
+        else if (lang === "ets") {
+            stats.etsLines += lines;
+        }
+        else if (lang === "c") {
+            stats.cLines += lines;
+        }
+        else {
+            stats.cppLines += lines;
+        }
+    };
+    const countTestTree = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (EXCLUDED_DIRS.has(entry.name.toLowerCase()))
+                    continue;
+                countTestTree(full);
+            }
+            else if (entry.isFile()) {
+                classifyFile(full, true);
+            }
+        }
+    };
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const nameLower = entry.name.toLowerCase();
+                if (EXCLUDED_DIRS.has(nameLower))
+                    continue;
+                if (TEST_DIRS.has(nameLower)) {
+                    countTestTree(full);
+                    continue;
+                }
+                walk(full);
+            }
+            else if (entry.isFile()) {
+                classifyFile(full, false);
+            }
+        }
+    };
+    for (const root of roots)
+        walk(root);
+    stats.businessCodeLines = stats.etsLines + stats.cLines + stats.cppLines + stats.testLines;
+    return stats;
+}

package/dist/metrics/analysis/hvigor.d.ts

@@ -37,4 +37,11 @@ export declare function stripAnsi(raw: string): string;
 export declare function extractErrorCodes(stripped: string): ErrorCodeEntry[];
 export declare function extractWarnings(stripped: string): WarningEntry[];
 export declare function extractModuleTimings(stripped: string): Map<string, ModuleTiming>;
+/**
+ * 解析 droid2hmos 包装器（build/test harmony）的摘要输出：包装器内部执行
+ * hvigorw，但按迁移工作台规则 hvigor 原始输出重定向到日志文件，工具输出只有
+ * 状态摘要（status 表：passed/failed）。无 failed 标记视为成功（命令已完成）；
+ * 错误码/告警/模块计时在摘要中不存在，返回空集合。
+ */
+export declare function parseD2hWrapperOutput(raw: string): CompileResult;
 export declare function parseHvigorwOutput(raw: string): CompileResult;

package/dist/metrics/analysis/hvigor.js

@@ -130,6 +130,26 @@ function addTiming(timings, moduleName, taskName, duration) {
         });
     }
 }
+// ─── parseD2hWrapperOutput ──────────────────────────────────────────────────
+/**
+ * 解析 droid2hmos 包装器（build/test harmony）的摘要输出：包装器内部执行
+ * hvigorw，但按迁移工作台规则 hvigor 原始输出重定向到日志文件，工具输出只有
+ * 状态摘要（status 表：passed/failed）。无 failed 标记视为成功（命令已完成）；
+ * 错误码/告警/模块计时在摘要中不存在，返回空集合。
+ */
+export function parseD2hWrapperOutput(raw) {
+    const stripped = stripAnsi(raw).toLowerCase();
+    const failed = /(^|[^a-z])failed([^a-z]|$)/m.test(stripped);
+    return {
+        success: !failed,
+        duration: 0,
+        errorCount: 0,
+        warnCount: 0,
+        errors: [],
+        warnings: [],
+        moduleTimings: new Map(),
+    };
+}
 // ─── parseHvigorwOutput ─────────────────────────────────────────────────────
 export function parseHvigorwOutput(raw) {
     const stripped = stripAnsi(raw);

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, buildRoundSnapshot } from "../snapshot/flush.js";
+import { handleSessionIdle, flushMetrics, buildRoundSnapshot, finalizeRoundWaits } from "../snapshot/flush.js";
 import { clearStepContentCache } from "../snapshot/steps.js";
 import { mergeChildMetrics } from "../snapshot/merge.js";
 import { resolveDirs } from "../dirs.js";
@@ -24,6 +24,70 @@ export function createMetricsEngine(opts = {}) {
     function resolveSessionId(rawId) {
         return childToParent.get(rawId) ?? rawId;
     }
+    /**
+     * 等待事件处理（0.4.1 活跃口径）：
+     * - session.status 限流状态机：retry 记起点，busy/idle 结算本轮挂起时长并计数；
+     * - permission.asked/replied 配对：asked 的键是 `id`、replied 的键是 `requestID`
+     *   （事件源字段名不对称），按 ID 配对差值入本轮；跨轮询问已在轮闭合时截断、条目不存。
+     * 父会话与子代理路由共用（子代理等待同样扣减父轮墙钟）。
+     */
+    function handleSessionWaits(state, event) {
+        const props = event.properties;
+        if (!props)
+            return;
+        if (event.type === "session.status") {
+            const statusType = (props.status?.type);
+            if (statusType === "retry") {
+                // 每次 retry 事件 = 一次限流重试（attempt 递增），直接计数；窗口起点只记首个
+                if (state._retryStartedAt === null)
+                    state._retryStartedAt = Date.now();
+                state._roundRetryCount++;
+                state._checkpointDirty = true;
+            }
+            else if ((statusType === "busy" || statusType === "idle") && state._retryStartedAt !== null) {
+                // busy/idle 恢复：结算本轮挂起时长
+                state._roundRetryMs += Math.max(0, Date.now() - state._retryStartedAt);
+                state._retryStartedAt = null;
+                state._checkpointDirty = true;
+            }
+            return;
+        }
+        if (event.type === "permission.asked") {
+            const id = props.id || props.requestID || "";
+            if (id && !state._pendingPermissionAsks.has(id)) {
+                state._pendingPermissionAsks.set(id, { askedAt: Date.now(), roundStart: state._roundStartTime });
+            }
+            return;
+        }
+        if (event.type === "permission.replied") {
+            const id = props.requestID || props.id || "";
+            const pending = id ? state._pendingPermissionAsks.get(id) : undefined;
+            if (pending) {
+                // 同轮内答复才结算（跨轮的询问已在轮闭合截断入上轮，此处不再双计）
+                if (pending.roundStart === state._roundStartTime) {
+                    state._roundPermissionMs += Math.max(0, Date.now() - pending.askedAt);
+                }
+                state._pendingPermissionAsks.delete(id);
+            }
+        }
+    }
+    /** 子代理 question 工具等待入账（父路径由 handlePartUpdated 累加，此处补子代理路由） */
+    function handleSubAgentQuestionWait(state, props) {
+        const part = props?.part;
+        if (!part || part.type !== "tool" || part.tool !== "question")
+            return;
+        const toolState = part.state;
+        if (toolState?.status !== "completed")
+            return;
+        const time = toolState.time;
+        const callID = part.callID;
+        if (!time?.start || !time?.end || !callID)
+            return;
+        if (state._questionCountedCallIds.has(callID))
+            return;
+        state._questionCountedCallIds.add(callID);
+        state._roundQuestionMs += time.end - time.start;
+    }
     function extractSessionId(event) {
         const props = event.properties;
         if (!props) {
@@ -92,6 +156,7 @@ export function createMetricsEngine(opts = {}) {
     function finalizeAndFlush(sessionId, state, now) {
         // 兜底补轮：退出/删除前最后一次交互往往等不到 session.idle（约 1 分钟静止判定），
         // 此处把未闭合的非空轮收掉（空轮返回 null，已 idle 过的轮累计已重置、同样为 null，天然防重）
+        finalizeRoundWaits(state, now);
         const pendingRound = buildRoundSnapshot(state, now);
         if (pendingRound)
             state.rounds.push(pendingRound);
@@ -189,6 +254,11 @@ export function createMetricsEngine(opts = {}) {
             if (childSessionIds.has(originalSessionId)) {
                 const sub = state.subAgents.get(originalSessionId);
                 if (sub) {
+                    // 子代理的限流/权限/question 等待同样扣减父轮墙钟（0.4.1 活跃口径）
+                    handleSessionWaits(state, event);
+                    if (event.type === "message.part.updated") {
+                        handleSubAgentQuestionWait(state, props);
+                    }
                     handleSubAgentParts(sub, event);
                     // 子代理的完整回复/单步结束：置脏父会话
                     if (event.type === "message.updated" ||
@@ -264,6 +334,8 @@ export function createMetricsEngine(opts = {}) {
                     state.anomaly.events.push(event.type);
                 }
             }
+            // 限流挂起/权限审批等待配对（0.4.1 活跃口径）
+            handleSessionWaits(state, event);
             // 统一的 checkpoint 判定点
             evaluateCheckpoint(sessionId, state);
         },

package/dist/metrics/engine/handlers.js

@@ -1,6 +1,7 @@
 import { createTokenUsage } from "../types.js";
-import { parseHvigorwOutput } from "../analysis/hvigor.js";
-import { buildRoundSnapshot, resetRoundState } from "../snapshot/flush.js";
+import { parseHvigorwOutput, parseD2hWrapperOutput } from "../analysis/hvigor.js";
+import { buildRoundSnapshot, resetRoundState, finalizeRoundWaits } from "../snapshot/flush.js";
+import * as path from "node:path";
 // ─── Input Simplification ────────────────────────────────────────────────────
 function simplifyInput(raw) {
     if (!raw)
@@ -12,6 +13,29 @@ function simplifyInput(raw) {
     }
     return result;
 }
+/**
+ * 收集代码行扫描的根候选：bash 工具的 workdir、write/edit 工具的文件目录。
+ * flush 时由 refreshCodeLineStats 汇总（连同会话工作目录）做工程根发现。
+ */
+function recordCodeRootCandidate(state, tool, input) {
+    try {
+        if (tool === "bash") {
+            const workdir = input?.workdir;
+            if (typeof workdir === "string" && workdir)
+                state.codeRootCandidates.add(workdir);
+            return;
+        }
+        if (tool === "write" || tool === "edit") {
+            const filePath = input?.filePath || input?.path;
+            if (typeof filePath === "string" && filePath.includes(path.sep)) {
+                state.codeRootCandidates.add(path.dirname(filePath));
+            }
+        }
+    }
+    catch {
+        // 候选收集失败不影响主流程
+    }
+}
 // ─── Invalid Tool Detection ──────────────────────────────────────────────────
 function isInvalidTool(part) {
     if (part.tool === "invalid")
@@ -109,6 +133,7 @@ function handlePartUpdated(state, props) {
                 endMs: 0,
                 parentMsgId,
             });
+            recordCodeRootCandidate(state, part.tool || "", simplifyInput(rawInput));
         }
         if (status === "completed" || status === "error") {
             const tc = existingEntry || {
@@ -130,7 +155,9 @@ function handlePartUpdated(state, props) {
             tc.outputPreview = typeof output === "string" ? output.slice(0, 500) : "";
             // Update input if available
             if (toolState?.input && Object.keys(toolState.input).length > 0) {
-                Object.assign(tc.input, simplifyInput(toolState.input));
+                const mergedInput = simplifyInput(toolState.input);
+                Object.assign(tc.input, mergedInput);
+                recordCodeRootCandidate(state, tc.tool, mergedInput);
             }
             state.toolCallMap.set(callID, tc);
         }
@@ -150,6 +177,10 @@ function handlePartUpdated(state, props) {
             const duration = time && time.start && time.end
                 ? (time.end - time.start)
                 : 0;
+            // question 工具等待用户回答：time 窗口即等待时长（0.4.1 活跃口径扣减项）
+            if (toolName === "question" && time && time.start && time.end) {
+                state._roundQuestionMs += time.end - time.start;
+            }
             // Update distribution
             const stats = state.tools.distribution.get(toolName) ?? { calls: 0, errors: 0, totalDuration: 0, maxDuration: 0 };
             stats.calls++;
@@ -173,11 +204,17 @@ function handlePartUpdated(state, props) {
         // Compile stats extraction (with dedup)
         if (part.tool === "bash") {
             const command = state.toolCallMap.get(callID)?.input?.command || "";
-            if (command.includes("hvigorw")) {
+            // droid2hmos 包装器（build/test harmony）内部执行 hvigorw：命令行不含
+            // "hvigorw"、输出只有状态摘要（hvigor 原始输出被重定向到日志文件），
+            // 按命令形态识别为 HarmonyOS 构建调用
+            const isD2hHarmonyBuild = /\bdroid2hmos(?:\.(?:cmd|exe|bat|ps1))?\s+(?:build|test)\s+harmony\b/.test(command);
+            if (command.includes("hvigorw") || isD2hHarmonyBuild) {
                 if (status === "completed" && !alreadyCompleted) {
                     state.compileStats.hvigorwCalls++;
                     const output = toolState?.output || "";
-                    const result = parseHvigorwOutput(output);
+                    const result = command.includes("hvigorw")
+                        ? parseHvigorwOutput(output)
+                        : parseD2hWrapperOutput(output);
                     state.compileStats.lastBuildSuccess = result.success;
                     // First build per round
                     if (!state._roundFirstBuildTracked) {
@@ -252,16 +289,8 @@ function handlePartUpdated(state, props) {
                 }
             }
         }
-        if (part.tool === "write" && !alreadyCompleted) {
-            const entry = state.toolCallMap.get(callID);
-            const filePath = entry?.input?.filePath || entry?.input?.path || "";
-            if (filePath.endsWith(".ets") && status === "completed") {
-                const content = entry?.input?.content;
-                if (content) {
-                    state.compileStats.etsLines += content.split("\n").filter(l => l.length > 0).length;
-                }
-            }
-        }
+        // （0.4.2 起 etsLines 等代码行维度改由 flush 时工程全量扫描产出，
+        //  不再对 write 工具内容做累计——见 analysis/codelines.ts 口径说明）
         // Fix cycle: count code changes
         if ((part.tool === "write" || part.tool === "edit") && status === "completed") {
             if (state.compileStats._pendingFix) {
@@ -477,6 +506,7 @@ function handleMessageUpdated(state, props) {
             // 新用户消息 = 天然轮边界：先收掉当前非空轮（不再等 idle 静止判定），
             // 快速连发多条不再被合并进同一轮；resume 重放期间轮累计为空，
             // buildRoundSnapshot 返回 null 无副作用，重放结束后首条真实消息正常开新轮
+            finalizeRoundWaits(state, Date.now());
             const round = buildRoundSnapshot(state, Date.now());
             if (round) {
                 state.rounds.push(round);

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

@@ -1,4 +1,5 @@
 import type { MessageEntry, PlanningCall, RoundSnapshot, SkillCallEntry, SkillSearchEntry, TokenUsage, ToolCallEntry, SessionMeta, CompileStats, StageInfo, ToolStats } from "../types.js";
+import type { CodeLineStats } from "../analysis/codelines.js";
 export interface SubAgentState {
     sessionId: string;
     agentName: string;
@@ -113,6 +114,23 @@ export interface SessionMetricsState {
     _roundTokens: TokenUsage;
     _roundToolCalls: number;
     _roundErrors: number;
+    /** 本轮 question 工具等待用户累计（ms，0.4.1 活跃口径） */
+    _roundQuestionMs: number;
+    /** 本轮权限审批等待累计（ms） */
+    _roundPermissionMs: number;
+    /** 本轮限流重试挂起累计（ms） */
+    _roundRetryMs: number;
+    /** 本轮限流重试次数 */
+    _roundRetryCount: number;
+    /** 已问未答的权限请求：requestID → 询问时刻与所属轮起点（轮闭合时截断结算后移除） */
+    _pendingPermissionAsks: Map<string, {
+        askedAt: number;
+        roundStart: number;
+    }>;
+    /** 限流挂起起点（session.status retry 起始时刻）；null = 未挂起 */
+    _retryStartedAt: number | null;
+    /** 已入账 question 等待的 callID（子代理路径去重用；父路径由 toolCallMap 去重） */
+    _questionCountedCallIds: Set<string>;
     _roundFirstBuildTracked: boolean;
     _roundIdleProcessed: boolean;
     _idleFlushed: boolean;
@@ -120,6 +138,14 @@ export interface SessionMetricsState {
     _checkpointDirty: boolean;
     /** 上次 flush 的累加字段基线；null = 尚未 flush 过 */
     _flushBaseline: FlushBaseline | null;
+    /** 最近一次扫描结果（flush 时按 30s 节流刷新；见 flush.ts refreshCodeLineStats） */
+    codeLines: CodeLineStats;
+    /** 根候选：bash workdir 与 write/edit 文件目录（工作目录取 sessionMeta） */
+    codeRootCandidates: Set<string>;
+    /** 最近一次代码行扫描时刻（ms） */
+    _lastCodeScanAt: number;
+    /** 最近一次扫描时的候选集合签名（变化即重扫） */
+    _codeScanRootsKey: string;
     messageMap: Map<string, MessageEntry>;
     toolCallMap: Map<string, ToolCallEntry>;
     textLengthMap: Map<string, number>;

package/dist/metrics/engine/state.js

@@ -50,7 +50,6 @@ export function createSessionMetrics(sessionId) {
             hvigorwCalls: 0,
             hvigorwErrors: 0,
             lastBuildSuccess: false,
-            etsLines: 0,
             firstBuildPerRound: [],
             errorCodes: new Map(),
             fixCycles: [],
@@ -58,6 +57,10 @@ export function createSessionMetrics(sessionId) {
             warnings: new Map(),
             moduleTimings: new Map(),
         },
+        codeLines: { etsLines: 0, cLines: 0, cppLines: 0, testLines: 0, businessCodeLines: 0 },
+        codeRootCandidates: new Set(),
+        _lastCodeScanAt: 0,
+        _codeScanRootsKey: "",
         orderCounter: 0,
         skillCallMap: new Map(),
         htmlPreviewMsgId: null,
@@ -75,6 +78,13 @@ export function createSessionMetrics(sessionId) {
         _roundTokens: createTokenUsage(),
         _roundToolCalls: 0,
         _roundErrors: 0,
+        _roundQuestionMs: 0,
+        _roundPermissionMs: 0,
+        _roundRetryMs: 0,
+        _roundRetryCount: 0,
+        _pendingPermissionAsks: new Map(),
+        _retryStartedAt: null,
+        _questionCountedCallIds: new Set(),
         _roundFirstBuildTracked: false,
         _roundIdleProcessed: false,
         _idleFlushed: false,

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     静默下限（毫秒）

package/dist/metrics/upload/uploadManager.js

@@ -353,11 +353,17 @@ function dedupePaths(paths) {
  * 启动清扫暂存目录顶层：崩溃遗留的完整三件套（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             可补偿重传的包列表（顶层遗留部分）
  */
-function sweepStagingDirectory(stagingDir, rescueEnabled) {
+export function sweepStagingDirectory(stagingDir, rescueEnabled) {
     const rescued = [];
     try {
         const entries = fs.readdirSync(stagingDir);
@@ -365,26 +371,31 @@ function sweepStagingDirectory(stagingDir, rescueEnabled) {
         const handled = new Set(["failed"]);
         let removed = 0;
         const removedNames = [];
+        // 第一遍：.tar.gz 三件套判定（必须先于 .json 清理，见函数注释）
         for (const entry of entries) {
             if (handled.has(entry))
                 continue;
-            if (entry.endsWith(".tar.gz")) {
-                const base = entry.slice(0, -".tar.gz".length);
-                const pkg = rescueEnabled ? loadIntactPackage(stagingDir, base, names) : undefined;
-                if (pkg) {
-                    movePackageIntoFailed(stagingDir, pkg, path.join(stagingDir, `${base}.meta.json`));
-                    rescued.push(pkg);
-                }
-                else {
-                    fs.rmSync(path.join(stagingDir, entry), { force: true });
-                    removed++;
-                    removedNames.push(entry);
-                }
-                handled.add(entry);
-                handled.add(`${base}.json`);
-                handled.add(`${base}.meta.json`);
+            if (!entry.endsWith(".tar.gz"))
                 continue;
+            const base = entry.slice(0, -".tar.gz".length);
+            const pkg = rescueEnabled ? loadIntactPackage(stagingDir, base, names) : undefined;
+            if (pkg) {
+                movePackageIntoFailed(stagingDir, pkg, path.join(stagingDir, `${base}.meta.json`));
+                rescued.push(pkg);
+            }
+            else {
+                fs.rmSync(path.join(stagingDir, entry), { force: true });
+                removed++;
+                removedNames.push(entry);
             }
+            handled.add(entry);
+            handled.add(`${base}.json`);
+            handled.add(`${base}.meta.json`);
+        }
+        // 第二遍：清理剩余孤儿（无对应 tar.gz 的快照副本/meta、组装残留目录）
+        for (const entry of entries) {
+            if (handled.has(entry))
+                continue;
             if (entry.endsWith(".json") || entry.startsWith(".assembly-")) {
                 fs.rmSync(path.join(stagingDir, entry), { recursive: true, force: true });
                 removed++;
@@ -560,6 +571,8 @@ function removeQuietly(filePath) {
 // ─── 孤儿快照补传（§13 失败补偿链路） ─────────────────────────────────────────
 /** 已传终态标记目录名（metrics/.sent/<sessionId>） */
 const SENT_MARKER_DIR = ".sent";
+/** 已传标记时效缓冲：快照 mtime 超出标记时间该值仍视为"标记后更新过"需补传 */
+const SENT_NEWER_GRACE_MS = 60_000;
 /**
  * 记录会话终态包已成功上云。
  * 快照原件（metrics/<sessionId>.json）会永久保留为本地记录，
@@ -578,9 +591,23 @@ export function markSessionUploaded(metricsDir, sessionId) {
 export function isSessionUploaded(metricsDir, sessionId) {
     return fs.existsSync(path.join(metricsDir, SENT_MARKER_DIR, sessionId));
 }
+/** 读取已传标记时间戳（内容为上传完成时刻的毫秒值）；无标记/内容非法返回 null */
+function sentTimestamp(metricsDir, sessionId) {
+    try {
+        const content = fs.readFileSync(path.join(metricsDir, SENT_MARKER_DIR, sessionId), "utf-8").trim();
+        const time = Number(content);
+        return Number.isFinite(time) && time > 0 ? time : null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * 扫描目录选出孤儿快照候选：mtime 静默 [idleMs, maxAgeMs] 且不在活跃集的快照。
- * 上传成功后快照即被删除，"文件仍在"天然等价于"终态未传出"。
+ * 快照原件永久保留为本地记录，"已传标记"是防重复上传的依据。
+ * 时效判断：标记只证明"标记时刻之前的快照已上云"——会话在中途终态触发
+ * （task 完成/session.deleted）上传后仍可能继续运行并更新快照，因此快照
+ * mtime 晚于标记时间（超出 60s 缓冲）仍视为孤儿，补传最终态。
  *
  * @param metricsDir 快照目录
  * @param idleMs     静默下限（毫秒）
@@ -602,11 +629,14 @@ export async function selectOrphanSnapshots(metricsDir, idleMs, maxAgeMs, isActi
         if (!entry.endsWith(".json"))
             continue;
         const sessionId = entry.slice(0, -".json".length);
-        if (isSessionUploaded(metricsDir, sessionId))
-            continue;
         const filePath = path.join(metricsDir, entry);
         try {
             const stats = await fs.promises.stat(filePath);
+            // 已传标记时效判断：标记只证明"标记时刻之前的快照已上云"，快照 mtime
+            // 晚于标记时间（超出 60s 缓冲）说明会话其后仍更新过，最终态未上云，仍补传
+            const sentAt = sentTimestamp(metricsDir, sessionId);
+            if (sentAt !== null && stats.mtimeMs <= sentAt + SENT_NEWER_GRACE_MS)
+                continue;
             const age = now - stats.mtimeMs;
             if (age < idleMs || age > maxAgeMs)
                 continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-metrics-plugin",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "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",