opencode-metrics-plugin 0.3.5 → 0.4.2

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # 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-00-orchestrator"] }]`，实现「插件处处加载、只统计迁移 agent 的会话」，不受 opencode 项目级配置发现的 git 边界限制。注意项目 `.opencode/opencode-metrics.json(c)` 存在时仍会完全接管（含 `agents`），接管文件需同步配置。
+
 ## 0.3.5（2026-09-15）
 
 - 修复「重启 + resume 续跑」系列数据损坏：steps 重复乱序、planning 清零、tokens/工具统计丢段、agent/model 归因丢失；累加字段改差量并入，连发消息即切轮、退出兜底补轮。

package/README.md

@@ -90,6 +90,7 @@
 | 选项 | 类型 | 默认 | 说明 |
 |---|---|---|---|
 | `enabled` | boolean | `true` | 总开关，`false` 时不记录任何会话 |
+| `agents` | string[] | — | 会话 agent 白名单（`*` 通配，如 `["android-to-hmos-*", "build"]`）：根会话 agent 命中才记录（快照/事件日志/上传全不产生），子会话随父判定；缺省全记 |
 | `eventLogging` | boolean | `true` | 原始事件写盘；关闭后快照仍生成，但 `steps[].text/reasoning` 为空 |
 | `checkpointFlushIntervalMs` | number | `2000` | 实时落盘冷却窗口（ms），`0` 关闭退回只在会话空闲时落盘 |
 | `dirs` | object | env-paths | `metricsDir` / `eventsDir` / `logFile`（基准，实际写 `<所在目录>/log/plugin/YYYYMMDD.log`）/ `uploadStagingDir` |

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,