@zhuan-ai/zhuanspec 2.16.2 → 2.16.4

package/dist/core/hooks/record-progress.js

@@ -9,10 +9,11 @@
 import path from 'path';
 import { promises as fsPromises, existsSync, readFileSync, unlinkSync } from 'fs';
 import { FileSystemUtils } from '../../utils/file-system.js';
-import { PHASE_ORDER } from '../../utils/phase-utils.js';
+import { PHASE_ORDER, PHASE_IDLE_THRESHOLD_MS } from '../../utils/phase-utils.js';
 import { resolveZhuanSpecRoot } from '../../utils/resolve-root.js';
-import { isCodeFile, isTrackedFileForPhase, getOrCreatePhaseBucket, recomputeAccuracyRate, persistAccuracyJson, appendAccuracyDebugLog } from '../metrics/code-accuracy.js';
+import { isCodeFile, isTrackedFileForPhase, getOrCreatePhaseBucket, recomputeAccuracyRate, persistAccuracyJson, appendAccuracyDebugLog, isReviewAutoFixActive, isMeaningfulUserCorrection, isTrivialAckPrompt, computePromptFileMaxLines } from '../metrics/code-accuracy.js';
 import { detectHookHost, sanitizeCodexEnvelope } from '../../utils/hook-host.js';
