@zhuan-ai/zhuanspec 2.16.3 → 2.16.5

package/dist/core/configurators/codex.js

@@ -38,7 +38,7 @@ import path from 'path';
 import os from 'os';
 import { promises as fs } from 'fs';
 import { FileSystemUtils } from '../../utils/file-system.js';
-import { getCodexHooksTomlBlock, getCodexDefaultHookSlots } from '../templates/codex-hooks-template.js';
+import { getCodexHooksTomlBlock, getCodexDefaultHookSlots, getCodexDefaultHookHashes } from '../templates/codex-hooks-template.js';
 import { getCodexAgentTomls, } from '../templates/codex-agents-template.js';
 import { getCodexSkillFiles } from '../templates/codex-skills-template.js';
 import { CodexSlashCommandConfigurator } from './slash/codex.js';
@@ -374,6 +374,16 @@ export class CodexConfigurator {
                     seedBySuffix.set(split.suffix, entry.hash);
                 }
             }
+            // 2b. Computed hashes take priority over cross-project seeds because
+            // seeds from a different source type (e.g. ~/.codex/hooks.json vs
+            // .codex/config.toml) may have different hook content and thus wrong
+            // hashes.  Our computed hashes replicate the exact Codex CLI fingerprint
+            // algorithm (NormalizedHookIdentity → canonical JSON → SHA-256) and are
+            // guaranteed correct for the current ZhuanSpec default hooks.
+            const computedHashes = getCodexDefaultHookHashes();
+            for (const [suffix, hash] of computedHashes) {
+                seedBySuffix.set(suffix, hash); // always overwrite cross-project seeds
+            }
             const seedAvailable = seedBySuffix.size > 0;
             // 3. Plan per-slot writes.
             const written = [];

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

@@ -11,8 +11,9 @@ import { promises as fsPromises, existsSync, readFileSync, unlinkSync } from 'fs
 import { FileSystemUtils } from '../../utils/file-system.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
@@ -404,6 +405,55 @@ function generateProposalChangeSummary(toolInput) {
     // Truncate to 120 chars
     return firstLine.length > 120 ? firstLine.substring(0, 117) + '...' : firstLine;
 }
