@zhuan-ai/zhuanspec 2.17.13 → 2.17.15

package/dist/core/hooks/post-apply.d.ts

@@ -16,6 +16,10 @@ interface HookOutput {
         reviewTriggered?: boolean;
         deviationDetected?: boolean;
         deviationFiles?: string[];
+        featureOmissionDetected?: boolean;
+        uncoveredFeatures?: string[];
+        missingScenarios?: string[];
+        partialScenarios?: string[];
     };
 }
 export declare function postApplyHook(options: PostApplyOptions): Promise<void>;

package/dist/core/hooks/post-apply.js

@@ -8,6 +8,7 @@
 import path from 'path';
 import { FileSystemUtils } from '../../utils/file-system.js';
 import { GitRepoDetector } from '../../utils/git-repo-detector.js';
+import { promises as fs } from 'fs';
 import { getBeijingTime, atomicWriteJson, recoverProgressJsonForWrite, } from './record-progress.js';
 import { ensureAccuracySnapshot } from '../metrics/code-accuracy.js';
 import { detectHookHost, sanitizeCodexEnvelope } from '../../utils/hook-host.js';
@@ -44,6 +45,32 @@ async function runPostApplyHook(changeId) {
  * Users should manually run `zhuanspec review <change-id>` in a new session.
  */
 export async function executePostApply(changeDir, repoRoot) {
+    // 0. Feature-omission gate（功能点遗漏闸口）：检测「范围内但未实现」的 Scenario/功能点
+    //    对应问题：PRD 已有功能点被静默漏实现，Review 未拦住。此处提前拦截，afterAction=pause。
+    const omissionResult = await detectFeatureOmission(changeDir);
+    if (omissionResult.detected) {
+        const parts = [];
+        if (omissionResult.uncoveredFeatures.length > 0) {
+            parts.push(`功能点遗漏 ${omissionResult.uncoveredFeatures.length} 个: ${omissionResult.uncoveredFeatures.join(', ')}`);
+        }
+        if (omissionResult.missingScenarios.length > 0) {
+            parts.push(`未实现 Scenario ${omissionResult.missingScenarios.length} 个`);
+        }
+        if (omissionResult.partialScenarios.length > 0) {
+            parts.push(`疑似未实现(partial) Scenario ${omissionResult.partialScenarios.length} 个`);
+        }
+        return {
+            continue: false,
+            systemMessage: `Post-apply BLOCKED: 检测到范围内功能点/Scenario 未落地（${parts.join('；')}）。请补齐缺失的代码实现（禁止改删 spec/技术方案/PRD），再重新进入 Review。`,
+            hookSpecificOutput: {
+                reviewTriggered: false,
+                featureOmissionDetected: true,
+                uncoveredFeatures: omissionResult.uncoveredFeatures,
+                missingScenarios: omissionResult.missingScenarios,
+                partialScenarios: omissionResult.partialScenarios,
+            },
+        };
+    }
     // 1. Reverse Sync deviation detection
     const deviationResult = await detectDeviation(changeDir, repoRoot);
     // 2. Report deviation status (no auto review trigger)
@@ -75,6 +102,49 @@ export async function executePostApply(changeDir, repoRoot) {
         },
     };
 }
+/**
+ * 功能点遗漏检测：读取 apply 阶段 spec-code 一致性报告，识别「范围内但未实现」的遗漏。
+ *
+ * 数据来源优先级：
+ *   1. review/spec-consistency-result.json（consistency-check Skill 产出，含 uncoveredScenarios/partialScenarios/featureTrace）
+ *   2. 若报告不存在 → 视为未检测（detected=false），不阻断（交由 review 阶段兜底）
+ *
+ * 判定为遗漏（detected=true）的条件（任一命中）：
+ *   - featureTrace.uncoveredFeatures 非空（技术方案功能点 F 无落地 Scenario）
+ *   - uncoveredScenarios 中存在 status=missing 的项
+ *   - partialScenarios 非空（仅命中辅助关键词，疑似未实现）
+ */
+async function detectFeatureOmission(changeDir) {
+    const empty = {
+        detected: false,
+        uncoveredFeatures: [],
+        missingScenarios: [],
+        partialScenarios: [],
+    };
+    const reportPath = path.join(changeDir, 'review', 'spec-consistency-result.json');
+    let report;
+    try {
+        const raw = await fs.readFile(reportPath, 'utf-8');
+        report = JSON.parse(raw);
+    }
+    catch {
+        // 报告不存在或解析失败 → 不阻断，交由 review 阶段兜底
+        return empty;
+    }
+    const uncoveredFeatures = Array.isArray(report.featureTrace?.uncoveredFeatures)
+        ? report.featureTrace.uncoveredFeatures.filter((f) => typeof f === 'string')
+        : [];
+    const missingScenarios = Array.isArray(report.uncoveredScenarios)
+        ? report.uncoveredScenarios
+            .filter(s => s?.status === 'missing')
+            .map(s => s.scenario || '(未命名 Scenario)')
+        : [];
+    const partialScenarios = Array.isArray(report.partialScenarios)
+        ? report.partialScenarios.map(s => s?.scenario || '(未命名 Scenario)')
+        : [];
+    const detected = uncoveredFeatures.length > 0 || missingScenarios.length > 0 || partialScenarios.length > 0;
+    return { detected, uncoveredFeatures, missingScenarios, partialScenarios };
+}
 /**
  * Detect deviation by comparing proposal scope with actual git diff
  */

