@zhuan-ai/zhuanspec 2.15.7 → 2.16.0

package/dist/core/hooks/record-progress.d.ts

@@ -7,6 +7,7 @@
  * 3. Track tool calls for metrics
  */
 import { Phase } from '../../utils/phase-utils.js';
+import type { PhaseAccuracyEntry, TrackedKind } from '../metrics/code-accuracy.js';
 /**
  * Atomic write JSON file: write to temp file first, then rename
  * This prevents half-written files during crashes or concurrent writes
@@ -174,7 +175,11 @@ export interface ProposalChangeRecord {
     relatedDeviationId?: string;
 }
 /**
- * 用户纠偏事件记录（由 deviation-check 写入 .correction-log）
+ * 用户纠偏事件记录
+ *
+ * v2.15.16 Sprint 3 起：.correction-log 已下线，纠偏事件由 user-input-hook
+ * 写入 user_inputs.json 的 correctionSignal / postBaseline / resolution 字段统一管理。
+ * 此类型仅保留给 progress.ts resolve-correction 命令的老 change 兼容路径使用。
  */
 export interface CorrectionRecord {
     ts: string;
@@ -197,8 +202,18 @@ export interface AccuracyData {
         originalRate: number;
         overriddenRate: number;
         reason?: string;
+        /** 纠正前的 raw 快照（完整保留，供事后差异分析；历史数据可能缺失） */
+        originalRateRaw?: number;
+        originalAiTotalLines?: number;
+        originalUserCorrectionLines?: number;
     }>;
     correctionEdits?: CorrectionEditRecord[];
+    /**
+     * 分阶段准确率桶（Task 3）。
+     * 顶层 aiLinesAdded / userCorrectionLines / aiTotalLines = 各 phase 桶求和（全生命周期聚合）。
+     * 纠偏明细不放在桶内；按 phase 查明细：correctionEdits.filter(e => e.phase === X)。
+     */
+    phaseAccuracy?: PhaseAccuracyEntry[];
 }
 export interface CorrectionEditRecord {
     filePath: string;
@@ -207,6 +222,17 @@ export interface CorrectionEditRecord {
     strategy: 'L1' | 'L2' | 'L3' | 'correction-context';
     agentType?: string;
     timestamp: string;
+    /** 该 edit 发生在哪个 phase（供按 phase 查明细时过滤用） */
+    phase?: string;
+    /** 本 edit 所属的文件白名单类别 */
+    trackedKind?: TrackedKind;
+    /** 纠偏触发源头信息（Task 6），用于 prompt ↔ edit 联关查询 */
+    triggeredBy?: {
+        source: 'correction-keyword' | 'post-baseline-prompt' | 'pending-correction-marker';
+        promptId?: string;
+        promptIndex?: number;
+        promptSnippet?: string;
+    };
 }
 /**
  * 纠偏上下文标记 — 替代 accuracy snapshot 的精准归因机制。
@@ -227,6 +253,41 @@ export interface CorrectionContext {
     path: 'A' | 'B' | 'C' | 'D';
     expiresAt: string;
     phase: string;
+    /**
+     * 纠偏触发来源：
+     *   - 'correction-keyword'        用户 prompt 命中纠偏关键词 → deviation-check → resolve-correction CLI
+     *   - 'pending-correction-marker' .pending-correction 文件兑底（并行竞态兼容）
+     *   - 'post-baseline-prompt'      phaseBaselines 打标后的 UserPromptSubmit（Task 0）
+     */
+    source?: 'correction-keyword' | 'post-baseline-prompt' | 'pending-correction-marker';
+    /** 当前 phase 内的 user prompt 序号（1-based），仅 source='post-baseline-prompt' 有意义 */
+    promptIndex?: number;
+    /** 关联的 user_inputs.json.inputId，用于查明细（Task 6） */
+    promptId?: string;
+    /** prompt 文本前 120 字符摘要，冗余存一份避免频繁 join user_inputs.json */
+    promptSnippet?: string;
+}
+/**
+ * Phase baseline 打标（Task 0）——“首版完成标识”。
+ *
+ * 语义：某 phase 的 markedAt 写入后，该 phase 首版已完成，
+ * 之后的 user prompt 触发修改才算纠偏。
+ *
+ * 打标路径（三路径 OR，先到先得，幂等）：
+ *   - auto-file-complete：Stop hook 中核心产出文件齐备
+ *   - auto-stop：phase 切换时兜底打标（既然都切下一 phase 了，上一 phase 视为“首版完成”）
+ *   - manual-cli：`zhuanspec progress mark-baseline` 手动打标
+ */
+export interface PhaseBaselineEntry {
+    markedAt: string;
+    markedBy: 'auto-file-complete' | 'auto-stop' | 'manual-cli';
+    firstStopAt?: string;
+}
+export interface PhaseBaselines {
+    techDesign?: PhaseBaselineEntry;
+    propose?: PhaseBaselineEntry;
+    apply?: PhaseBaselineEntry;
+    review?: PhaseBaselineEntry;
 }
 export interface ProgressData {
     changeId: string;
@@ -271,6 +332,7 @@ export interface ProgressData {
     lastEvent?: string;
     accuracy?: AccuracyData;
     correctionContext?: CorrectionContext;
+    phaseBaselines?: PhaseBaselines;
 }
 export declare function recordProgressHook(options: RecordProgressOptions): Promise<void>;
 /**

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

@@ -11,7 +11,7 @@ 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 { resolveZhuanSpecRoot } from '../../utils/resolve-root.js';
-import { isCodeFile } from '../metrics/code-accuracy.js';
+import { isCodeFile, isTrackedFileForPhase, getOrCreatePhaseBucket, recomputeAccuracyRate, persistAccuracyJson, appendAccuracyDebugLog } from '../metrics/code-accuracy.js';
 import { detectHookHost, sanitizeCodexEnvelope } from '../../utils/hook-host.js';
 const fs = fsPromises;
 /**
@@ -502,6 +502,37 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
             timestamp: getBeijingTime(),
             triggeredBy: currentTask || 'manual',
         });
+        // === Task 0 路径 2：phase 切换时给上一 phase 补 baseline（兜底打标）===
+        // previousPhase ∈ {techDesign, propose, apply, review} 才打标；idle/archive 排除
+        const BASELINE_PHASES = ['techDesign', 'propose', 'apply', 'review'];
+        if (BASELINE_PHASES.includes(previousPhase)) {
+            progress.phaseBaselines = progress.phaseBaselines || {};
+            const key = previousPhase;
+            const existedBefore = !!progress.phaseBaselines[key]?.markedAt;
+            if (!existedBefore) {
+                progress.phaseBaselines[key] = {
+                    markedAt: getBeijingTime(),
+                    markedBy: 'auto-stop',
+                };
+            }
+            // 埋点：baseline.mark
+            appendAccuracyDebugLog(changeDir, {
+                type: 'baseline.mark',
+                phase: key,
+                trigger: 'auto-stop',
+                changeId,
+                input: { toPhase: phase, previousPhase: key },
+                output: { markedBy: 'auto-stop', existed: existedBefore },
+            });
+        }
+        // === 跨 phase 清理 correctionContext：
+        // 旧 phase 的 active 不应泄漏到新 phase，新 phase 是否进入纠偏态
+        // 由新 phase 的 phaseBaselines + UserPromptSubmit 重新判定
+        if (progress.correctionContext
+            && progress.correctionContext.active
+            && progress.correctionContext.phase !== phase) {
+            progress.correctionContext.active = false;
+        }
     }
     progress.currentNode = process.env.ZHUANSPEC_CURRENT_NODE || phase;
     progress.currentTask = currentTask || progress.currentTask;
@@ -610,7 +641,20 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
         contentSource = toolInputEdits.length > 0 ? 'edits[]' : 'none';
     }
     let estimatedLines = 0;
-    const inCorrectionContext = !!(progress.correctionContext?.active) || pendingExists;
+    // === P0 兜底：post-baseline-fallback ===
+    // 正常链路：UserPromptSubmit 的 user-input hook 会在 phaseBaseline 已打标时写入
+    // correctionContext.active=true。但若 .claude/settings.json 未挂 user-input hook
+    // （老版本模板），correctionContext 会保持 null，导致后续 Write 误入 linesAdded。
+    // 本兜底：只要当前 phase 的 phaseBaseline 已打标，就视同进入纠正上下文。
+    // 语义：Stop 打 baseline 代表该 phase 首版齐备，之后的同 phase Write 绝大多数
+    // 由后续 user prompt 驱动（AI 不会主动在无 prompt 情况下继续大改），归为 user 纠正。
+    const _phaseKeyForBaseline = progress.phase;
+    const _baselinePhases = ['techDesign', 'propose', 'apply', 'review'];
+    const baselineMarkedForPhase = _baselinePhases.includes(_phaseKeyForBaseline)
+        && !!progress.phaseBaselines?.[_phaseKeyForBaseline]?.markedAt;
+    const ccActiveRaw = !!(progress.correctionContext?.active);
+    const inCorrectionContext = ccActiveRaw || pendingExists || baselineMarkedForPhase;
+    const correctionFallbackReason = (!ccActiveRaw && !pendingExists && baselineMarkedForPhase) ? 'post-baseline-fallback' : 'none';
     // === 调试日志：在 changeDir 下写 .correction-debug.log，方便排查“为什么没记录上” ===
     const correctionDebugLog = (branch, addedTo, delta) => {
         try {
@@ -628,6 +672,8 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
                 contentSource,
                 changeLines,
                 pendingExists,
+                baselineMarkedForPhase,
+                fallbackReason: correctionFallbackReason,
                 correctionContext: progress.correctionContext
                     ? { active: ccActive, path: ccPath, expiresAt: ccExpiresAt, phase: ccPhase, currentPhase: progress.phase }
                     : null,
@@ -646,46 +692,175 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
             // 日志失败不阻断主流程
         }
     };
-    if (changeLines > 0 && filePath && isCodeFile(filePath)) {
-        estimatedLines = changeLines;
-        if (inCorrectionContext) {
-            // 纠偏上下文：行数计入 userCorrectionLines，不进 linesAdded
+    if (changeLines > 0 && filePath) {
+        // Task 3.3：按 phase 选白名单（techDesign/propose/apply/review），而非笼统用 isCodeFile
+        const track = isTrackedFileForPhase(filePath, progress.phase, changeDir);
+        if (!track.tracked) {
+            correctionDebugLog(`skipped/out-of-phase-whitelist`, 'skipped', 0);
+            appendAccuracyDebugLog(changeDir, {
+                type: 'skip.out-of-phase-whitelist',
+                phase: progress.phase,
+                trigger: 'hook',
+                changeId,
+                skipReason: 'out-of-phase-whitelist',
+                input: { tool: toolName, file: filePath, changeLines },
+            });
+        }
+        else {
+            estimatedLines = changeLines;
+            const trackedKind = track.kind;
+            const trackedPhase = progress.phase;
+            // 确保 accuracy 结构存在
             if (!progress.accuracy) {
                 progress.accuracy = {
                     aiLinesAdded: 0, aiLinesModified: 0, aiTotalLines: 0,
                     userCorrectionLines: 0, accuracyRate: 1.0,
-                    correctionEdits: [],
+                    correctionEdits: [], phaseAccuracy: [],
                 };
             }
-            progress.accuracy.userCorrectionLines = (progress.accuracy.userCorrectionLines || 0) + changeLines;
-            progress.accuracy.correctionEdits = progress.accuracy.correctionEdits || [];
-            progress.accuracy.correctionEdits.push({
-                filePath,
-                editLines: changeLines,
-                source: 'user',
-                strategy: 'correction-context',
-                agentType: progress.correctionContext?.path,
-                timestamp,
-            });
-            correctionDebugLog(`${toolName}/correction`, 'userCorrectionLines', changeLines);
-        }
-        else {
-            // 正常 AI 产出
-            progress.linesAdded += changeLines;
-            correctionDebugLog(`${toolName}/normal`, 'linesAdded', changeLines);
+            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'。
+                    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;
+                    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', changeLines);
+                    appendAccuracyDebugLog(changeDir, {
+                        type: 'correction.record',
+                        phase: trackedPhase,
+                        kind: trackedKind,
+                        trigger: 'hook',
+                        changeId,
+                        input: {
+                            tool: toolName,
+                            file: filePath,
+                            changeLines,
+                            contentSource,
+                            ccSource,
+                            promptId,
+                            promptIndex,
+                        },
+                        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' });
+            // 统一同步 accuracy.json
+            await persistAccuracyJson(changeDir, progress);
         }
     }
     else {
-        // 未进入计量分支：记录原因（非代码文件 / 字段缺失 / 非写入工具）
+        // 未进入计量分支：记录原因（字段缺失 / 非写入工具）
         if (toolName === 'Write' || toolName === 'Edit' || toolName === 'MultiEdit') {
             const reason = !filePath
                 ? 'no-file-path'
-                : !isCodeFile(filePath)
-                    ? 'non-code-file'
-                    : changeLines === 0
-                        ? `empty-${contentSource}`
-                        : 'unknown';
+                : changeLines === 0
+                    ? `empty-${contentSource}`
+                    : 'unknown';
             correctionDebugLog(`skipped/${reason}`, 'skipped', 0);
+            appendAccuracyDebugLog(changeDir, {
+                type: `skip.${reason}`,
+                phase: progress.phase,
+                trigger: 'hook',
+                changeId,
+                skipReason: reason,
+                input: { tool: toolName, file: filePath || null, changeLines, contentSource },
+            });
         }
     }
     const tokenUsageFromEnv = Number(process.env.ZHUANSPEC_TOKEN_USAGE || 0);
@@ -756,31 +931,10 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
             // Ignore tasks.md read errors
         }
     }
-    // === 合并 .correction-log 到 progress.corrections（供 Stop hook 沉淀询问使用）===
-    try {
-        const correctionLogPath = path.join(changeDir, '.correction-log');
-        if (existsSync(correctionLogPath)) {
-            const content = readFileSync(correctionLogPath, 'utf-8');
-            const parsed = [];
-            for (const line of content.split('\n')) {
-                const trimmed = line.trim();
-                if (!trimmed)
-                    continue;
-                try {
-                    parsed.push(JSON.parse(trimmed));
-                }
-                catch {
-                    // skip malformed line
-                }
-            }
-            if (parsed.length > 0) {
-                progress.corrections = parsed;
-            }
-        }
-    }
-    catch {
-        // ignore correction log read errors
-    }
+    // v2.15.16 Sprint 3：.correction-log → progress.corrections 的合并逻辑已下线。
+    // 纠偏明细现由 user-input-hook 写入 user_inputs.json（correctionSignal / postBaseline /
+    // resolution 字段），review 步骤 0 与 knowledge skill 模式 B 均直接读 user_inputs.json，
+    // 不再依赖 progress.corrections。
     // Write progress file atomically
     await atomicWriteJson(progressPath, progress);
     // Also update tool_calls.json separately for detailed tracking

package/dist/core/hooks/summarize.js

@@ -8,10 +8,11 @@
  * 4. Generate events.json entries for key events
  */
 import path from 'path';
+import { promises as fsPromises } from 'fs';
 import { execSync } from 'child_process';
 import { FileSystemUtils } from '../../utils/file-system.js';
 import { executePostApply } from './post-apply.js';
-import { getBeijingTime, detectActiveChange } from './record-progress.js';
+import { getBeijingTime, detectActiveChange, atomicWriteJson } from './record-progress.js';
 import { computeAccuracy } from '../metrics/code-accuracy.js';
 import { detectHookHost, sanitizeCodexEnvelope } from '../../utils/hook-host.js';
 export async function summarizeHook(options) {
@@ -215,6 +216,29 @@ async function runSummarize() {
             systemMessage += `- AI产出: ${accResult.aiTotalLines} 行\n`;
             systemMessage += `- 用户纠正: ${accResult.userCorrectionLines} 行\n`;
             systemMessage += `- 准确率: ${(accResult.rate * 100).toFixed(1)}%${accResult.overridden ? ' (已手动修正)' : ''}\n`;
+            // 分阶段准确率（Task 5）：按 phase/trackedKind 展示桶级快照；历史数据无桶时降级提示
+            const buckets = progressData.accuracy.phaseAccuracy ?? [];
+            systemMessage += `\n分阶段准确率:\n`;
+            if (buckets.length === 0) {
+                systemMessage += `- —（历史数据，无分阶段指标）\n`;
+            }
+            else {
+                for (const b of buckets) {
+                    const rawPct = ((b.accuracyRateRaw ?? b.accuracyRate ?? 1) * 100).toFixed(1);
+                    const showPct = ((b.accuracyRate ?? 1) * 100).toFixed(1);
+                    const overrideCount = b.overrideHistory?.length ?? 0;
+                    const lastReason = overrideCount > 0
+                        ? b.overrideHistory[overrideCount - 1].reason
+                        : '';
+                    const confirmedTag = b.confirmed
+                        ? `✓已确认(${b.confirmed.by})`
+                        : '未确认';
+                    const overrideTag = overrideCount > 0
+                        ? ` override=${overrideCount}次(${lastReason})`
+                        : '';
+                    systemMessage += `- [${b.phase}/${b.trackedKind}] AI=${b.aiTotalLines} 纠偏=${b.userCorrectionLines} raw=${rawPct}% 展示=${showPct}%${overrideTag} ${confirmedTag}\n`;
+                }
+            }
         }
     }
     if (allTasksComplete) {
@@ -260,7 +284,7 @@ async function runSummarize() {
             `2. **用户选"是"**：**必须调用 \`@skill:zhuanspec:knowledge --mode=correction --correction <change-id>\`** （或等价的 \`/zhuanspec:knowledge\` slash command 并在交互中选择模式 B）完成沉淀。`,
             `   - change-id 值为 \`${changeId}\``,
             '   - **禁止直接 Write/Edit 创建 \`zhuanspec/knowledge/\` 下的任何文件**，禁止自行判定分类或文件名格式；所有写入由 skill 统一执行。',
-            '   - skill 将自动完成：读取 .correction-log → 分类决策树 → 去重扫描 → 套用统一 Front Matter → 写入对应分类目录 → 更新 index.md → 标记 resolve-correction。',
+            '   - skill 将自动完成：读取 user_inputs.json（Level 1）或 summary 关键词批量扫描（Level 2）→ 分类决策树 → 去重扫描 → 套用统一 Front Matter → 写入对应分类目录 → 更新 index.md → 标记 resolve-correction。',
             '',
             `3. **用户选"否"**：运行 \`zhuanspec progress resolve-correction ${changeId} --mark-pitfall-saved\` 标记已处理，不写入任何知识文件。`,
             '',
@@ -274,6 +298,30 @@ async function runSummarize() {
         ].join('\n');
         systemMessage += `\n⚠️ 检测到 ${n} 次用户纠偏未沉淀——请按上方说明调 askUserQuestion，用户选是后必须调用 @skill:zhuanspec:knowledge 而非自行 Write。\n`;
     }
+    // === Task 0 路径 1：Stop 时按核心产出齐备度自动打 phase baseline ===
+    // 幂等：已打标则跳过；先到先得（auto-file-complete 优于 auto-stop）
+    try {
+        if (['techDesign', 'propose', 'apply', 'review'].includes(phase)) {
+            const outputsReady = await isPhaseOutputsComplete(phase, changeDir, allTasksComplete);
+            if (outputsReady && await FileSystemUtils.fileExists(progressPath)) {
+                const fullProgress = JSON.parse(await FileSystemUtils.readFile(progressPath));
+                const now = getBeijingTime();
+                fullProgress.phaseBaselines = fullProgress.phaseBaselines || {};
+                const key = phase;
+                if (!fullProgress.phaseBaselines[key]?.markedAt) {
+                    fullProgress.phaseBaselines[key] = {
+                        markedAt: now,
+                        markedBy: 'auto-file-complete',
+                        firstStopAt: now,
+                    };
+                    await atomicWriteJson(progressPath, fullProgress);
+                }
+            }
+        }
+    }
+    catch {
+        // baseline 打标失败不阻断 summarize 主流程
+    }
     return {
         continue: true,
         systemMessage,
@@ -371,4 +419,44 @@ function computeWaves(tasks) {
     }
     return Array.from(wavesMap.values()).sort((a, b) => a.waveId - b.waveId);
 }
+/**
+ * 判定指定 phase 的核心产出文件是否齐备（Task 0 路径 1 auto-file-complete 的前置条件）。
+ *
+ * 判定标准：
+ * - techDesign → changes/{changeId}/techDesign/ 目录存在且至少有一份 .md 文件
+ * - propose    → proposal.md / tasks.md / design.md 全部存在
+ * - apply      → tasks.md 全部打勾
+ * - review     → review/review-report.md 存在
+ */
+async function isPhaseOutputsComplete(phase, changeDir, allTasksComplete) {
+    if (phase === 'techDesign') {
+        const techDesignDir = path.join(changeDir, 'techDesign');
+        if (!(await FileSystemUtils.directoryExists(techDesignDir)))
+            return false;
+        try {
+            const files = await fsPromises.readdir(techDesignDir);
+            return files.some(f => f.endsWith('.md'));
+        }
+        catch {
+            return false;
+        }
+    }
+    if (phase === 'propose') {
+        const required = ['proposal.md', 'tasks.md', 'design.md'];
+        for (const f of required) {
+            if (!(await FileSystemUtils.fileExists(path.join(changeDir, f)))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (phase === 'apply') {
+        return allTasksComplete;
+    }
+    if (phase === 'review') {
+        const reviewReportPath = path.join(changeDir, 'review', 'review-report.md');
+        return await FileSystemUtils.fileExists(reviewReportPath);
+    }
+    return false;
+}
 //# sourceMappingURL=summarize.js.map

package/dist/core/hooks/user-input-hook.d.ts

@@ -1,9 +1,42 @@
 /**
  * User Input Hook
  *
- * Records user input summary during ZhuanSpec workflow.
- * Tracks user interventions, corrections, confirmations, and additional requests.
+ * 统一的 UserPromptSubmit 入口（v2.15.15 起接管 deviation-check 的纠偏/需求变更注入）：
+ *   1. 过滤 slash/bang 命令、too-short 内容、Codex Ambient Suggestions、10s 窗口重复
+ *   2. 将 prompt 归档到 user_inputs.json（含 fullPrompt + correctionSignal + postBaseline）
+ *   3. baseline 已打标时写 correctionContext（Task 0 post-baseline-prompt 语义）
+ *   4. phase='apply' + postBaseline + 命中 hard 关键词
+ *      → 注入四选一（纠偏）或 AD 两选一（需求变更）additionalContext
+ *      → 同步写 .pending-correction 供 pre-tool hook 拦截 Edit/Write
+ *
+ * 与 deviation-check 的关系：
+ *   - 本 hook 接管 UserPromptSubmit 下原 deviation-check 的全部职责（关键词 + 四选一）
+ *   - deviation-check 保留 pre-tool 分支（检测 .pending-correction → 拦截 Edit/Write）
+ *   - settings.json 模板不再挂 deviation-check 到 UserPromptSubmit；旧项目请跑 zhuanspec update
+ *
+ * v2.15.16 Sprint 3：.correction-log 写入已下线，user_inputs.json 为唯一纠偏事实源。
+ */
+/**
+ * 纠偏信号分级：
+ *  - 'hard' : 命中 USER_CORRECTION_KEYWORDS / REQUIREMENT_CHANGE_KEYWORDS 中的硬关键词
+ *  - 'soft' : 保留位，当前未使用；未来可接入语义/模式匹配
+ *  - 'none' : 无纠偏信号
  */
+export interface CorrectionSignal {
+    kind: 'hard' | 'soft' | 'none';
+    matchedKeywords: string[];
+    isRequirementChange?: boolean;
+}
+/**
+ * 用户对四选一的最终选择。由 `zhuanspec progress resolve-correction` 回写。
+ */
+export interface UserInputResolution {
+    path?: 'A' | 'B' | 'C' | 'D';
+    resolvedAt?: string;
+    note?: string;
+    /** 本条 prompt 是否真的弹了四选一（hard 信号命中即触发） */
+    triggeredFourOption?: boolean;
+}
 interface UserInputOutput {
     continue: boolean;
     systemMessage?: string;
@@ -11,6 +44,9 @@ interface UserInputOutput {
         inputRecorded: boolean;
         triggerType: string;
         summaryLength: number;
+        /** 四选一或 AD 两选一注入时附加 additionalContext/options */
+        additionalContext?: string;
+        options?: string[];
     };
 }
 /**