+function parseApplyPatch(command) {
+    const result = { files: [], totalLinesAdded: 0, totalLinesRemoved: 0 };
+    if (!command)
+        return result;
+    const lines = command.split('\n');
+    let currentFile = null;
+    for (const line of lines) {
+        if (line.startsWith('*** Add File: ') || line.startsWith('*** Update File: ')) {
+            if (currentFile)
+                result.files.push(currentFile);
+            const filePath = line.replace(/^\*\*\* (?:Add|Update) File:\s*/, '').trim();
+            currentFile = { path: filePath, linesAdded: 0, linesRemoved: 0 };
+        }
+        else if (line.startsWith('*** Delete File: ')) {
+            if (currentFile)
+                result.files.push(currentFile);
+            const filePath = line.replace(/^\*\*\* Delete File:\s*/, '').trim();
+            currentFile = { path: filePath, linesAdded: 0, linesRemoved: 0 };
+        }
+        else if (line === '*** End Patch' || line === '*** Begin Patch') {
+            if (currentFile) {
+                result.files.push(currentFile);
+                currentFile = null;
+            }
+        }
+        else if (line.startsWith('*** ')) {
+            // Other patch directives (e.g., *** Rename File:) — push current and skip
+            if (currentFile) {
+                result.files.push(currentFile);
+                currentFile = null;
+            }
+        }
+        else if (currentFile) {
+            if (line.startsWith('+'))
+                currentFile.linesAdded++;
+            else if (line.startsWith('-'))
+                currentFile.linesRemoved++;
+            // Context lines (space prefix or @@ markers) are ignored for counting
+        }
+    }
+    if (currentFile)
+        result.files.push(currentFile);
+    // Calculate totals
+    for (const f of result.files) {
+        result.totalLinesAdded += f.linesAdded;
+        result.totalLinesRemoved += f.linesRemoved;
+    }
+    return result;
+}
 async function runRecordProgress(filePath, toolName, success, stdinData) {
     const cwd = resolveZhuanSpecRoot();
     // Priority: filePath-derived > progress.json scan > environment variables
@@ -619,8 +669,31 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
     progress.currentNode = process.env.ZHUANSPEC_CURRENT_NODE || phase;
     progress.currentTask = currentTask || progress.currentTask;
     progress.toolCalls.push(toolCall);
-    const WRITE_TOOLS = new Set(['Write', 'Edit', 'MultiEdit', 'NotebookEdit']);
-    if (filePath && WRITE_TOOLS.has(toolName) && !progress.filesModified.includes(filePath)) {
+    // === Codex apply_patch 支持 ===
+    // Codex 使用 apply_patch 工具，file_path 为空，实际内容在 command 字段的 patch 格式中
+    let patchResult = null;
+    if (toolName === 'apply_patch') {
+        const command = stdinData.tool_input?.command || '';
+        patchResult = parseApplyPatch(command);
+        // 用第一个文件路径作为 filePath（用于 accuracy 追踪和 change detection）
+        if (patchResult.files.length > 0 && !filePath) {
+            filePath = patchResult.files[0].path;
+        }
+    }
+    const WRITE_TOOLS = new Set(['Write', 'Edit', 'MultiEdit', 'NotebookEdit', 'apply_patch']);
+    if (toolName === 'apply_patch' && patchResult) {
+        // apply_patch 可修改多文件，逐一加入 filesModified
+        const zhuanspecDirPrefix = path.resolve(process.cwd(), 'zhuanspec') + path.sep;
+        for (const f of patchResult.files) {
+            if (!f.path || progress.filesModified.includes(f.path))
+                continue;
+            const absF = path.isAbsolute(f.path) ? f.path : path.resolve(process.cwd(), f.path);
+            if (!absF.startsWith(zhuanspecDirPrefix)) {
+                progress.filesModified.push(f.path);
+            }
+        }
+    }
+    else if (filePath && WRITE_TOOLS.has(toolName) && !progress.filesModified.includes(filePath)) {
         // Exclude ZhuanSpec internal files (spec/metrics/doc files inside zhuanspec/ dir)
         const absFilePath = path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
         const zhuanspecDirPrefix = path.resolve(process.cwd(), 'zhuanspec') + path.sep;
@@ -630,7 +703,7 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
     }
     // Detect proposal file changes and record them
     const changePath = path.join(zhuanspecDir, 'changes', changeId);
-    const WRITE_EDIT_TOOLS = new Set(['Write', 'Edit', 'MultiEdit']);
+    const WRITE_EDIT_TOOLS = new Set(['Write', 'Edit', 'MultiEdit', 'apply_patch']);
     if (filePath && WRITE_EDIT_TOOLS.has(toolName) && isProposalFile(filePath, changePath)) {
         const relativeProposalPath = path.relative(changePath, path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath));
         // 提案文件变更行数：按工具类型取不同字段，避免 Edit/MultiEdit 全记为 0
@@ -651,6 +724,16 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
                 contentLines += Math.max(ns, os);
             }
         }
+        else if (toolName === 'apply_patch' && patchResult) {
+            // apply_patch 的提案文件变更行数：用 patch 中涉及该提案文件的行数
+            const absChangePath = path.isAbsolute(changePath) ? changePath : path.resolve(cwd, changePath);
+            for (const f of patchResult.files) {
+                const absF = path.isAbsolute(f.path) ? f.path : path.resolve(cwd, f.path);
+                if (absF.startsWith(absChangePath + path.sep)) {
+                    contentLines += f.linesAdded + f.linesRemoved;
+                }
+            }
+        }
         const record = {
             changeRecordId: `pc-${Date.now()}`,
             timestamp,
@@ -699,6 +782,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') {
@@ -708,20 +796,22 @@ 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';
     }
+    else if (toolName === 'apply_patch' && patchResult) {
+        // Codex apply_patch：统计 patch 中所有 +/- 行
+        changeLines = patchResult.totalLinesAdded + patchResult.totalLinesRemoved;
+        contentSource = patchResult.files.length > 0 ? 'command' : 'none';
+    }
     let estimatedLines = 0;
     // === P0 兜底：post-baseline-fallback ===
     // 正常链路：UserPromptSubmit 的 user-input hook 会在 phaseBaseline 已打标时写入