+import { countLineDiff } from '../../utils/line-diff.js';
 const fs = fsPromises;
 /**
  * Atomic write JSON file: write to temp file first, then rename
@@ -116,6 +117,10 @@ export async function recoverProgressJsonForWrite(filePath) {
                         durationMs: 0,
                         taskCount: 0,
                         completedTaskCount: 0,
+                        wallClockMs: 0,
+                        idleMs: 0,
+                        lastActiveAt: '',
+                        _lastActiveEpoch: 0,
                     }],
                 stats: { tokenUsageTotal: 0, contextLoad: 0, durationMs: { techDesign: 0, propose: 0, apply: 0, review: 0, archive: 0 } },
             };
@@ -163,6 +168,69 @@ export function getBeijingTimeForFilename() {
     const seconds = String(beijingTime.getSeconds()).padStart(2, '0');
     return `${year}-${month}-${day} ${hours}-${minutes}-${seconds}`;
 }
+/**
+ * v2.16+ 活跃耗时累加器
+ *
+ * 每次 PostToolUse 心跳到达时调用，根据 gap = now - lastActiveAt 判断：
+ *   gap < PHASE_IDLE_THRESHOLD_MS → 活跃，累加到 durationMs
+ *   gap >= PHASE_IDLE_THRESHOLD_MS → 空闲，累加到 idleMs 并 push idleSegments
+ *
+ * 同步刷新 wallClockMs、lastActiveAt、lastUpdatedAt。
+ * 返回本次增量便于调用方决定是否刷新 stats。
+ */
+export function tickActivePhaseDuration(entry, nowEpoch = Date.now(), nowTimestamp = getBeijingTime()) {
+    // 初始化可选字段
+    if (entry.idleMs === undefined)
+        entry.idleMs = 0;
+    if (entry.wallClockMs === undefined)
+        entry.wallClockMs = 0;
+    const parse = (s) => {
+        if (!s)
+            return null;
+        const ms = new Date(s.replace(' ', 'T')).getTime();
+        return Number.isFinite(ms) ? ms : null;
+    };
+    // 优先使用毫秒级 epoch（精确），fallback 到秒级字符串解析（兼容老数据）
+    const lastTickStr = entry.lastActiveAt || entry.lastUpdatedAt || entry.startedAt;
+    const lastTickEpoch = entry._lastActiveEpoch ?? parse(lastTickStr);
+    const startEpoch = parse(entry.startedAt);
+    // 无法解析时间 → 仅刷新心跳时间
+    if (lastTickEpoch == null || startEpoch == null) {
+        entry.lastActiveAt = nowTimestamp;
+        entry.lastUpdatedAt = nowTimestamp;
+        entry._lastActiveEpoch = nowEpoch;
+        return { activeDelta: 0, idleDelta: 0 };
+    }
+    const gap = nowEpoch - lastTickEpoch;
+    let activeDelta = 0;
+    let idleDelta = 0;
+    if (gap > 0) {
+        if (gap < PHASE_IDLE_THRESHOLD_MS) {
+            // 活跃：累加到 durationMs
+            activeDelta = gap;
+            entry.durationMs = (entry.durationMs || 0) + gap;
+        }
+        else {
+            // 空闲：累加到 idleMs + 记录段
+            idleDelta = gap;
+            entry.idleMs = (entry.idleMs || 0) + gap;
+            entry.idleSegments = entry.idleSegments || [];
+            entry.idleSegments.push({
+                from: lastTickStr,
+                to: nowTimestamp,
+                durationMs: gap,
+            });
+        }
+    }
+    // 刷新 wallClockMs = now - startedAt
+    const wall = nowEpoch - startEpoch;
+    entry.wallClockMs = wall > 0 ? wall : (entry.wallClockMs || 0);
+    // 刷新心跳（字符串 + epoch 双写，epoch 用于下次 tick 精确计算）
+    entry.lastActiveAt = nowTimestamp;
+    entry.lastUpdatedAt = nowTimestamp;
+    entry._lastActiveEpoch = nowEpoch;
+    return { activeDelta, idleDelta };
+}
 export async function recordProgressHook(options) {
     // Read stdin for Claude Code hook input
     let stdinData = {};
@@ -420,6 +488,20 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
             if (progress.stats.durationMs.techDesign === undefined) {
                 progress.stats.durationMs.techDesign = 0;
             }
+            // v2.16+ 迁移：老 progress.json 的 phaseDurations entry 缺少 wallClockMs/idleMs/lastActiveAt
+            for (const entry of progress.phaseDurations) {
+                if (entry.wallClockMs === undefined) {
+                    // 老版本 durationMs 是墙钟差，复制到 wallClockMs，durationMs 保留作为活跃近似
+                    entry.wallClockMs = entry.durationMs || 0;
+                }
+                if (entry.idleMs === undefined) {
+                    entry.idleMs = 0;
+                }
+                if (!entry.lastActiveAt) {
+                    // 进行中 entry 用 lastUpdatedAt 兆底，已结束用 endedAt
+                    entry.lastActiveAt = entry.endedAt || entry.lastUpdatedAt || entry.startedAt;
+                }
+            }
         }
         else {
             progress = createNewProgress(changeId);
@@ -618,6 +700,11 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
     const toolInputOldString = stdinData.tool_input?.old_string;
     const toolInputEdits = stdinData.tool_input?.edits;
     // 按工具类型计算本次变更涉及的行数
+    // 口径：
+    //   Write    → 全文行数（无旧本可参考，以完整写入量为准）
+    //   Edit     → countLineDiff(old, new)：仅计增+删净改动行（不含上下文锚点）
+    //   MultiEdit → 多个 edit 的 diff 累加
+    // 此口径对 techDesign / propose / apply / review 四阶段统一生效（均走 isTrackedFileForPhase 白名单）
     let changeLines = 0;
     let contentSource = 'none';
     if (toolName === 'Write') {
@@ -627,17 +714,14 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
         }
     }
     else if (toolName === 'Edit') {
-        const newLines = toolInputNewString ? toolInputNewString.split('\n').length : 0;
-        const oldLines = toolInputOldString ? toolInputOldString.split('\n').length : 0;
-        // 取 max(new, old)：体现本次编辑触及的代码量，兼容纯新增/纯删除/替换
-        changeLines = Math.max(newLines, oldLines);
+        // 以前：Math.max(newLines, oldLines) — 含上下文锚点，虚高计数
+        // 现在：只计真正变动的行（增+删），跳过未变上下文
+        changeLines = countLineDiff(toolInputOldString, toolInputNewString);
         contentSource = (toolInputNewString || toolInputOldString) ? 'new_string' : 'none';
     }
     else if (toolName === 'MultiEdit' && Array.isArray(toolInputEdits)) {
         for (const edit of toolInputEdits) {
-            const newLines = edit?.new_string ? edit.new_string.split('\n').length : 0;
-            const oldLines = edit?.old_string ? edit.old_string.split('\n').length : 0;
-            changeLines += Math.max(newLines, oldLines);
+            changeLines += countLineDiff(edit?.old_string, edit?.new_string);
         }
         contentSource = toolInputEdits.length > 0 ? 'edits[]' : 'none';
     }
@@ -719,40 +803,30 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
                     correctionEdits: [], phaseAccuracy: [],
                 };
             }