package/dist/core/hooks/review-hooks.d.ts

@@ -81,6 +81,25 @@ interface SpecConsistencyOutput {
         scenarioId: string;
         description: string;
     }>;
+    /**
+     * 仅命中辅助关键词（类名/表名）、未命中核心关键词的疑似未实现项。
+     * 非空视为未通过——必须澄清为 covered 或补齐代码，禁止改删 spec。
+     */
+    partialScenarios?: Array<{
+        scenario?: string;
+        sourceFeature?: string;
+        matchedKeyword?: string;
+        warning?: string;
+    }>;
+    /**
+     * 功能点 F 编号全链核对结果（以 feature-manifest.json 的 F 编号为分母）。
+     * uncoveredFeatures 非空 = 技术方案功能点无落地 Scenario，属功能点遗漏。
+     */
+    featureTrace?: {
+        totalFeatures?: number;
+        coveredFeatures?: number;
+        uncoveredFeatures?: string[];
+    };
     mapping: Array<{
         requirementId: string;
         scenarioId: string;

package/dist/core/hooks/review-hooks.js

@@ -261,9 +261,17 @@ export async function specConsistencyResultCheck(changeId, skillOutput) {
         };
     }
     const loopCount = output.loopCount || 0;
-    // Check consistency coverage
+    // Check consistency coverage —— 三类缺口任一命中即视为未通过（层4 终检）：
+    //   1. missing：核心与辅助关键词均未命中的 Scenario
+    //   2. partial：仅命中辅助关键词（类名/表名）的疑似未实现项
+    //   3. uncoveredFeatures：feature-manifest 中无落地 Scenario 的功能点 F
+    const partialScenarios = output.partialScenarios || [];
+    const uncoveredFeatures = output.featureTrace?.uncoveredFeatures || [];
     const hasUncovered = output.uncoveredScenarios.length > 0;