@@ -800,40 +890,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;
@@ -854,6 +934,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,
@@ -861,7 +948,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,
@@ -870,14 +957,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,
@@ -886,39 +973,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' });

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

@@ -185,17 +185,19 @@ export async function userInputHook(content, responseTimeMs) {
         logDebug(cwd, { event: 'skip', reason: 'content-too-short', changeId, phase, phaseSource, contentLen });
         return { continue: true };
     }
-    // Skip slash/bang commands (e.g. /zhuanspec:proposal, /compact, /clear, !ls).
-    // 这类 prompt 是命令/workflow 触发，非“用户对 AI 产出的纠偏/濄清/补充”，
+    // Skip slash/bang/dollar commands:
+    //   Claude Code: /zhuanspec:proposal, /compact, /clear, !ls
+    //   Codex: $zhuanspec-proposal, $zhuanspec-techDesign 等 skill 触发
+    // 这类 prompt 是命令/workflow 触发，非"用户对 AI 产出的纠偏/澄清/补充"，
     // 不应计入 user_inputs.json，更不应放进纠偏溯源池影响 accuracyRate。
     // 注意：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)) {
+    if (/^[/!$][A-Za-z0-9_:/@.\-]+(\s|$)/.test(trimmedContent) || /^\/[\w:\-]+$/.test(trimmedContent)) {
         logDebug(cwd, {
             event: 'skip',
-            reason: 'slash-command',
+            reason: 'skill-command',
             changeId,
             phase,
             phaseSource,

package/dist/core/metrics/code-accuracy.d.ts

@@ -38,6 +38,66 @@ export declare function appendAccuracyDebugLog(changeDir: string, entry: Accurac
  * 判断是否为代码文件（需纳入准确率统计）
  */
 export declare function isCodeFile(filePath: string): boolean;
+/**
+ * Review 阶段自动修复 Skill 列表。
+ * 这些 Skill 在 review 阶段触发的代码编辑属于自动修复，
+ * 不应计入用户纠正（不影响 apply 阶段准确率）。
+ *
+ * 匹配规则：skill name 包含列表中任一子串即视为 autofix skill。
+ */
+export declare const REVIEW_AUTOFIX_SKILLS: string[];
+/**
+ * 纯确认/招呼类 prompt，不具备纠偏意图，不应触发用户纠正归因。
+ * 与 src/core/corrections/select-candidates.ts 中的 TRIVIAL_ACK_SET 保持同步。
+ */
+export declare const TRIVIAL_ACK_WORDS: ReadonlySet<string>;
+/**
+ * 判定 prompt 是否为琐碎确认/招呼（如"继续"、"好的"、"ok"等）。
+ *
+ * 规则：
+ *   1. 空字符串视为琐碎；
+ *   2. 规范化后命中 TRIVIAL_ACK_WORDS 视为琐碎；
+ *   3. 规范化后字符长度 ≤ 2 视为琐碎（如"好。"、"!!"）。
+ *
+ * 注：斜杠/感叹号开头的命令词（/zhuanspec:、!ls 等）已由 user-input-hook
+ * 在写入 correctionContext 前过滤，无需在此重复处理。
+ */
+export declare function isTrivialAckPrompt(text: string | null | undefined): boolean;
+/**
+ * 判断 correctionContext 是否代表一次有意义的用户纠正（非琐碎确认）。
+ *
+ * 接受的 source：
+ *   - correction-keyword：命中显式纠偏关键词，始终视为用户纠正；
+ *   - post-baseline-prompt：baseline 后任何用户提示，但 promptSnippet
+ *     必须不是琐碎确认词（如"继续"、"好的"）。
+ *
+ * 该函数用于 review 阶段判定 "用户提示词触发的纠正"，使其覆盖范围与 apply 阶段一致。
+ */
+export declare function isMeaningfulUserCorrection(correctionContext?: {
+    active: boolean;
+    source?: string;
+    promptSnippet?: string;
+} | null): boolean;
+/**
+ * 判定当前 review 阶段的编辑是否属于 Skill 自动修复（CR/单测），不应计入准确率。
+ *
+ * 判定逻辑：取最近一次 review 阶段的 skill 调用，若 skill name 匹配 REVIEW_AUTOFIX_SKILLS
+ * 且该 skill 调用晚于最近的有意义用户纠偏上下文（correctionContext.resolvedAt），则视为自动修复。
+ *
+ * "有意义的用户纠偏" 定义：
+ *   - source = 'correction-keyword'，或
+ *   - source = 'post-baseline-prompt' 且 promptSnippet 不是琐碎确认词
+ */
+export declare function isReviewAutoFixActive(skillCalls: Array<{
+    skill: string;
+    triggeredAt: string;
+    phase: string;
+}>, correctionContext?: {
+    active: boolean;
+    resolvedAt?: string;
+    source?: string;
+    promptSnippet?: string;
+}): boolean;
 export type TrackedPhase = 'techDesign' | 'propose' | 'apply' | 'review';
 export type TrackedKind = 'techSpec' | 'proposalDoc' | 'code';
 /**
@@ -150,6 +210,22 @@ export declare function snapshotAiBaseline(progress: ProgressData, changeDir: st
  * @returns true 表示本次调用创建了新快照，false 表示快照已存在或跳过
  */
 export declare function ensureAccuracySnapshot(changeDir: string): Promise<boolean>;
+/**
+ * 同 (promptId + filePath + phase) 历史 record 中的最大 editLines。
+ *
+ * 背景：用户一次 prompt 可能触发 AI 多次 Edit（重复修正同一区域）。
+ * 直接累加会造成虚高；取 max 反映“最终保留下来的最大一次改动”。
+ *
+ * promptId 为空时返回 0（冷启动，当前是首条，取 0 后累加全量 changeLines）。
+ */
+export declare function computePromptFileMaxLines(correctionEdits: ReadonlyArray<{
+    filePath: string;
+    editLines: number;
+    phase?: string;
+    triggeredBy?: {
+        promptId?: string;
+    };
+}>, promptId: string | undefined, filePath: string, phase: TrackedPhase): number;
 /**
  * 用户纠正行数累计（legacy——新代码优先用 record-progress.ts 内联的 correctionContext 逻辑）。
  *

package/dist/core/metrics/code-accuracy.js

@@ -62,6 +62,110 @@ export function isCodeFile(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     return CODE_FILE_EXTENSIONS.has(ext);
 }
+// ============================================================
+// Review 阶段自动修复 Skill 白名单
+// ============================================================
+/**
+ * Review 阶段自动修复 Skill 列表。
+ * 这些 Skill 在 review 阶段触发的代码编辑属于自动修复，
+ * 不应计入用户纠正（不影响 apply 阶段准确率）。
+ *
+ * 匹配规则：skill name 包含列表中任一子串即视为 autofix skill。
+ */
+export const REVIEW_AUTOFIX_SKILLS = [
+    'code-review-expert',
+    'generate-mockito-unit-test',
+];
+// ============================================================
+// 琐碎确认词识别（与 select-candidates.ts 保持一致）
+// ============================================================
+/**
+ * 纯确认/招呼类 prompt，不具备纠偏意图，不应触发用户纠正归因。
+ * 与 src/core/corrections/select-candidates.ts 中的 TRIVIAL_ACK_SET 保持同步。
+ */
+export const TRIVIAL_ACK_WORDS = new Set([
+    '是', '是的', '好', '好的', '嗯', '嗯嗯', '对', '行', '可以', '确认',
+    '同意', '继续', '没问题', '明白', '了解', '知道了', '收到', '辛苦', '辛苦了',
+    'ok', 'okay', 'k', 'yes', 'y', 'yep', 'yeah', 'sure', 'fine', 'cool',
+    'go', 'go on', 'plan approved', 'continue', 'thanks', 'thx',
+]);
+/** 规范化文本：小写 + 中英文标点/空白统一压成单空格。 */
+function normalizeAckText(text) {
+    return text
+        .toLowerCase()
+        .replace(/[\s\p{P}\p{S}]+/gu, ' ')
+        .trim();
+}
+/**
+ * 判定 prompt 是否为琐碎确认/招呼（如"继续"、"好的"、"ok"等）。
+ *
+ * 规则：
+ *   1. 空字符串视为琐碎；
+ *   2. 规范化后命中 TRIVIAL_ACK_WORDS 视为琐碎；
+ *   3. 规范化后字符长度 ≤ 2 视为琐碎（如"好。"、"!!"）。
+ *
+ * 注：斜杠/感叹号开头的命令词（/zhuanspec:、!ls 等）已由 user-input-hook
+ * 在写入 correctionContext 前过滤，无需在此重复处理。
+ */
+export function isTrivialAckPrompt(text) {
+    if (!text)
+        return true;
+    const norm = normalizeAckText(text);
+    if (norm.length === 0)
+        return true;
+    if (TRIVIAL_ACK_WORDS.has(norm))
+        return true;
+    if (norm.length <= 2)
+        return true;
+    return false;
+}
+/**
+ * 判断 correctionContext 是否代表一次有意义的用户纠正（非琐碎确认）。
+ *
+ * 接受的 source：
+ *   - correction-keyword：命中显式纠偏关键词，始终视为用户纠正；
+ *   - post-baseline-prompt：baseline 后任何用户提示，但 promptSnippet
+ *     必须不是琐碎确认词（如"继续"、"好的"）。
+ *
+ * 该函数用于 review 阶段判定 "用户提示词触发的纠正"，使其覆盖范围与 apply 阶段一致。
+ */
+export function isMeaningfulUserCorrection(correctionContext) {
+    if (!correctionContext?.active)
+        return false;
+    const source = correctionContext.source;
+    if (source === 'correction-keyword')
+        return true;
+    if (source === 'post-baseline-prompt') {
+        return !isTrivialAckPrompt(correctionContext.promptSnippet);
+    }
+    return false;
+}
+/**
+ * 判定当前 review 阶段的编辑是否属于 Skill 自动修复（CR/单测），不应计入准确率。
+ *
+ * 判定逻辑：取最近一次 review 阶段的 skill 调用，若 skill name 匹配 REVIEW_AUTOFIX_SKILLS
+ * 且该 skill 调用晚于最近的有意义用户纠偏上下文（correctionContext.resolvedAt），则视为自动修复。
+ *
+ * "有意义的用户纠偏" 定义：
+ *   - source = 'correction-keyword'，或
+ *   - source = 'post-baseline-prompt' 且 promptSnippet 不是琐碎确认词
+ */
+export function isReviewAutoFixActive(skillCalls, correctionContext) {
+    // 取 review 阶段中匹配 autofix skill 的最近一次调用
+    const recentAutofix = [...skillCalls]
+        .reverse()
+        .find(sc => sc.phase === 'review'
+        && REVIEW_AUTOFIX_SKILLS.some(s => sc.skill.includes(s)));
+    if (!recentAutofix)
+        return false;
+    // 如果存在有意义的用户纠偏上下文且 resolvedAt 晚于 skill 触发时间，说明用户已介入
+    if (isMeaningfulUserCorrection(correctionContext)
+        && correctionContext?.resolvedAt
+        && correctionContext.resolvedAt > recentAutofix.triggeredAt) {
+        return false;
+    }
+    return true;
+}
 /**
  * 判定 filePath 在当前 phase 下是否属于白名单，并返回文件分类。
  *
@@ -322,6 +426,32 @@ export async function ensureAccuracySnapshot(changeDir) {
     }
 }
 // ============================================================
+// 纠偏去重计算（同 promptId+filePath+phase 取 max）
+// ============================================================
+/**
+ * 同 (promptId + filePath + phase) 历史 record 中的最大 editLines。
+ *
+ * 背景：用户一次 prompt 可能触发 AI 多次 Edit（重复修正同一区域）。
+ * 直接累加会造成虚高；取 max 反映“最终保留下来的最大一次改动”。
+ *
+ * promptId 为空时返回 0（冷启动，当前是首条，取 0 后累加全量 changeLines）。
+ */
+export function computePromptFileMaxLines(correctionEdits, promptId, filePath, phase) {
+    if (!promptId || !filePath)
+        return 0;
+    let maxLines = 0;
+    for (const e of correctionEdits) {
+        if (e.phase === phase
+            && e.filePath === filePath
+            && e.triggeredBy?.promptId === promptId
+            && typeof e.editLines === 'number'
+            && e.editLines > maxLines) {
+            maxLines = e.editLines;
+        }
+    }
+    return maxLines;
+}
+// ============================================================
 // 用户纠正行数累计
 // ============================================================
 /**

package/dist/core/templates/codex-hooks-template.d.ts

@@ -85,5 +85,32 @@ export interface CodexHookSlot {
  * the same event (matching Codex's array-of-tables semantics).
  */
 export declare function getCodexDefaultHookSlots(): readonly CodexHookSlot[];
+/**
+ * Compute the content-trust SHA-256 hash for a hook handler, replicating
+ * the algorithm from Codex CLI's `codex-rs/hooks/src/engine/discovery.rs`:
+ *
+ * Codex hashes a `NormalizedHookIdentity` struct, which is serialized to
+ * TOML then converted to canonical JSON. The structure is:
+ *
+ *   { event_name, matcher?, hooks: [{ type, command, async, timeout, statusMessage? }] }
+ *
+ * Key normalization details:
+ *   - `timeout` defaults to 600 when absent in source TOML
+ *   - `async` is always false (we don't support async hooks)
+ *   - `command_windows` (None) is omitted in TOML serialization
+ *   - `matcher` is only included when present
+ *   - Keys are recursively sorted (canonical JSON) then SHA-256 hashed
+ *
+ * This allows ZhuanSpec to pre-seed `trusted_hash` entries directly without
+ * relying on cross-project hash grafting, eliminating the "Hooks need review"
+ * prompt on first use or after upgrades.
+ */
+export declare function computeHookContentHash(entry: CodexHookEntry): string;
+/**
+ * Get the computed content-trust hashes for all default hook handlers.
+ * Returns a map from slot suffix (`<event_snake>:<group>:<handler>`) to
+ * the SHA-256 hash string that Codex CLI would compute.
+ */
+export declare function getCodexDefaultHookHashes(): Map<string, string>;
 export {};
 //# sourceMappingURL=codex-hooks-template.d.ts.map

package/dist/core/templates/codex-hooks-template.js

@@ -25,6 +25,7 @@
  * ZhuanSpec markers of `<repo>/.codex/config.toml` so that `zhuanspec update`
  * can regenerate it idempotently without clobbering user-owned config.
  */
+import { createHash } from 'crypto';
 /**
  * ZhuanSpec default hooks, in logical order. Keep this list in sync with the
  * Claude settings.json generator in init.ts so behavior stays consistent
@@ -49,7 +50,7 @@ const CODEX_DEFAULT_HOOKS = [
     },
     {
         event: 'PostToolUse',
-        matcher: 'Write|Edit|Read|Grep|Glob|Bash|Skill|Agent|mcp__.*',
+        matcher: 'Write|Edit|apply_patch|Read|Grep|Glob|Bash|Skill|Agent|mcp__.*',
         command: 'ZHUANSPEC_HOST=codex zhuanspec-hook record-progress --json',
         statusMessage: '📝 Recording progress...',
     },
@@ -142,4 +143,84 @@ export function getCodexDefaultHookSlots() {
         return { event: entry.event, eventSnake, groupIndex, handlerIndex: 0 };
     });
 }
+/**
+ * Compute the content-trust SHA-256 hash for a hook handler, replicating
+ * the algorithm from Codex CLI's `codex-rs/hooks/src/engine/discovery.rs`:
+ *
+ * Codex hashes a `NormalizedHookIdentity` struct, which is serialized to
+ * TOML then converted to canonical JSON. The structure is:
+ *
+ *   { event_name, matcher?, hooks: [{ type, command, async, timeout, statusMessage? }] }
+ *
+ * Key normalization details:
+ *   - `timeout` defaults to 600 when absent in source TOML
+ *   - `async` is always false (we don't support async hooks)
+ *   - `command_windows` (None) is omitted in TOML serialization
+ *   - `matcher` is only included when present
+ *   - Keys are recursively sorted (canonical JSON) then SHA-256 hashed
+ *
+ * This allows ZhuanSpec to pre-seed `trusted_hash` entries directly without
+ * relying on cross-project hash grafting, eliminating the "Hooks need review"
+ * prompt on first use or after upgrades.
+ */
+export function computeHookContentHash(entry) {
+    // Build the normalized handler object matching Codex's HookHandlerConfig::Command
+    // after normalization (timeout defaults to 600, async always present).
+    const handlerObj = {
+        type: 'command',
+        command: entry.command,
+        async: false,
+        timeout: 600,
+    };
+    if (entry.statusMessage) {
+        handlerObj.statusMessage = entry.statusMessage;
+    }
+    // Build the NormalizedHookIdentity: event_name + flattened MatcherGroup
+    const identity = {
+        event_name: toEventSnake(entry.event),
+        hooks: [handlerObj],
+    };
+    if (entry.matcher) {
+        identity.matcher = entry.matcher;
+    }
+    const canonical = canonicalJson(identity);
+    const bytes = Buffer.from(JSON.stringify(canonical), 'utf-8');
+    const hex = createHash('sha256').update(bytes).digest('hex');
+    return `sha256:${hex}`;
+}
+/**
+ * Recursively sort object keys alphabetically to produce canonical JSON,
+ * matching Codex CLI's `canonical_json()` in fingerprint.rs.
+ */
+function canonicalJson(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (Array.isArray(value))
+        return value.map(canonicalJson);
+    if (typeof value === 'object') {
+        const obj = value;
+        const sorted = {};
+        for (const key of Object.keys(obj).sort()) {
+            sorted[key] = canonicalJson(obj[key]);
+        }
+        return sorted;
+    }
+    return value;
+}
+/**
+ * Get the computed content-trust hashes for all default hook handlers.
+ * Returns a map from slot suffix (`<event_snake>:<group>:<handler>`) to
+ * the SHA-256 hash string that Codex CLI would compute.
+ */
+export function getCodexDefaultHookHashes() {
+    const hashes = new Map();
+    const slots = getCodexDefaultHookSlots();
+    for (let i = 0; i < CODEX_DEFAULT_HOOKS.length; i++) {
+        const entry = CODEX_DEFAULT_HOOKS[i];
+        const slot = slots[i];
+        const suffix = `${slot.eventSnake}:${slot.groupIndex}:${slot.handlerIndex}`;
+        hashes.set(suffix, computeHookContentHash(entry));
+    }
+    return hashes;
+}
 //# sourceMappingURL=codex-hooks-template.js.map

package/dist/utils/line-diff.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 行级 diff 计算工具
+ *
+ * 用途：替代 record-progress.ts 中的 Math.max(newLines, oldLines)，
+ *      只统计真正发生变化的行数（增 + 删），不计入未修改的上下文锚点。
+ *
+ * 例：
+ *   old = "A\nB\nC\nD"
+ *   new = "A\nX\nC\nD"
+ *   max(4,4) = 4    ← 旧口径（含上下文）
+ *   diff     = 2    ← 新口径（B 删除 + X 新增）
+ *
+ * 算法：基于 LCS（Longest Common Subsequence）的行级最小编辑距离。
+ *      对小规模编辑（< 1000 行）足够快，且无外部依赖。
+ */
+/**
+ * 计算两段文本的行级净改动行数（添加行数 + 删除行数）。
+ *
+ * - 仅有 oldText：纯删除，返回旧文本行数
+ * - 仅有 newText：纯新增，返回新文本行数
+ * - 两者都有：基于 LCS 的最小编辑距离
+ *
+ * 注意：
+ * - 完全相同（无变化）返回 0
+ * - 修改一行 = 1 删 + 1 增 = 2
+ * - 与 unified diff 的 +/- 行数概念一致
+ *
+ * @param oldText 旧文本（Edit 的 old_string）
+ * @param newText 新文本（Edit 的 new_string）
+ * @returns 净改动行数（>= 0）
+ */
+export declare function countLineDiff(oldText: string | undefined | null, newText: string | undefined | null): number;
+//# sourceMappingURL=line-diff.d.ts.map

package/dist/utils/line-diff.js

@@ -0,0 +1,85 @@
+/**
+ * 行级 diff 计算工具
+ *
+ * 用途：替代 record-progress.ts 中的 Math.max(newLines, oldLines)，
+ *      只统计真正发生变化的行数（增 + 删），不计入未修改的上下文锚点。
+ *
+ * 例：
+ *   old = "A\nB\nC\nD"
+ *   new = "A\nX\nC\nD"
+ *   max(4,4) = 4    ← 旧口径（含上下文）
+ *   diff     = 2    ← 新口径（B 删除 + X 新增）
+ *
+ * 算法：基于 LCS（Longest Common Subsequence）的行级最小编辑距离。
+ *      对小规模编辑（< 1000 行）足够快，且无外部依赖。
+ */
+/**
+ * 计算两段文本的行级净改动行数（添加行数 + 删除行数）。
+ *
+ * - 仅有 oldText：纯删除，返回旧文本行数
+ * - 仅有 newText：纯新增，返回新文本行数
+ * - 两者都有：基于 LCS 的最小编辑距离
+ *
+ * 注意：
+ * - 完全相同（无变化）返回 0
+ * - 修改一行 = 1 删 + 1 增 = 2
+ * - 与 unified diff 的 +/- 行数概念一致
+ *
+ * @param oldText 旧文本（Edit 的 old_string）
+ * @param newText 新文本（Edit 的 new_string）
+ * @returns 净改动行数（>= 0）
+ */
+export function countLineDiff(oldText, newText) {
+    const oldStr = oldText ?? '';
+    const newStr = newText ?? '';
+    if (oldStr === newStr)
+        return 0;
+    if (!oldStr)
+        return newStr.split('\n').length;
+    if (!newStr)
+        return oldStr.split('\n').length;
+    const oldLines = oldStr.split('\n');
+    const newLines = newStr.split('\n');
+    const lcs = lcsLength(oldLines, newLines);
+    // 删除行数 = 旧行 - LCS；新增行数 = 新行 - LCS
+    return (oldLines.length - lcs) + (newLines.length - lcs);
+}
+/**
+ * 计算两个字符串数组的 LCS 长度（动态规划，O(n*m) 时间，O(min) 空间）。
+ *
+ * 内部辅助函数。使用滚动数组避免 O(n*m) 空间开销。
+ *
+ * @param a 数组 A（旧行）
+ * @param b 数组 B（新行）
+ * @returns 最长公共子序列长度
+ */
+function lcsLength(a, b) {
+    const n = a.length;
+    const m = b.length;
+    if (n === 0 || m === 0)
+        return 0;
+    // 让 b 作为短边，节省空间
+    const [shortArr, longArr] = m <= n ? [b, a] : [a, b];
+    const shortLen = shortArr.length;
+    const longLen = longArr.length;
+    // 滚动数组：prev / curr，长度 = shortLen + 1
+    let prev = new Array(shortLen + 1).fill(0);
+    let curr = new Array(shortLen + 1).fill(0);
+    for (let i = 1; i <= longLen; i++) {
+        for (let j = 1; j <= shortLen; j++) {
+            if (longArr[i - 1] === shortArr[j - 1]) {
+                curr[j] = prev[j - 1] + 1;
+            }
+            else {
+                curr[j] = Math.max(prev[j], curr[j - 1]);
+            }
+        }
+        // 滚动：把 curr 拷给 prev，curr 清零
+        const tmp = prev;
+        prev = curr;
+        curr = tmp;
+        curr.fill(0);
+    }
+    return prev[shortLen];
+}
+//# sourceMappingURL=line-diff.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhuan-ai/zhuanspec",
-  "version": "2.16.3",
+  "version": "2.16.5",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "zhuanspec",
@@ -74,7 +74,6 @@
   "dependencies": {
     "@inquirer/core": "^10.2.2",
     "@inquirer/prompts": "^7.8.0",
-    "@rollup/rollup-darwin-x64": "^4.60.4",
     "chalk": "^5.5.0",
     "commander": "^14.0.0",
     "fast-glob": "^3.3.3",