-            const bucket = getOrCreatePhaseBucket(progress, trackedPhase, trackedKind);
-            if (inCorrectionContext) {
-                // 工具白名单守卫：techDesign / propose 阶段的纠偏统计只接受增量编辑（Edit/MultiEdit），
-                // 禁止 Write。原因：tech-spec.md / proposal.md 通常是整文件 Write 产出，一旦被误判为纠偏，
-                // 会把整份文件行数当成 userCorrectionLines 记入，导致分子被严重放大、accuracyRate 失真。
-                // apply / review 阶段不受此限制（apply 可 Write 新增代码文件，review-report.md 也常由 Write 生成）。
-                if ((trackedPhase === 'techDesign' || trackedPhase === 'propose') && toolName === 'Write') {
-                    correctionDebugLog(`skipped/write-blocked-${trackedPhase}-correction`, 'skipped', 0);
-                    appendAccuracyDebugLog(changeDir, {
-                        type: `skip.write-blocked-${trackedPhase}-correction`,
-                        phase: trackedPhase,
-                        kind: trackedKind,
-                        trigger: 'hook',
-                        changeId,
-                        skipReason: `write-blocked-${trackedPhase}-correction`,
-                        input: { tool: toolName, file: filePath, changeLines },
-                    });
-                }
-                else {
-                    // 纠偏上下文：桶 + 顶层 userCorrectionLines 同步累加
-                    bucket.userCorrectionLines += changeLines;
-                    bucket.lastUpdatedAt = timestamp;
-                    progress.accuracy.userCorrectionLines = (progress.accuracy.userCorrectionLines || 0) + changeLines;
-                    progress.accuracy.correctionEdits = progress.accuracy.correctionEdits || [];
-                    // 提取纠偏触发源头信息（Task 6）
-                    // post-baseline-fallback 兜底命中时，语义等价于 user-input hook 写入的 'post-baseline-prompt'。
+            // === Review 阶段特殊处理 ===
+            // 规则：
+            //   1. CR/单测 Skill 自动修复 → 不计入准确率（完全跳过）
+            //   2. 用户提示词触发的纠正 → 归属到 apply 阶段的准确率桶
+            //   3. review 阶段不产生独立的准确率 bucket
+            //
+            // 用户提示词识别（与 apply 阶段一致）：
+            //   - correction-keyword：命中显式纠偏关键词（"不对"、"应该是"等）
+            //   - post-baseline-prompt + 非琐碎确认：baseline 后的任何用户提示，
+            //     只要 promptSnippet 不是"继续"、"好的"等琐碎确认词。
+            //     斜杠/感叹号命令（/zhuanspec:、!ls）已在 user-input-hook 过滤。
+            //   - .pending-correction marker 存在
+            //
+            // 自动修复 = 最近有 review autofix skill 调用（code-review-expert / generate-mockito-unit-test）
+            if (trackedPhase === 'review') {
+                // 判断是否为用户提示词触发的纠正
+                const meaningfulCC = isMeaningfulUserCorrection(progress.correctionContext ?? undefined);
+                const isExplicitUserCorrection = (ccActiveRaw && meaningfulCC) || pendingExists;
+                if (isExplicitUserCorrection) {
+                    // 用户在 review 阶段的纠正 → 归到 apply/code bucket，影响 apply 准确率
+                    const applyBucket = getOrCreatePhaseBucket(progress, 'apply', trackedKind);
+                    // 提取纠偏触发源头信息
                     const ccSource = progress.correctionContext?.source
-                        || (pendingExists
-                            ? 'pending-correction-marker'
-                            : (correctionFallbackReason === 'post-baseline-fallback'
-                                ? 'post-baseline-prompt'
-                                : 'correction-keyword'));
-                    // Task 6：若 correctionContext 无 prompt 元数据（典型于 pending-correction-marker 兑底路径），
-                    // 从 .pending-correction marker JSON 中回填 promptId / phaseInputIndex / promptSnippet。
+                        || (pendingExists ? 'pending-correction-marker' : 'correction-keyword');
                     let fallbackPromptId;
                     let fallbackPromptIndex;
                     let fallbackPromptSnippet;
@@ -773,6 +847,13 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
                     const promptId = progress.correctionContext?.promptId ?? fallbackPromptId;
                     const promptIndex = progress.correctionContext?.promptIndex ?? fallbackPromptIndex;
                     const promptSnippet = progress.correctionContext?.promptSnippet ?? fallbackPromptSnippet;
+                    // 去重：同 (promptId + filePath + apply phase) 取历史 max，只累加 delta
+                    progress.accuracy.correctionEdits = progress.accuracy.correctionEdits || [];
+                    const prevMax = computePromptFileMaxLines(progress.accuracy.correctionEdits, promptId, filePath, 'apply');
+                    const dedupDelta = Math.max(0, changeLines - prevMax);
+                    applyBucket.userCorrectionLines += dedupDelta;
+                    applyBucket.lastUpdatedAt = timestamp;
+                    progress.accuracy.userCorrectionLines = (progress.accuracy.userCorrectionLines || 0) + dedupDelta;
                     progress.accuracy.correctionEdits.push({
                         filePath,
                         editLines: changeLines,
@@ -780,7 +861,7 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
                         strategy: 'correction-context',
                         agentType: progress.correctionContext?.path,
                         timestamp,
-                        phase: trackedPhase,
+                        phase: 'apply', // 归属到 apply（非 review）
                         trackedKind,
                         triggeredBy: {
                             source: ccSource,
@@ -789,14 +870,14 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
                             promptSnippet,
                         },
                     });
-                    // 记录 phase 维度 promptId（去重）
-                    if (promptId && !bucket.correctionPromptIds.includes(promptId)) {
-                        bucket.correctionPromptIds.push(promptId);
+                    // 记录 apply bucket 的 promptId（去重）
+                    if (promptId && !applyBucket.correctionPromptIds.includes(promptId)) {
+                        applyBucket.correctionPromptIds.push(promptId);
                     }
-                    correctionDebugLog(`${toolName}/correction`, 'userCorrectionLines', changeLines);
+                    correctionDebugLog(`${toolName}/review-user-correction→apply`, 'userCorrectionLines', dedupDelta);
                     appendAccuracyDebugLog(changeDir, {
                         type: 'correction.record',
-                        phase: trackedPhase,
+                        phase: 'apply', // 归属到 apply
                         kind: trackedKind,
                         trigger: 'hook',
                         changeId,
@@ -805,39 +886,183 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
                             file: filePath,
                             changeLines,
                             contentSource,
+                            actualPhase: 'review',
+                            redirectedTo: 'apply',
                             ccSource,
                             promptId,
                             promptIndex,
+                            prevMax,
+                            dedupDelta,
                         },
                         output: {
-                            bucketCorrection: bucket.userCorrectionLines,
+                            bucketCorrection: applyBucket.userCorrectionLines,
                             topCorrection: progress.accuracy.userCorrectionLines,
-                            promptIdsCount: bucket.correctionPromptIds.length,
+                            promptIdsCount: applyBucket.correctionPromptIds.length,
                         },
                     });
                 }
+                else {
+                    // 非用户提示词触发 → review 阶段自动修复、琐碎确认后的编辑、或 baseline fallback
+                    // 判断是否为 Skill 自动修复（CR/单测）
+                    const isAutoFix = isReviewAutoFixActive(progress.skillCalls || [], progress.correctionContext ?? undefined);
+                    const ccSourceRaw = progress.correctionContext?.source;
+                    const ccPromptSnippet = progress.correctionContext?.promptSnippet;
+                    const ccTrivialAck = ccSourceRaw === 'post-baseline-prompt'
+                        && isTrivialAckPrompt(ccPromptSnippet);
+                    const skipReason = isAutoFix
+                        ? 'review-skill-autofix'
+                        : (ccTrivialAck ? 'review-trivial-ack' : 'review-non-correction');
+                    correctionDebugLog(`skipped/${skipReason}`, 'skipped', 0);
+                    appendAccuracyDebugLog(changeDir, {
+                        type: `skip.${skipReason}`,
+                        phase: trackedPhase,
+                        kind: trackedKind,
+                        trigger: 'hook',
+                        changeId,
+                        skipReason,
+                        input: {
+                            tool: toolName,
+                            file: filePath,
+                            changeLines,
+                            inCorrectionContext,
+                            baselineMarkedForPhase,
+                            ccActiveRaw,
+                            ccSource: ccSourceRaw,
+                            ccTrivialAck,
+                            isAutoFix,
+                        },
+                    });
+                    // review 阶段自动修复、琐碎确认、非纠正编辑都完全跳过准确率统计
+                }
             }
             else {
-                // 正常 AI 产出：桶 + 顶层 aiLinesAdded/aiTotalLines 同步累加，同时顶层 progress.linesAdded 仍需累加以兼容旧逻辑
-                bucket.aiLinesAdded += changeLines;
-                bucket.aiTotalLines += changeLines;
-                bucket.lastUpdatedAt = timestamp;
-                progress.accuracy.aiLinesAdded = (progress.accuracy.aiLinesAdded || 0) + changeLines;
-                progress.accuracy.aiTotalLines = (progress.accuracy.aiTotalLines || 0) + changeLines;
-                progress.linesAdded += changeLines;
-                correctionDebugLog(`${toolName}/normal`, 'linesAdded', changeLines);
-                appendAccuracyDebugLog(changeDir, {
-                    type: 'ai.record',
-                    phase: trackedPhase,
-                    kind: trackedKind,
-                    trigger: 'hook',
-                    changeId,
-                    input: { tool: toolName, file: filePath, changeLines, contentSource },
-                    output: {
-                        bucketAiTotal: bucket.aiTotalLines,
-                        topAiTotal: progress.accuracy.aiTotalLines,
-                    },
-                });
+                // === 非 review 阶段：原有逻辑 ===
+                const bucket = getOrCreatePhaseBucket(progress, trackedPhase, trackedKind);
+                if (inCorrectionContext) {
+                    // 工具白名单守卫：techDesign / propose 阶段的纠偏统计只接受增量编辑（Edit/MultiEdit），
+                    // 禁止 Write。原因：tech-spec.md / proposal.md 通常是整文件 Write 产出，一旦被误判为纠偏，
+                    // 会把整份文件行数当成 userCorrectionLines 记入，导致分子被严重放大、accuracyRate 失真。
+                    // apply 阶段不受此限制（apply 可 Write 新增代码文件）。
+                    if ((trackedPhase === 'techDesign' || trackedPhase === 'propose') && toolName === 'Write') {
+                        correctionDebugLog(`skipped/write-blocked-${trackedPhase}-correction`, 'skipped', 0);
+                        appendAccuracyDebugLog(changeDir, {
+                            type: `skip.write-blocked-${trackedPhase}-correction`,
+                            phase: trackedPhase,
+                            kind: trackedKind,
+                            trigger: 'hook',
+                            changeId,
+                            skipReason: `write-blocked-${trackedPhase}-correction`,
+                            input: { tool: toolName, file: filePath, changeLines },
+                        });
+                    }
+                    else {
+                        // 纠偏上下文：提取 promptId，同 (promptId+file+phase) 取 max 计算 delta，桶 + 顶层 userCorrectionLines 同步累加 delta
+                        // 提取纠偏触发源头信息（Task 6）
+                        // post-baseline-fallback 兜底命中时，语义等价于 user-input hook 写入的 'post-baseline-prompt'。
+                        const ccSource = progress.correctionContext?.source
+                            || (pendingExists
+                                ? 'pending-correction-marker'
+                                : (correctionFallbackReason === 'post-baseline-fallback'
+                                    ? 'post-baseline-prompt'
+                                    : 'correction-keyword'));
+                        // Task 6：若 correctionContext 无 prompt 元数据（典型于 pending-correction-marker 兑底路径），
+                        // 从 .pending-correction marker JSON 中回填 promptId / phaseInputIndex / promptSnippet。
+                        let fallbackPromptId;
+                        let fallbackPromptIndex;
+                        let fallbackPromptSnippet;
+                        if (!progress.correctionContext?.promptId && pendingExists) {
+                            try {
+                                const markerRaw = readFileSync(pendingMarkerPath, 'utf-8');
+                                if (markerRaw) {
+                                    const markerData = JSON.parse(markerRaw);
+                                    fallbackPromptId = markerData.promptId;
+                                    fallbackPromptIndex = markerData.phaseInputIndex;
+                                    fallbackPromptSnippet = markerData.promptSnippet;
+                                }
+                            }
+                            catch {
+                                // marker 解析失败不阻断主流程
+                            }
+                        }
+                        const promptId = progress.correctionContext?.promptId ?? fallbackPromptId;
+                        const promptIndex = progress.correctionContext?.promptIndex ?? fallbackPromptIndex;
+                        const promptSnippet = progress.correctionContext?.promptSnippet ?? fallbackPromptSnippet;
+                        // 去重：同 (promptId + filePath + phase) 取历史 max，只累加 delta。
+                        // 语义：同一 prompt 中 AI 对同一文件的多次 Edit（重复修正同区域）不重复计数。
+                        progress.accuracy.correctionEdits = progress.accuracy.correctionEdits || [];
+                        const prevMax = computePromptFileMaxLines(progress.accuracy.correctionEdits, promptId, filePath, trackedPhase);
+                        const dedupDelta = Math.max(0, changeLines - prevMax);
+                        bucket.userCorrectionLines += dedupDelta;
+                        bucket.lastUpdatedAt = timestamp;
+                        progress.accuracy.userCorrectionLines = (progress.accuracy.userCorrectionLines || 0) + dedupDelta;
+                        progress.accuracy.correctionEdits.push({
+                            filePath,
+                            editLines: changeLines,
+                            source: 'user',
+                            strategy: 'correction-context',
+                            agentType: progress.correctionContext?.path,
+                            timestamp,
+                            phase: trackedPhase,
+                            trackedKind,
+                            triggeredBy: {
+                                source: ccSource,
+                                promptId,
+                                promptIndex,
+                                promptSnippet,
+                            },
+                        });
+                        // 记录 phase 维度 promptId（去重）
+                        if (promptId && !bucket.correctionPromptIds.includes(promptId)) {
+                            bucket.correctionPromptIds.push(promptId);
+                        }
+                        correctionDebugLog(`${toolName}/correction`, 'userCorrectionLines', dedupDelta);
+                        appendAccuracyDebugLog(changeDir, {
+                            type: 'correction.record',
+                            phase: trackedPhase,
+                            kind: trackedKind,
+                            trigger: 'hook',
+                            changeId,
+                            input: {
+                                tool: toolName,
+                                file: filePath,
+                                changeLines,
+                                contentSource,
+                                ccSource,
+                                promptId,
+                                promptIndex,
+                                prevMax,
+                                dedupDelta,
+                            },
+                            output: {
+                                bucketCorrection: bucket.userCorrectionLines,
+                                topCorrection: progress.accuracy.userCorrectionLines,
+                                promptIdsCount: bucket.correctionPromptIds.length,
+                            },
+                        });
+                    }
+                }
+                else {
+                    // 正常 AI 产出：桶 + 顶层 aiLinesAdded/aiTotalLines 同步累加，同时顶层 progress.linesAdded 仍需累加以兼容旧逻辑
+                    bucket.aiLinesAdded += changeLines;
+                    bucket.aiTotalLines += changeLines;
+                    bucket.lastUpdatedAt = timestamp;
+                    progress.accuracy.aiLinesAdded = (progress.accuracy.aiLinesAdded || 0) + changeLines;
+                    progress.accuracy.aiTotalLines = (progress.accuracy.aiTotalLines || 0) + changeLines;
+                    progress.linesAdded += changeLines;
+                    correctionDebugLog(`${toolName}/normal`, 'linesAdded', changeLines);
+                    appendAccuracyDebugLog(changeDir, {
+                        type: 'ai.record',
+                        phase: trackedPhase,
+                        kind: trackedKind,
+                        trigger: 'hook',
+                        changeId,
+                        input: { tool: toolName, file: filePath, changeLines, contentSource },
+                        output: {
+                            bucketAiTotal: bucket.aiTotalLines,
+                            topAiTotal: progress.accuracy.aiTotalLines,
+                        },
+                    });
+                }
             }
             // 累加后重算 accuracyRate（顶层 + 各桶）
             recomputeAccuracyRate(progress, { changeDir, trigger: 'hook' });
@@ -870,51 +1095,34 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
     const contextLoadFromStdIn = Number(stdinData.tool_result?.contextLoad || 0);
     progress.stats.tokenUsageTotal += tokenUsageFromEnv + tokenUsageFromStdIn;
     progress.stats.contextLoad += contextLoadFromEnv + contextLoadFromStdIn;
-    // Calculate duration for current phase from phaseTransitions
-    // Find the last transition to current phase; if none exists (e.g. initial
-    // phase such as techDesign started via initializeProgress without a
-    // transition record), fall back to phaseDurations[].startedAt, then to
-    // progress.startedAt so every phase gets an accurate elapsed time.
-    const transitionsToCurrentPhase = progress.phaseTransitions.filter((t) => t.to === phase);
-    const currentPhaseStart = transitionsToCurrentPhase[transitionsToCurrentPhase.length - 1];
-    let phaseStartTimestamp;
-    if (currentPhaseStart) {
-        phaseStartTimestamp = currentPhaseStart.timestamp;
-    }
-    else {
-        const activePhaseDuration = [...progress.phaseDurations]
-            .reverse()
-            .find(pd => pd.phase === phase && !pd.endedAt);
-        if (activePhaseDuration?.startedAt) {
-            phaseStartTimestamp = activePhaseDuration.startedAt;
-        }
-        else if (progress.startedAt) {
-            phaseStartTimestamp = progress.startedAt;
-        }
-    }
-    if (phaseStartTimestamp) {
-        const startTime = new Date(phaseStartTimestamp.replace(' ', 'T')).getTime();
-        const elapsedMs = Date.now() - startTime;
-        if (Number.isFinite(startTime) && elapsedMs > 0) {
-            if (phase === 'techDesign')
-                progress.stats.durationMs.techDesign = elapsedMs;
-            if (phase === 'propose')
-                progress.stats.durationMs.propose = elapsedMs;
-            if (phase === 'apply')
-                progress.stats.durationMs.apply = elapsedMs;
-            if (phase === 'review')
-                progress.stats.durationMs.review = elapsedMs;
-            if (phase === 'archive')
-                progress.stats.durationMs.archive = elapsedMs;
-            // v2.15.16：同步刷新活跃段的 phaseDurations 记录，进行中也能从单条直接读出
-            // 实时 durationMs / lastUpdatedAt。endedAt 仍仅在 phase 切换时填。
-            const activeEntry = [...progress.phaseDurations]
-                .reverse()
-                .find(pd => pd.phase === phase && !pd.endedAt);
-            if (activeEntry) {
-                activeEntry.durationMs = elapsedMs;
-                activeEntry.lastUpdatedAt = getBeijingTime();
-            }
+    // v2.16+：使用 tickActivePhaseDuration 累加活跃耗时
+    // 在 phaseDurations 中找到当前进行中的 entry，tick 一次心跳
+    const activeEntry = [...progress.phaseDurations]
+        .reverse()
+        .find(pd => pd.phase === phase && !pd.endedAt);
+    if (activeEntry) {
+        const nowEpoch = Date.now();
+        const nowTs = getBeijingTime();
+        tickActivePhaseDuration(activeEntry, nowEpoch, nowTs);
+        // 同步刷新 stats.durationMs（活跃耗时）
+        if (phase === 'techDesign')
+            progress.stats.durationMs.techDesign = activeEntry.durationMs;
+        if (phase === 'propose')
+            progress.stats.durationMs.propose = activeEntry.durationMs;
+        if (phase === 'apply')
+            progress.stats.durationMs.apply = activeEntry.durationMs;
+        if (phase === 'review')
+            progress.stats.durationMs.review = activeEntry.durationMs;
+        if (phase === 'archive')
+            progress.stats.durationMs.archive = activeEntry.durationMs;
+        // 同步 stats 的可选双轨字段
+        if (!progress.stats.wallClockMs)
+            progress.stats.wallClockMs = { techDesign: 0, propose: 0, apply: 0, review: 0, archive: 0 };
+        if (!progress.stats.idleMs)
+            progress.stats.idleMs = { techDesign: 0, propose: 0, apply: 0, review: 0, archive: 0 };
+        if (phase !== 'idle') {
+            progress.stats.wallClockMs[phase] = activeEntry.wallClockMs || 0;
+            progress.stats.idleMs[phase] = activeEntry.idleMs || 0;
         }
     }
     // === Auto-count tasks from tasks.md ===
@@ -1101,6 +1309,10 @@ function createNewProgress(changeId) {
                 durationMs: 0,
                 taskCount: 0,
                 completedTaskCount: 0,
+                wallClockMs: 0,
+                idleMs: 0,
+                lastActiveAt: getBeijingTime(),
+                _lastActiveEpoch: Date.now(),
             }],
         stats: {
             tokenUsageTotal: 0,
@@ -1167,17 +1379,16 @@ export async function initializeProgress(changeId, initialPhase = 'propose') {
                     timestamp,
                     triggeredBy: 'initializeProgress',
                 });
-                // Update previous phase duration
+                // Update previous phase duration with tick
                 const prevPhaseDuration = progress.phaseDurations.find(pd => pd.phase === previousPhase && !pd.endedAt);
                 if (prevPhaseDuration) {
+                    // 封段前 tick，确保最后活跃时间被累加
+                    const nowEpoch = Date.now();
+                    tickActivePhaseDuration(prevPhaseDuration, nowEpoch, timestamp);
                     prevPhaseDuration.endedAt = timestamp;
-                    prevPhaseDuration.lastUpdatedAt = timestamp;
-                    const startTime = new Date(prevPhaseDuration.startedAt.replace(' ', 'T')).getTime();
-                    const endTime = new Date(timestamp.replace(' ', 'T')).getTime();
-                    const ms = Number.isFinite(startTime) && endTime > startTime ? endTime - startTime : 0;
-                    prevPhaseDuration.durationMs = ms;
-                    if (previousPhase && previousPhase !== 'idle' && ms > 0 && progress.stats?.durationMs) {
-                        progress.stats.durationMs[previousPhase] = ms;
+                    // 同步 stats
+                    if (previousPhase && previousPhase !== 'idle' && progress.stats?.durationMs) {
+                        progress.stats.durationMs[previousPhase] = prevPhaseDuration.durationMs;
                     }
                 }
                 else if (previousPhase && previousPhase !== 'idle') {
@@ -1211,6 +1422,10 @@ export async function initializeProgress(changeId, initialPhase = 'propose') {
                     durationMs: 0,
                     taskCount: 0,
                     completedTaskCount: 0,
+                    wallClockMs: 0,
+                    idleMs: 0,
+                    lastActiveAt: timestamp,
+                    _lastActiveEpoch: Date.now(),
                 });
             }
             progress.phase = initialPhase;
@@ -1281,14 +1496,12 @@ function seedInitialPhase(progress, initialPhase, timestamp) {
     progress.phaseDurations = progress.phaseDurations || [];
     const activeEntry = progress.phaseDurations.find(pd => pd.phase === initialPhase && !pd.endedAt);
     if (!activeEntry) {
-        // Close any still-open legacy entry (e.g. the placeholder 'idle' entry created in createNewProgress)
+        // Close any still-open legacy entry with tick
         for (const entry of progress.phaseDurations) {
             if (!entry.endedAt && entry.phase !== initialPhase) {
+                const nowEpoch = Date.now();
+                tickActivePhaseDuration(entry, nowEpoch, timestamp);
                 entry.endedAt = timestamp;
-                entry.lastUpdatedAt = timestamp;
-                const startTime = new Date((entry.startedAt || timestamp).replace(' ', 'T')).getTime();
-                const endTime = new Date(timestamp.replace(' ', 'T')).getTime();
-                entry.durationMs = Number.isFinite(startTime) && endTime > startTime ? endTime - startTime : 0;
             }
         }
         progress.phaseDurations.push({
@@ -1298,6 +1511,10 @@ function seedInitialPhase(progress, initialPhase, timestamp) {
             durationMs: 0,
             taskCount: 0,
             completedTaskCount: 0,
+            wallClockMs: 0,
+            idleMs: 0,
+            lastActiveAt: timestamp,
+            _lastActiveEpoch: Date.now(),
         });
     }
 }

package/dist/core/hooks/user-input-hook.js

@@ -188,7 +188,10 @@ export async function userInputHook(content, responseTimeMs) {
     // Skip slash/bang commands (e.g. /zhuanspec:proposal, /compact, /clear, !ls).
     // 这类 prompt 是命令/workflow 触发，非“用户对 AI 产出的纠偏/濄清/补充”，
     // 不应计入 user_inputs.json，更不应放进纠偏溯源池影响 accuracyRate。
-    const trimmedContent = content.trim();
+    // 注意：Claude Code 在 slash 命令前会注入 NAK(U+0015) 等 C0 控制字符做标记，
+    // 普通 trim() 不会剥控制字符，必须显式剥掉前缀的 C0/DEL 再做正则判定，
+    // 否则像 "\u0015/zhuanspec:proposal" 这种命令会漏过过滤被记成普通用户输入。
+    const trimmedContent = content.trim().replace(/^[\x00-\x1F\x7F]+/, '');
     if (/^[/!][A-Za-z0-9_:/@.\-]+(\s|$)/.test(trimmedContent) || /^\/[\w:\-]+$/.test(trimmedContent)) {
         logDebug(cwd, {
             event: 'skip',