-    if (hasUncovered) {
+    const hasPartial = partialScenarios.length > 0;
+    const hasUncoveredFeatures = uncoveredFeatures.length > 0;
+    const hasGap = hasUncovered || hasPartial || hasUncoveredFeatures;
+    if (hasGap) {
         if (loopCount > MAX_LOOP_COUNT) {
             return {
                 pass: false,
@@ -273,6 +281,8 @@ export async function specConsistencyResultCheck(changeId, skillOutput) {
                     consistencyRate: output.consistencyRate,
                     totalScenarios: output.totalScenarios,
                     coveredScenarios: output.coveredScenarios,
+                    partialScenarios,
+                    uncoveredFeatures,
                     loopExceeded: true,
                 },
                 nextAction: 'stop',
@@ -286,12 +296,14 @@ export async function specConsistencyResultCheck(changeId, skillOutput) {
             metrics: {
                 consistencyRate: output.consistencyRate,
                 uncoveredScenarios: output.uncoveredScenarios,
+                partialScenarios,
+                uncoveredFeatures,
             },
             nextAction: 'fix',
             fixPrompt: formatConsistencyFixPrompt(output, loopCount),
         };
     }
-    // PASS: All scenarios covered
+    // PASS: All scenarios covered, no partial, no uncovered features
     return {
         pass: true,
         needFix: false,
@@ -301,6 +313,7 @@ export async function specConsistencyResultCheck(changeId, skillOutput) {
             totalRequirements: output.totalRequirements,
             totalScenarios: output.totalScenarios,
             coveredScenarios: output.coveredScenarios,
+            featureTrace: output.featureTrace,
             mapping: output.mapping,
         },
         nextAction: 'continue',
@@ -709,20 +722,33 @@ function formatMissingUnitTestEvidencePrompt(loopCount) {
 `;
 }
 function formatConsistencyFixPrompt(output, loopCount) {
-    const uncoveredList = output.uncoveredScenarios.map(s => `- ${s.requirementId}/${s.scenarioId}: ${s.description}`).join('\n');
+    const uncoveredList = output.uncoveredScenarios.map(s => `- [missing] ${s.requirementId}/${s.scenarioId}: ${s.description}`).join('\n');
+    const partialScenarios = output.partialScenarios || [];
+    const partialList = partialScenarios.map(s => `- [partial] ${s.scenario || '(未命名)'}${s.sourceFeature ? ` [${s.sourceFeature}]` : ''}: ${s.warning || '仅命中辅助关键词，疑似未实现'}`).join('\n');
+    const uncoveredFeatures = output.featureTrace?.uncoveredFeatures || [];
+    const featureList = uncoveredFeatures.map(f => `- [feature] ${f}: 该功能点无落地 Scenario，属功能点遗漏`).join('\n');
+    const sections = [];
+    if (output.uncoveredScenarios.length > 0) {
+        sections.push(`未覆盖 Scenario（${output.uncoveredScenarios.length} 个）：\n${uncoveredList}`);
+    }
+    if (partialScenarios.length > 0) {
+        sections.push(`疑似未实现 partial（${partialScenarios.length} 个，仅命中类名/表名等辅助关键词）：\n${partialList}`);
+    }
+    if (uncoveredFeatures.length > 0) {
+        sections.push(`遗漏功能点 F（${uncoveredFeatures.length} 个，feature-manifest 有、无落地 Scenario）：\n${featureList}`);
+    }
     return `
 🔄 Spec-Code Consistency Fix Loop (${loopCount}/${MAX_LOOP_COUNT})
 
-发现 ${output.uncoveredScenarios.length} 个未覆盖的 Scenario：
-
-${uncoveredList}
+${sections.join('\n\n')}
 
 ⚠️ 铁律：Spec is Truth — 文档与代码冲突时，错的一定是代码。
-🚫 禁止修改 Spec 文件内容（包括 Requirement 名称、Scenario 描述、Given/When/Then 条件）。
+🚫 绝对禁止为凑覆盖率修改 Spec 文件 / 技术方案 / feature-manifest（包括 Requirement 名称、Scenario 描述、Given/When/Then 条件、[F<n>] 标记）。
 
 请通过以下方式修复：
-1. 补充或修改代码实现，使其满足上述 Scenario 描述的业务诉求
-2. 修复后重新运行 spec-code-consistency 检查验证覆盖情况
+1. 对 missing/partial 项：补齐或修改**代码实现**，使其满足 Scenario 描述的业务诉求（partial 项须命中方法名/接口路径/组件名等核心关键词并通过深度检查）
+2. 对遗漏功能点 F：补齐对应代码实现（而非补 PRD/技术方案）；确因范围裁剪不做的，登记 proposal.md 功能点覆盖对照表并注明理由
+3. 修复后重新运行 spec-code-consistency 检查验证覆盖情况
 `;
 }
 // ============================================================
@@ -797,6 +823,8 @@ ${legacySection}
 | Requirements 数量 | ${results.specConsistency.metrics.totalRequirements || 0} |
 | Scenario 数量 | ${results.specConsistency.metrics.totalScenarios || 0} |
 | 一致性覆盖率 | ${results.specConsistency.metrics.consistencyRate || 0}% |
+| 疑似未实现 partial 数 | ${results.specConsistency.metrics.partialScenarios?.length || 0} |
+| 遗漏功能点 F | ${results.specConsistency.metrics.uncoveredFeatures?.join(', ') || '—'} |
 | 循环次数 | ${results.specConsistency.loopCount} |
 | 状态 | ${results.specConsistency.pass ? '✅ PASS' : '❌ FAIL'} |
 

package/dist/core/templates/slash-command-templates.js

@@ -5,6 +5,10 @@ const baseGuardrails = `**约束条件**
 - **工作区边界（强制）**：查找文档、检索工程代码、执行 grep/glob/ls 时，范围必须限定在当前 ZhuanSpec 工作区内。禁止使用 \`../**\`、上级目录绝对路径或手动拼接到工作区外路径。Glob 返回相对路径时，必须以本次工具调用的 \`path\` 参数作为基准拼接绝对路径，不得误解为当前目录或上级目录。
 - **知识库参考**：开始任何阶段前，先检查 \`zhuanspec/knowledge/\` 目录。使用 \`rg "[关键词]" zhuanspec/knowledge/\` 搜索相关陷阱和最佳实践，避免重复踩坑。阅读 \`zhuanspec/knowledge/index.md\` 了解项目级知识摘要。
 - **工程代码检索顺序**：凡是需要检索工程代码、配置类、数据模型类或关键实现位置时，必须先调用 \`@skill:load-project-knowledge\` 进行渐进式加载，使用返回的 search_priority 限定检索范围，按优先路径定位代码。Skill 返回的 \`matched_services[].micro_path\` 即各服务 \`.project-wiki/\` 下的知识条目路径，按需读取其中子文档（无论 Skill 内部走 llmwiki 还是 project.md 路径，最终内容均来自各服务的 \`.project-wiki/\`）。仅当 Skill 无匹配结果时，才回退到 \`grep/glob/ls\`。
+- **需求来源读取（红线，全阶段适用）**：读取需求来源（技术方案输入、测试 case、验收标准等）时，按链接类型选用对应读取方式，禁止张冠李戴：
+  * **大神页面**（\`zhuanspirit\` 大神文档 / \`--dashen-page-id\` / \`--dashen-url\`）：用大神 MCP 工具（如 \`mcp__dashen__getPageContent\`）读取。
+  * **zzcase 测试用例**（\`zzcase.zhuanspirit.com/plan/taskDetail/module/{moduleId}/task/{taskId}\`）：从 URL 提取 \`moduleId\`，用 \`mcp__caseweb__GET_get2\` 读取。
+  * **飞书链接**（\`project.feishu.cn/{space}/story/detail/{id}\` 需求工作项、\`xxx.feishu.cn/wiki/{token}\`、\`xxx.feishu.cn/docx/{id}\` 文档）：**禁止用 Fetch/WebFetch 直接抓取飞书网页**（会被安全域名校验拦截而失败），必须用本机飞书 CLI \`lark-cli\` 读取正文（通过 Bash 调用；不确定子命令时先执行 \`lark-cli --help\` 确认用法）。若 lark-cli 未安装/未授权/读取失败，如实报告失败原因与用户需处理的动作（安装 \`npm install -g @larksuite/cli\` 或执行 \`lark-cli auth login\` 授权），不要编造需求内容。
 - 如果需要额外的 ZhuanSpec 约定或澄清，请参考 \`zhuanspec/AGENTS.md\`（位于 \`zhuanspec/\` 目录内 - 如果看不到，请运行 \`ls zhuanspec\` 或 \`zhuanspec update\`）。`;
 const proposalGuardrails = `${baseGuardrails}\n- **强制澄清要求**：在创建任何提案文件之前，必须首先分析用户请求，识别所有不确定或模糊的方面（范围、技术选择、优先级、验收标准等）。如果发现任何模糊之处，必须停止并使用**选项式交互**（如 \`AskQuestion\` 工具）提问，获得明确答复后才能继续。严禁在不确定的情况下自行推测、假设或创建提案。严禁要求用户手动输入大段文字来回答澄清问题。
 - 识别任何模糊或歧义的细节，使用带预设选项的选择题在编辑文件之前询问必要的后续问题。
@@ -215,6 +219,13 @@ const proposalSteps = `**步骤**
 
 6. 在 \`changes/<id>/specs/<capability>/spec.md\` 中起草规范增量（每个功能一个文件夹），使用 \`## ADDED|MODIFIED|REMOVED Requirements\`，每个要求至少包含一个 \`#### Scenario:\`，并在相关时交叉引用相关功能。
 
+   ⚠️ **CHECKPOINT [SCENARIO-FEATURE-TRACE]（提案↔技术方案主键回填）**：
+   当存在技术方案（techDesign/tech-spec.md 或 techDesign/feature-manifest.json）时，本次提案是技术方案 checkList 的下游实现，必须做到「挨个核对、逐条回填」：
+   1. **每个 \`#### Scenario:\` 标题末尾必须携带来源标记 \`[F<数字>]\`**（如 \`#### Scenario: 导出发送成员列表 [F6]\`），F 编号取自 techDesign/feature-manifest.json 或 tech-spec.md checkList 的功能点编号；一个 Scenario 覆盖多个功能点时写 \`[F3,F6]\`。
+   2. **技术方案 checkList / feature-manifest 中的每一个 F 编号，必须在本提案的 spec.md 中至少被一个 Scenario 覆盖**——这是逐项核对，不允许「整体看着差不多」就跳过。
+   3. 核对方式：列出 feature-manifest 全部 F 编号 → 逐个在 spec.md 中搜索 \`[F<n>]\` → 记录命中/缺失。存在缺失的 F 编号即为**遗漏功能点**，必须补齐 Scenario 后才能进入下一步，禁止以「补 PRD / 补技术方案」绕过（PRD/技术方案是上游真相，不得为迁就实现而反向删改）。
+   4. 若某个 F 编号本次确实不实现，必须在 proposal.md 的 **功能点覆盖对照表** 中显式标注「本期不做 + 理由 + 负责方确认」，而非静默丢弃。
+
    ⚠️ **CHECKPOINT [SPEC-REQUIREMENT-FORMAT]**：
    每个 \`### Requirement:\` 块写完后必须自检以下两点，违反任意一条 \`zhuanspec validate\` 会报 ERROR：
    1. **必须有需求描述文本**：header 之后、第一个 \`#### Scenario\` 之前，必须至少有一行非空的需求描述文本；不能直接从 \`### Requirement:\` 跳到 \`#### Scenario:\`。
@@ -279,14 +290,18 @@ const proposalSteps = `**步骤**
      * 循环结束后仍未通过：输出错误报告，等待人工干预
    - 验证通过后，继续下一步
 
-9. **技术方案覆盖度自动完善**（当存在技术方案文档时：techDesign/ 目录下的 tech-spec.md，或用户指定了本地技术方案路径）：
+9. **技术方案覆盖度自动完善**（当存在技术方案文档时：techDesign/ 目录下的 tech-spec.md / feature-manifest.json，或用户指定了本地技术方案路径）：
    - 运行覆盖度检查（通过 Skill \`@skill:tech-spec-coverage-check\`）
+   - **功能点(F编号)逐项覆盖核对（强制，先于元素级补全）**：
+     * 读取 techDesign/feature-manifest.json 的全部功能点编号（F1…Fn）；无 manifest 时退化为解析 tech-spec.md checkList 的编号
+     * 逐个 F 编号在本次 specs/ 各 spec.md 中检索 \`[F<n>]\` 标记，产出 \`uncoveredFeatures\`（在技术方案中存在、但提案 Scenario 未覆盖的 F 编号列表）
+     * \`uncoveredFeatures\` 非空即判定为**功能点遗漏**：必须为每个缺失 F 补齐带 \`[F<n>]\` 标记的 Scenario；确因范围裁剪不做的，登记到 proposal.md 功能点覆盖对照表并标注理由，不得静默省略
    - 如果发现未覆盖的技术方案元素，**自动补充到对应提案文件**：
      * 未覆盖的数据库表/API → 自动追加到 specs/ 对应 spec.md 的 Requirements 中
      * 未覆盖的类名/接口 → 自动追加到 tasks.md 作为新任务项
      * 未覆盖的配置项/基础设施 → 自动追加到 design.md 对应章节
-   - 补充完成后重新检查覆盖率，确认 >= 90%
-   - 将覆盖度报告写入 metrics/tech-spec-coverage.json
+   - 补充完成后重新检查覆盖率，确认 \`uncoveredFeatures\` 为空 且 元素覆盖率 >= 90%
+   - 将覆盖度报告写入 metrics/tech-spec-coverage.json（含 uncoveredFeatures 字段）
 
 10. **提案详细度检查（AI 可执行性验证）**：
    验证提案内容是否足够详细，确保 AI 能够仅凭提案内容完整执行所有任务，无需额外猜测或澄清。
@@ -598,6 +613,20 @@ const applySteps = `**步骤**
       - **立刻移交 B5 统一执行重跑**（不得拖到全局 Concerns 汇总；不得将 NEEDS_CONTEXT 当 DONE_WITH_CONCERNS 混过）
       - 若清单为空（本 Wave 无需重跑）→ 显式写 \`— 无需重跑\`，禁止省略该段
 
+   B4.2. **Scenario 逐项核对（本 Wave，MANDATORY GATE）——「实施代码 ↔ propose 的 Scenario 挨个核对」**：
+      - **目的**：本 Wave 涉及的每个 Scenario 实施完成即刻与代码核对，尽早暴露遗漏，避免堆积到 Review 才发现（对应「PRD 已有功能点被静默漏实现」的防线）
+      - **执行**：调用 \`spec-code-consistency-check\` Skill，**scope 限定为本 Wave 覆盖的 Scenario**（按本 Wave 任务映射的 spec.md Scenario 及其 \`[F\\d+]\` 标记筛选）：
+        a. 对每个 Scenario 用**核心关键词**（方法名 / 接口路径 / 组件名 / Consumer 类名 / ES 索引名）精确搜索，仅命中类名/表名等**辅助关键词**不算覆盖（标 \`partial\`）
+        b. 对 \`covered\` 项执行深度检查（方法体 > 3 行、有业务调用链、非 stub/TODO-only）
+        c. 聚合本 Wave 涉及的 \`[F\\d+]\` 编号，核对每个 F 是否有落地的 Scenario
+      - **判定（任一不满足 → 本 Wave GATE FAIL，阻断进入下一 Wave）**：
+        * 无 \`missing\`（核心与辅助关键词均未命中的 Scenario）
+        * 无 \`partial\`（仅命中辅助关键词的疑似项必须澄清为 covered 或补齐代码）
+        * 无 \`todo-only\` / \`stub-suspected\`（骨架冒充完成）
+        * 本 Wave 的 \`featureTrace.uncoveredFeatures\` 为空
+      - **发现遗漏时的唯一正确动作**：**补齐缺失的代码实现**（回到 B5 以 \`Execution Mode = RETRY\` 重新下发对应任务）；🚫 **绝对禁止**为凑覆盖率而改删 spec.md / 技术方案 / feature-manifest（上游是真相，Spec is Truth）
+      - **写回集成报告**：新增 \`## 🔍 本 Wave Scenario 核对\` 段，列出每个 Scenario 的 \`status\`（covered/partial/missing）、命中关键词类型（core/aux）、深度检查结果、sourceFeature；即使全部通过也要写 \`— 全部覆盖\`
+
    B5. **阻塞任务重试（BLOCKED ∪ NEEDS_CONTEXT 合并处理）**：
       - 重试对象覆盖两类：
         a. 编译失败 / 测试失败被标记为 \`BLOCKED\` 的任务（原有范围）
@@ -742,7 +771,7 @@ const archiveReferences = `**参考**
 - 会话分析 (\`session-analytics\`)：记录本次会话的效率指标，用于改进工作流。`;
 const designGuardrails = `${baseGuardrails}\n- **独立设计阶段**：techDesign 命令用于在 proposal 之前生成技术设计请求文档，不依赖变更提案。设计文档可作为后续提案的输入。
 - **Skill 调用连续性（红线）**：在 techDesign 流程中调用任何辅助类 Skill（如 \`@skill:load-project-knowledge\`）后，**必须立即推进到下一编号步骤**，禁止把 Skill 的输出当作流程终态，禁止停顿等待用户输入“继续/下一步”等确认词。只有在显式标注的 AskUserQuestion 步骤（如开发范围确认、需求来源确认、外部依赖确认）才允许暂停等待用户。
-- **需求澄清优先**：在生成设计请求前，必须确认需求来源（大神页面、需求描述文本等）。
+- **需求澄清优先**：在生成设计请求前，必须确认需求来源（大神页面、飞书链接/文档、需求描述文本等）；飞书链接的读取方式见 baseGuardrails 的「需求来源读取」红线。
 - **开发范围前置确认（硬约束）**：在调用技术方案 Skill 前，**必须**先通过 AskUserQuestion 确认开发范围是“仅后端开发”还是“全栈开发”，根据答复选择对应 Skill（仅后端=\`generate-tech-spec-md-skill\`，全栈=\`generate-fullstack-tech-spec-skill\`），禁止默认或跳过此确认环节。
 - **Skill 可用性前置检查（硬约束）**：在实际调用技术方案 Skill 前，**必须**先校验目标 Skill 是否已安装且可用；**若不可用，立即中断流程**并提示用户到 Skill 市场安装对应 Skill，禁止以人工编写/其他 Skill 代替。
 - **Skill 调用为主**：技术方案生成主要通过 \`generate-tech-spec-md-skill\`（仅后端）或 \`generate-fullstack-tech-spec-skill\`（全栈）Skill 完成，而非直接运行 CLI 命令。
@@ -873,25 +902,7 @@ const designSteps = `**步骤**
    - **状态为 ⚠️ 的依赖**：必须说明兜底方案（如"ES 不可用时用 DB 查询兜底"）
    - 该矩阵将被 propose/apply 阶段复用，作为 Subagent L1 上下文注入的根据
 
-7.5. **测试 Case 生成（可选，选项式确认）**：
-   - 使用 AskUserQuestion 询问用户是否需要基于当前技术方案生成测试 case：
-     * header: "测试Case生成"
-     * question: "技术方案已生成，是否需要基于当前方案生成测试 case？"
-     * 选项 A：生成测试 case（推荐） → description: 调用 test-case-generator 技能，基于技术方案和需求文档自动生成测试用例，产出将用于后续 Propose 阶段的 TDD 流程
-     * 选项 B：跳过，不生成 → description: 跳过测试 case 生成，后续 Propose 阶段仍可手动提供测试 case
-   - 用户选择"生成测试 case"：
-     * 从 \`techDesign/tech-spec.md\` 的 \`## 文档信息\` 表格中提取"需求来源"字段（可能是 dashen URL 或飞书文档链接）
-     * 调用 \`@skill:test-case-generator\` 技能：
-       - 输入技术方案：\`techDesign/tech-spec.md\` 全文
-       - 输入需求来源：提取到的 URL（skill 内部根据链接类型通过 dashen MCP / 飞书文档 API 读取需求正文）
-     * 输出目录：\`changes/<change-id>/techDesign/\`（测试 case 源文件）
-     * Skill 完成后，在 progress.json 的 events 字段追加：\`{ "event": "test-case-generated", "source": "test-case-generator", "timestamp": "<ISO>" }\`
-     * ⚠️ **继续执行步骤 8（输出摘要），不得在此停留**
-   - 用户选择"跳过"：
-     * 在 progress.json 的 events 字段追加：\`{ "event": "test-case-skipped", "timestamp": "<ISO>" }\`
-     * 直接进入步骤 8
-
-7.6. **涉及工程清单输出（阶段 6 定稿产物，必须生成）**：
+7.5. **涉及工程清单输出（阶段 6 定稿产物，必须生成）**：
    - 在技术方案定稿时，从 Skill 生成的 \`tech-spec.md\`、\`matched_services\` 和改动点定位结果中提取涉及工程
    - 输出到与技术方案同目录：
      \`zhuanspec/changes/{change-id}/techDesign/affected-projects.md\`
@@ -911,7 +922,6 @@ const designSteps = `**步骤**
    - 告知用户生成的文档路径和实际调用的 Skill 名称
    - 告知用户涉及工程清单路径：\`zhuanspec/changes/{change-id}/techDesign/affected-projects.md\`
    - **明确说明**：techDesign 阶段仅保存进度数据（progress.json）、技术方案（含外部依赖矩阵）和涉及工程清单，不创建 proposal.md 和 tasks.md
-   - 如果步骤 7.5 生成了测试 case，额外提示：「✅ 已生成测试 case 源文件，后续 Propose 阶段将自动启用 TDD 模式并调用 tdd-testcase-generator 转换为研发 TDD testcase」
    - 提示 phase=techDesign
    - 提示下一步可以使用 \`/zhuanspec:proposal\` 创建变更提案（复用目录）`;
 const designReferences = `**参考**
@@ -977,17 +987,18 @@ const reviewSteps = `**步骤**
 
 2. **执行最多六轨顺序串行校验（强制前四轨 + 可选后两轨）**：按 2.1 → 2.2 → 2.3 → 2.4 → 2.5 → 2.6 顺序逐轨执行，**禁止并行**，前一轨未完成禁止启动后一轨。
 
-   **2.1 轨道 1 — Spec-Code 一致性轨**
+   **2.1 轨道 1 — Spec-Code 一致性轨（含功能点 F 编号全链终检，「再次核验 1-3 项」）**
    - 进入条件：Phase 已切换为 review。
    - 执行动作：
      - 运行 \`zhuanspec validate <change-id> --strict\`，确认 \`spec-code-consistent\` 规则通过。
-     - 读取 \`zhuanspec/changes/<id>/specs/**/spec.md\` 中全部 Requirement/Scenario，核对是否均有代码实现落点。
-   - 自闭环修复（最多 3 轮）：发现 \`uncoveredScenarios\` 非空时，遵循"Spec is Truth"铁律，**只修改代码实现**使其匹配 Scenario，**禁止修改 spec 文件**，修复后重跑 validate。
+     - **全量调用 \`spec-code-consistency-check\` Skill**（Review 触发 = 全量终检，覆盖全部 Scenario，而非仅某 Wave）：对每个 Scenario 用**核心关键词**精确定位，仅命中类名/表名等辅助关键词标 \`partial\`；对 \`covered\` 项做深度检查（方法体 > 3 行、有业务调用链、非 stub/TODO-only）。
+     - **F 编号全链核对（再次核验层1-3）**：以 \`techDesign/feature-manifest.json\` 的 F 编号为分母，聚合各 Scenario 标题末尾的 \`[F\\d+]\` 标记，核对每个功能点 F 是否有落地且非 stub 的 Scenario；缺失的计入 \`featureTrace.uncoveredFeatures\`。
+   - 自闭环修复（最多 3 轮）：发现 \`uncoveredScenarios\` / \`partialScenarios\` 非空或 \`uncoveredFeatures\` 非空时，遵循"Spec is Truth"铁律，**只补齐/修改代码实现**使其匹配 Scenario，**🚫 绝对禁止修改 spec 文件 / 技术方案 / feature-manifest**，修复后重跑 validate + Skill。
    - 产物落盘：**AI 将结果写入** \`zhuanspec/changes/<id>/review/spec-consistency-result.json\`，格式：
      \`\`\`json
-     { "consistencyRate": 100, "totalRequirements": 0, "totalScenarios": 0, "coveredScenarios": 0, "uncoveredScenarios": [], "mapping": [], "loopCount": 0 }
+     { "consistencyRate": 100, "totalRequirements": 0, "totalScenarios": 0, "coveredScenarios": 0, "uncoveredScenarios": [], "partialScenarios": [], "featureTrace": { "totalFeatures": 0, "coveredFeatures": 0, "uncoveredFeatures": [] }, "mapping": [], "loopCount": 0 }
      \`\`\`
-   - 退出条件：\`consistencyRate === 100\` 且 \`uncoveredScenarios.length === 0\`。未通过禁止进入 2.2。
+   - 退出条件（全部满足）：\`consistencyRate === 100\` 且 \`uncoveredScenarios.length === 0\` 且 \`partialScenarios.length === 0\` 且 \`featureTrace.uncoveredFeatures.length === 0\`。任一不满足禁止进入 2.2。
 
    **2.2 轨道 2 — Unit Test 轨（必须调用 Skill）**
    - 进入条件：2.1 已 PASS。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhuan-ai/zhuanspec",
-  "version": "2.17.13",
+  "version": "2.17.15",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "zhuanspec",
@@ -39,6 +39,26 @@
     "!dist/**/__tests__",
     "!dist/**/*.map"
   ],
+  "scripts": {
+    "lint": "eslint src/",
+    "build": "node build.js",
+    "dev": "tsc --watch",
+    "dev:cli": "pnpm build && node bin/zhuanspec.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage",
+    "test:postinstall": "node scripts/postinstall.js",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node scripts/postinstall.js",
+    "check:pack-version": "node scripts/pack-version-check.mjs",
+    "diagnose:cursor": "node scripts/diagnose-cursor-commands.js",
+    "release": "pnpm run release:ci",
+    "release:ci": "pnpm run check:pack-version && pnpm exec changeset publish",
+    "release:local": "pnpm exec changeset version && pnpm run check:pack-version && pnpm exec changeset publish",
+    "changeset": "changeset"
+  },
   "engines": {
     "node": ">=20.19.0"
   },
@@ -60,23 +80,5 @@
     "ora": "^8.2.0",
     "yaml": "^2.8.2",
     "zod": "^4.0.17"
-  },
-  "scripts": {
-    "lint": "eslint src/",
-    "build": "node build.js",
-    "dev": "tsc --watch",
-    "dev:cli": "pnpm build && node bin/zhuanspec.js",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:ui": "vitest --ui",
-    "test:coverage": "vitest --coverage",
-    "test:postinstall": "node scripts/postinstall.js",
-    "postinstall": "node scripts/postinstall.js",
-    "check:pack-version": "node scripts/pack-version-check.mjs",
-    "diagnose:cursor": "node scripts/diagnose-cursor-commands.js",
-    "release": "pnpm run release:ci",
-    "release:ci": "pnpm run check:pack-version && pnpm exec changeset publish",
-    "release:local": "pnpm exec changeset version && pnpm run check:pack-version && pnpm exec changeset publish",
-    "changeset": "changeset"
   }
-}
+}