@autobest-ui/agent 1.0.7 → 1.0.8

package/bin/traceability-validators.test.mjs

@@ -156,25 +156,70 @@ test('spec 校验器验证完整映射和输入哈希', async t => {
   const fixture = await createTraceableScope();
   t.after(() => fs.rm(fixture.root, { recursive: true, force: true }));
   const review = {
-    schemaVersion: 1,
+    schemaVersion: 2,
+    sessionStatus: 'complete',
+    userConfirmed: true,
     scope: {
       manifestPath: '../scope-manifest.json',
       directory: '01-product-detail',
       scopePath: 'scope.md'
     },
+    rounds: [{ round: 1, questionIds: ['Q001'] }],
+    questions: [{
+      id: 'Q001',
+      requirementIds: ['REQ-PD-001'],
+      area: 'dataContract',
+      parentQuestionIds: [],
+      question: '主图字段使用哪个接口字段？',
+      recommendation: '使用 PRD 明确的新字段。',
+      affectedAcceptance: '决定主图数据来源。',
+      status: 'answered',
+      answer: '使用新字段',
+      answeredBy: 'user'
+    }],
     requirements: [{
       id: 'REQ-PD-001',
       scopeStatus: 'active',
       reviewStatus: 'confirmed',
+      decisionCoverage: {
+        scopeBoundary: 'evidence',
+        dataContract: 'user',
+        emptyError: 'not-applicable',
+        stateInteraction: 'not-applicable',
+        permission: 'not-applicable',
+        responsiveVisual: 'evidence',
+        acceptanceEvidence: 'evidence'
+      },
+      questionIds: ['Q001'],
       decisions: ['商品主图必须可见'],
+      evidenceRefs: ['scope.md#REQ-PD-001'],
       remainingIssues: []
     }],
+    openFrontier: [],
     scopeUpdatesRequired: []
   };
   const spec = '# 商品详情功能规格\n\n## REQ-PD-001 商品主图\n\n### 验收条件\n\n- 商品主图可见。\n';
   const reviewText = `${JSON.stringify(review, null, 2)}\n`;
   await fs.writeFile(path.join(fixture.pageDir, 'review/review-result.json'), reviewText);
   assert.equal(runValidator(reviewValidator, fixture.pageDir).status, 0);
+
+  const incompleteReview = structuredClone(review);
+  incompleteReview.userConfirmed = false;
+  incompleteReview.questions[0].status = 'open';
+  delete incompleteReview.questions[0].answer;
+  delete incompleteReview.questions[0].answeredBy;
+  incompleteReview.requirements[0].reviewStatus = 'unresolved';
+  incompleteReview.requirements[0].decisionCoverage.dataContract = 'open';
+  incompleteReview.requirements[0].remainingIssues = ['主图字段尚未确定'];
+  incompleteReview.openFrontier = ['Q001'];
+  await fs.writeFile(
+    path.join(fixture.pageDir, 'review/review-result.json'),
+    `${JSON.stringify(incompleteReview, null, 2)}\n`
+  );
+  const incomplete = runValidator(reviewValidator, fixture.pageDir);
+  assert.equal(incomplete.status, 1);
+  assert.match(incomplete.stderr, /complete 会话/);
+  await fs.writeFile(path.join(fixture.pageDir, 'review/review-result.json'), reviewText);
   await fs.writeFile(path.join(fixture.pageDir, 'spec.md'), spec);
   const trace = {
     schemaVersion: 1,

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@autobest-ui/agent",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "private": false,
   "description": "Autobest Agent skills/plugins/mcp assets + sync cli",
   "files": [
     "skills",
     "plugins",
-    "!plugins/**/node_modules",
-    "!plugins/**/.runtime",
     "mcp",
-    "bin"
+    "bin",
+    "!**/node_modules",
+    "!**/.runtime"
   ],
   "type": "module",
   "engines": {

package/skills/README.md

@@ -18,7 +18,7 @@ npx --yes --package=@autobest-ui/agent@latest autobest-agent-sync common
 - `review-from-docs`
 - `ui-prd-scope`
 
-其中 `ui-prd-scope` 使用 `REQ-<页面或Scope简称>-<三位序号>` 分配稳定需求 ID；`review-from-docs` 以该编号记录质询结论；`make-spec` 生成逐项可验收的 `spec.md` 和机器可校验的映射。后续交付角色只引用编号，不重新编号。
+其中 `ui-prd-scope` 使用 `REQ-<页面或Scope简称>-<三位序号>` 分配稳定需求 ID；`review-from-docs` 为每个 REQ 建立决策树，逐轮询问当前完整 frontier 并记录用户确认的结论；`make-spec` 只从已完成的 review 生成逐项可验收的 `spec.md` 和机器可校验的映射。后续交付角色只引用编号，不重新编号。
 
 ## React
 

package/skills/common/make-spec/SKILL.md

@@ -13,7 +13,7 @@ description: 根据带稳定 REQ 编号的页面 scope 和 review-result 生成
 - `review/review-result.json`，以及它引用的 Figma 和证据。
 - 可选的既有 `spec.md` 与 `spec-traceability.json`；刷新时保留稳定编号和仍适用的验收边界。
 
-Manifest 必须声明 `traceabilitySchemaVersion: 1`。任何 `active` 需求缺少质询记录、仍为 `unresolved`，或 scope、review 的编号和状态不一致时停止，返回需要继续 `$review-from-docs` 或回写 scope 的具体编号。
+Manifest 必须声明 `traceabilitySchemaVersion: 1`，Review 必须使用 Schema v2、`sessionStatus: complete` 且已经由用户确认。任何 `active` 需求缺少质询记录、仍为 `unresolved`，或 scope、review 的编号和状态不一致时停止，返回需要继续 `$review-from-docs` 或回写 scope 的具体编号。
 
 ## 生成
 

package/skills/common/make-spec/scripts/validate-spec-traceability.mjs

@@ -56,6 +56,10 @@ if (trace) {
   if (manifest && manifest.traceabilitySchemaVersion !== 1) {
     fail('Manifest 未启用 traceabilitySchemaVersion: 1');
   }
+  if (review && review.schemaVersion !== 2) fail('Review schemaVersion 必须为 2');
+  if (review && (review.sessionStatus !== 'complete' || review.userConfirmed !== true)) {
+    fail('Review 必须完成多轮质询并由用户确认');
+  }
 
   for (const [label, filePath, expected] of [
     ['Scope', scopePath, trace.scope?.scopeSha256],

package/skills/common/review-from-docs/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: review-from-docs
-description: 围绕已有页面 scope、PRD、RAG、Figma 和仓库证据逐条质询需求，保留稳定 REQ 编号并生成结构化 review-result。用户要求评审、质询或澄清 scope，或需要在生成 spec 前消除需求冲突时使用；不生成最终 spec 或业务代码。
+description: 基于页面 scope、PRD、RAG、Figma 和仓库证据，对带 REQ 编号的需求进行决策树式多轮质询并生成结构化 review-result。用户要求评审、质询或澄清 scope，或需要在生成 spec 前消除需求冲突时使用；不生成最终 spec 或业务代码。
 ---
 
 # 基于文档质询需求
 
-以用户指定的页面 `scope.md` 为入口，把每个需求的冲突、歧义和缺失决策质询到可生成规格的状态。开始前完整读取 [需求追踪契约](../ui-prd-scope/references/requirement-traceability.md) 和 [质询结果 Schema](references/review-result-schema.md)。
+以用户指定的页面 `scope.md` 为入口，把每个需求的冲突、歧义和缺失决策质询到可生成规格的状态。质询方式沿用 Matt `grilling` 的决策树和 frontier 机制，同时用 REQ ID 保持范围、问题、结论和后续 Spec 的映射。开始前完整读取 [需求追踪契约](../ui-prd-scope/references/requirement-traceability.md) 和 [质询结果 Schema](references/review-result-schema.md)。
 
 ## 输入
 
@@ -15,19 +15,33 @@ description: 围绕已有页面 scope、PRD、RAG、Figma 和仓库证据逐条
 
 输入未声明 `traceabilitySchemaVersion: 1`、非全局 scope 缺少需求编号，或 scope 与 manifest 的编号不一致时停止并要求先用 `$ui-prd-scope` 刷新范围包。本 Skill 不创建、修改或重排需求编号。
 
-## 质询
+## 建立决策树
 
 1. 建立 manifest 中全部需求的台账，保留 `active`、`deferred` 和 `removed`。逐条核对 scope 原文、PRD、RAG、Figma 与仓库事实；证据优先级沿用 scope，不把历史 RAG 或当前实现升级为新需求。
-2. 对每个 `active` 需求检查行为、状态转换、权限、空态/错误态、响应式、UI 状态、数据前置和可观察验收结果。已有证据能唯一回答时记录证据结论；需要业务取舍时向用户提问。
-3. 每次只提出一个相互关联的决策组，明确列出 `REQ-ID`、证据冲突、缺失信息和该回答会影响的验收边界。不得用默认值替用户消解业务冲突。
-4. 用户回答后立即更新内存台账；结论必须落到对应 `REQ-ID`。用户明确暂缓或取消时记录状态和原因，但不修改 scope manifest 的生命周期状态；将需要回写 scope 的差异列入 `scopeUpdatesRequired`。
-5. 所有问题处理完毕，按 Schema 写入并复读 `review/review-result.json` 和 `review/review-result.md`。两份产物结论一致，Markdown 使用简体中文，JSON 保持机器字段。
-6. 执行 `node .agents/skills/review-from-docs/scripts/validate-review-traceability.mjs <页面 scope 目录>`；根据实际安装位置调整脚本路径。校验失败时修正质询产物，不修改或放宽 scope 编号。
+2. 为每个 active REQ，以及影响多个 REQ 的跨需求决策，建立有依赖关系的决策树。至少覆盖 Schema 中定义的七个决策领域；不适用的领域显式标为 `not-applicable`，不能因未检查而省略。
+3. 事实查证由 Agent 完成：继续阅读可用文档、代码、配置和本地资产。证据能够唯一回答的节点标为 `evidence` 并记录引用；只有需要产品、设计或业务取舍的节点进入用户质询。不得把可以从材料查到的事实转嫁给用户，也不得用推荐答案替用户作业务决定。
+4. 每个决策节点记录前置节点。当前所有前置条件已经解决的未决节点共同构成 frontier；依赖本轮答案的下游问题留到下一轮。
+
+## 多轮质询
+
+1. 每一轮一次性询问整个 frontier，而不是只问一个 REQ 或一个最明显的问题。一个 REQ 可以有多个问题，一个问题也可以关联多个 REQ。
+2. 问题按 `Q1`、`Q2` 顺序展示。每题必须包含：关联 REQ ID、简短标题、具体缺口或冲突、问题及必要选项、受影响的验收边界，以及推荐答案和理由。没有真实选择时不要制造选项。
+3. 一轮只包含彼此不依赖、用户现在即可回答的问题。输出本轮问题后停止并等待用户回答，不生成最终结果，也不把未回答问题标为已确认。
+4. 用户回答后，将答案映射回对应问题和全部关联 REQ，更新决策树并重新计算 frontier。继续提出下一轮，直到所有分支均已访问且 frontier 为空。
+5. 用户回答顺带暴露新分支、矛盾或边界时，把它加入决策树；不能因最初清单没有列出而忽略。用户明确暂缓、取消或暂停质询时记录原因，不自行推断。
+6. frontier 为空后，先向用户汇总每个 REQ 的决策和验收边界，请用户确认已达成共同理解。只有用户确认后，才能把会话标为 `complete` 并生成最终产物。
+
+## 写入结果
+
+用户确认完成后，按 Schema 写入并复读 `review/review-result.json` 和 `review/review-result.md`。用户明确暂停时可以写入 `sessionStatus: paused` 的中间结果，并保留全部开放问题；普通问答回合不写成完成结果。两份产物结论一致，Markdown 使用简体中文，JSON 保持机器字段。
+
+执行 `node .agents/skills/review-from-docs/scripts/validate-review-traceability.mjs <页面 scope 目录>`；根据实际安装位置调整脚本路径。校验失败时修正质询产物，不修改或放宽 scope 编号。
 
 ## 完成条件
 
 - Manifest 中每个需求在结果中恰好出现一次，没有未知编号。
-- 每个 `active` 需求为 `confirmed` 或 `unresolved`；只有证据或用户回答足以确定验收边界时才能标为 `confirmed`。
-- `confirmed` 需求至少包含一条 `decisions`，`unresolved` 需求至少包含一条 `remainingIssues`。
-- 用户要求生成可交付 Spec 时，任何 `active` 需求仍为 `unresolved` 都是明确阻断，不得伪装为默认结论。
+- 每个 active REQ 的七个决策领域都有明确状态；一个 REQ 可关联任意数量问题，不能把 REQ 当作单个问题。
+- `sessionStatus: complete` 时所有问题已回答、所有 active REQ 均为 `confirmed`、不存在 `open` 决策领域或 `remainingIssues`，并且用户已确认共同理解。
+- `sessionStatus: paused` 只用于用户明确暂停；未决问题和 frontier 必须原样保留，后续从该位置继续。
+- 任何 active 需求仍为 `unresolved` 都会阻断 `$make-spec`，不得用默认结论或推荐答案伪装成已确认。
 - 最终答复列出 confirmed/unresolved/deferred/removed 数量、产物路径和需要回写 scope 的生命周期变化；不生成 `spec.md`、不修改业务代码。

package/skills/common/review-from-docs/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "需求文档质询"
-  short_description: "按需求编号质询 scope 中的冲突、歧义和缺失信息"
-  default_prompt: "使用 $review-from-docs 逐条质询当前 scope，并生成带需求编号的 review-result。"
+  short_description: "按需求编号进行决策树式多轮质询"
+  default_prompt: "使用 $review-from-docs 对当前 scope 建立决策树，逐轮询问完整 frontier，并生成带需求编号的 review-result。"

package/skills/common/review-from-docs/references/review-result-schema.md

@@ -1,42 +1,88 @@
-# Review Result Schema
+# Review Result Schema v2
 
-质询结果写入页面 scope 目录下的 `review/review-result.json`：
+质询结果写入页面 scope 目录下的 `review/review-result.json`。v2 用问题轮次和决策覆盖证明质询已遍历完整决策树，而不是只记录一个最明显的缺失项。
 
 ```json
 {
-  "schemaVersion": 1,
+  "schemaVersion": 2,
+  "sessionStatus": "complete",
+  "userConfirmed": true,
   "scope": {
     "manifestPath": "../scope-manifest.json",
     "directory": "01-product-detail",
     "scopePath": "scope.md"
   },
+  "rounds": [{ "round": 1, "questionIds": ["Q001", "Q002"] }],
+  "questions": [
+    {
+      "id": "Q001",
+      "requirementIds": ["REQ-PD-001"],
+      "area": "emptyError",
+      "parentQuestionIds": [],
+      "question": "图片加载失败时是否保留 4:3 占位？",
+      "recommendation": "保留容器比例并显示默认占位图，避免页面跳动。",
+      "affectedAcceptance": "决定错误态的布局和视觉验收条件。",
+      "status": "answered",
+      "answer": "是，显示默认占位图",
+      "answeredBy": "user"
+    }
+  ],
   "requirements": [
     {
       "id": "REQ-PD-001",
       "scopeStatus": "active",
       "reviewStatus": "confirmed",
-      "questions": [
-        {
-          "question": "图片加载失败时是否保留 4:3 占位？",
-          "answer": "是，显示默认占位图",
-          "answeredBy": "user"
-        }
-      ],
+      "decisionCoverage": {
+        "scopeBoundary": "evidence",
+        "dataContract": "user",
+        "emptyError": "user",
+        "stateInteraction": "not-applicable",
+        "permission": "not-applicable",
+        "responsiveVisual": "evidence",
+        "acceptanceEvidence": "user"
+      },
+      "questionIds": ["Q001"],
       "decisions": ["加载失败时保持 4:3 容器并显示默认占位图"],
       "evidenceRefs": ["scope.md#REQ-PD-001", "mobile-default.json#12:34"],
       "remainingIssues": []
     }
   ],
+  "openFrontier": [],
   "scopeUpdatesRequired": []
 }
 ```
 
-## 约束
+## 决策领域
+
+每个 active REQ 必须包含全部领域，不能省略未检查项：
+
+| area | 检查内容 |
+| --- | --- |
+| `scopeBoundary` | PR 增量归属、范围内外、与其他 REQ 的边界 |
+| `dataContract` | 字段来源、格式、空值、编码、兼容和前后端责任 |
+| `emptyError` | 空态、缺失值、异常、失败和回退行为 |
+| `stateInteraction` | 初始状态、转换、交互、导航和副作用 |
+| `permission` | 登录、权限、角色和不可访问状态 |
+| `responsiveVisual` | Desktop/Mobile、断点、Figma 状态和视觉差异 |
+| `acceptanceEvidence` | 可观察结果、fixture、验证方式和证据来源 |
+
+领域状态只使用 `evidence`、`user`、`not-applicable`、`open`。`evidence` 必须能由 `evidenceRefs` 定位；`user` 必须至少关联一个已回答问题；`not-applicable` 表示已经检查并确认不适用，不能代表未检查。
+
+## 问题与轮次
+
+- 问题 ID 使用当前 review 内稳定且唯一的 `Q001`、`Q002` 格式；REQ 映射由非空 `requirementIds` 表达。
+- `parentQuestionIds` 记录必须先解决的问题，依赖关系不得成环；子问题必须出现在所有父问题之后的轮次。每轮只包含当时没有未解决父问题的完整 frontier。
+- `area` 必须是七个决策领域之一。跨领域问题拆开；跨 REQ 的同一业务决策可在一个问题中列出多个 `requirementIds`。
+- `status` 使用 `open` 或 `answered`。`answered` 必须包含 `answer` 和 `answeredBy`；`answeredBy` 使用 `user` 或 `evidence`。
+- 每个问题恰好出现在一个 `rounds[].questionIds` 中。`openFrontier` 只列当前可立即回答的开放问题；依赖未解决父问题的节点不属于 frontier。
+
+## 会话状态
+
+- `sessionStatus` 只使用 `complete` 或 `paused`。
+- `complete` 必须满足：`userConfirmed: true`、所有问题均为 `answered`、`openFrontier` 为空、所有 active REQ 均为 `confirmed`、全部决策领域不为 `open`、`remainingIssues` 为空。
+- `paused` 只在用户明确暂停时使用，`userConfirmed` 必须为 `false`；保留所有开放问题、依赖关系、当前 frontier 和未解决项，供下一次继续。
+- `deferred` 和 `removed` REQ 的 `reviewStatus` 必须与 scope 状态一致，不要求七领域覆盖。
 
-- `scope.manifestPath`、`scope.scopePath` 和所有本地产物路径相对于页面 scope 目录。
-- `scopeStatus` 使用 `active`、`deferred`、`removed`。
-- `reviewStatus` 使用 `confirmed`、`unresolved`、`deferred`、`removed`；后两者必须与 scope 状态相同。
-- `answeredBy` 使用 `user` 或 `evidence`。证据回答必须在同一需求的 `evidenceRefs` 中可定位。
-- `scopeUpdatesRequired` 只记录用户在质询中改变生命周期的需求，例如 `{ "id": "REQ-PD-003", "targetStatus": "deferred", "reason": "本迭代不实现" }`。它不是对 manifest 的静默修改授权。
+`scopeUpdatesRequired` 只记录用户在质询中改变生命周期的需求，例如 `{ "id": "REQ-PD-003", "targetStatus": "deferred", "reason": "本迭代不实现" }`。它不是对 manifest 的静默修改授权。
 
-`review-result.md` 按需求编号展示原始需求、证据、问题、回答、最终决策和未解决项，并在顶部汇总各状态数量。
+`review-result.md` 按轮次列出问题、建议与回答，再按 REQ 汇总七领域覆盖、最终决策和未解决项。推荐答案与用户最终答案必须明确区分。

package/skills/common/review-from-docs/scripts/validate-review-traceability.mjs

@@ -6,7 +6,19 @@ import path from 'node:path';
 const featureDir = path.resolve(process.argv[2] || '.');
 const errors = [];
 const requirementPattern = /^REQ-[A-Z][A-Z0-9]{1,15}-\d{3}$/;
+const questionPattern = /^Q\d{3}$/;
 const reviewStatuses = new Set(['confirmed', 'unresolved', 'deferred', 'removed']);
+const questionStatuses = new Set(['open', 'answered']);
+const coverageStatuses = new Set(['evidence', 'user', 'not-applicable', 'open']);
+const decisionAreas = [
+  'scopeBoundary',
+  'dataContract',
+  'emptyError',
+  'stateInteraction',
+  'permission',
+  'responsiveVisual',
+  'acceptanceEvidence'
+];
 const fail = message => errors.push(message);
 
 function readJson(filePath, label) {
@@ -26,7 +38,10 @@ const reviewPath = path.join(featureDir, 'review/review-result.json');
 const review = readJson(reviewPath, 'review-result.json');
 
 if (review) {
-  if (review.schemaVersion !== 1) fail('review-result.schemaVersion 必须为 1');
+  if (review.schemaVersion !== 2) fail('review-result.schemaVersion 必须为 2');
+  if (!['complete', 'paused'].includes(review.sessionStatus)) {
+    fail('review-result.sessionStatus 必须为 complete 或 paused');
+  }
   const manifestPath = path.resolve(featureDir, review.scope?.manifestPath || '');
   const scopePath = path.resolve(featureDir, review.scope?.scopePath || '');
   const manifest = readJson(manifestPath, 'scope-manifest.json');
@@ -43,10 +58,90 @@ if (review) {
   const expected = new Map(
     (manifestScope?.requirements || []).map(item => [item.id, item])
   );
+
+  const questions = Array.isArray(review.questions) ? review.questions : [];
+  const questionIds = questions.map(item => item?.id);
+  const questionById = new Map(questions.map(item => [item?.id, item]));
+  if (questionById.size !== questions.length) fail('review-result 包含重复问题 ID');
+  const roundQuestionIds = [];
+  if (!Array.isArray(review.rounds)) {
+    fail('review-result.rounds 必须是数组');
+  } else {
+    review.rounds.forEach((round, index) => {
+      if (round?.round !== index + 1) fail('rounds 必须从 1 开始连续编号');
+      if (!Array.isArray(round?.questionIds) || round.questionIds.length === 0) {
+        fail(`第 ${index + 1} 轮必须包含 questionIds`);
+      } else {
+        roundQuestionIds.push(...round.questionIds);
+      }
+    });
+  }
+  if (new Set(roundQuestionIds).size !== roundQuestionIds.length) {
+    fail('同一问题不得出现在多个轮次');
+  }
+  for (const id of questionIds) {
+    if (!roundQuestionIds.includes(id)) fail(`问题未归入任何轮次：${id}`);
+  }
+  for (const id of roundQuestionIds) {
+    if (!questionById.has(id)) fail(`轮次引用未知问题：${id}`);
+  }
+  const questionRound = new Map();
+  for (const round of review.rounds || []) {
+    for (const id of round.questionIds || []) questionRound.set(id, round.round);
+  }
+
+  for (const question of questions) {
+    if (!questionPattern.test(question?.id || '')) fail(`问题编号格式无效：${question?.id}`);
+    if (!decisionAreas.includes(question?.area)) fail(`${question?.id} 的 area 无效`);
+    if (!questionStatuses.has(question?.status)) fail(`${question?.id} 的 status 无效`);
+    for (const field of ['question', 'recommendation', 'affectedAcceptance']) {
+      if (typeof question?.[field] !== 'string' || !question[field].trim()) {
+        fail(`${question?.id} 缺少 ${field}`);
+      }
+    }
+    if (!Array.isArray(question?.requirementIds) || question.requirementIds.length === 0) {
+      fail(`${question?.id} 必须关联至少一个 REQ ID`);
+    } else {
+      for (const id of question.requirementIds) {
+        if (!expected.has(id)) fail(`${question?.id} 引用了未知需求：${id}`);
+      }
+    }
+    if (!Array.isArray(question?.parentQuestionIds)) {
+      fail(`${question?.id} 缺少 parentQuestionIds`);
+    } else {
+      for (const parentId of question.parentQuestionIds) {
+        if (!questionById.has(parentId)) fail(`${question?.id} 引用了未知父问题：${parentId}`);
+        if (parentId === question.id) fail(`${question.id} 不能依赖自身`);
+        if (questionRound.has(parentId) && questionRound.get(parentId) >= questionRound.get(question.id)) {
+          fail(`${question.id} 必须位于父问题 ${parentId} 之后的轮次`);
+        }
+      }
+    }
+    if (question.status === 'answered') {
+      if (typeof question.answer !== 'string' || !question.answer.trim()) {
+        fail(`${question.id} 已回答但缺少 answer`);
+      }
+      if (!['user', 'evidence'].includes(question.answeredBy)) {
+        fail(`${question.id} 已回答但 answeredBy 无效`);
+      }
+    }
+  }
+  const visited = new Set();
+  const visiting = new Set();
+  const hasCycle = id => {
+    if (visiting.has(id)) return true;
+    if (visited.has(id)) return false;
+    visiting.add(id);
+    const cyclic = (questionById.get(id)?.parentQuestionIds || []).some(hasCycle);
+    visiting.delete(id);
+    visited.add(id);
+    return cyclic;
+  };
+  if (questionIds.some(hasCycle)) fail('问题依赖不能形成循环');
+
   const requirements = Array.isArray(review.requirements) ? review.requirements : [];
   const ids = requirements.map(item => item?.id);
   if (new Set(ids).size !== ids.length) fail('review-result 包含重复需求 ID');
-
   for (const id of expected.keys()) {
     if (!ids.includes(id)) fail(`review-result 缺少需求：${id}`);
   }
@@ -60,18 +155,39 @@ if (review) {
       fail(`review-result 包含未知需求：${item.id}`);
       continue;
     }
-    if (item.scopeStatus !== source.status) {
-      fail(`${item.id} 的 scopeStatus 与 manifest 不一致`);
-    }
-    if (!reviewStatuses.has(item.reviewStatus)) {
-      fail(`${item.id} 的 reviewStatus 无效：${item.reviewStatus}`);
-    }
+    if (item.scopeStatus !== source.status) fail(`${item.id} 的 scopeStatus 与 manifest 不一致`);
+    if (!reviewStatuses.has(item.reviewStatus)) fail(`${item.id} 的 reviewStatus 无效`);
     if (source.status === 'active' && !['confirmed', 'unresolved'].includes(item.reviewStatus)) {
       fail(`${item.id} 是 active，reviewStatus 必须为 confirmed 或 unresolved`);
     }
     if (source.status !== 'active' && item.reviewStatus !== source.status) {
       fail(`${item.id} 的排除状态必须保持为 ${source.status}`);
     }
+    if (source.status === 'active') {
+      for (const area of decisionAreas) {
+        const status = item.decisionCoverage?.[area];
+        if (!coverageStatuses.has(status)) fail(`${item.id} 的 ${area} 覆盖状态无效`);
+        if (status === 'evidence' && (!Array.isArray(item.evidenceRefs) || item.evidenceRefs.length === 0)) {
+          fail(`${item.id} 的 ${area} 由 evidence 解决但缺少 evidenceRefs`);
+        }
+        if (status === 'user' && !questions.some(question =>
+          question.status === 'answered' &&
+          question.answeredBy === 'user' &&
+          question.area === area &&
+          question.requirementIds?.includes(item.id)
+        )) {
+          fail(`${item.id} 的 ${area} 标为 user 但缺少对应已回答问题`);
+        }
+      }
+      const expectedQuestionIds = questions
+        .filter(question => question.requirementIds?.includes(item.id))
+        .map(question => question.id)
+        .sort();
+      const itemQuestionIds = Array.isArray(item.questionIds) ? [...item.questionIds].sort() : [];
+      if (JSON.stringify(expectedQuestionIds) !== JSON.stringify(itemQuestionIds)) {
+        fail(`${item.id} 的 questionIds 与问题映射不一致`);
+      }
+    }
     if (item.reviewStatus === 'confirmed' &&
       (!Array.isArray(item.decisions) || item.decisions.length === 0)) {
       fail(`${item.id} 已 confirmed 但缺少 decisions`);
@@ -81,6 +197,34 @@ if (review) {
       fail(`${item.id} 仍 unresolved 但缺少 remainingIssues`);
     }
   }
+
+  const calculatedFrontier = questions
+    .filter(question => question.status === 'open' &&
+      question.parentQuestionIds?.every(id => questionById.get(id)?.status === 'answered'))
+    .map(question => question.id)
+    .sort();
+  const openFrontier = Array.isArray(review.openFrontier)
+    ? [...review.openFrontier].sort()
+    : [];
+  if (JSON.stringify(calculatedFrontier) !== JSON.stringify(openFrontier)) {
+    fail('openFrontier 与当前可回答问题不一致');
+  }
+
+  if (review.sessionStatus === 'complete') {
+    if (review.userConfirmed !== true) fail('complete 会话必须由用户确认');
+    if (questions.some(item => item.status !== 'answered')) fail('complete 会话不能包含开放问题');
+    for (const item of requirements.filter(item => item.scopeStatus === 'active')) {
+      if (item.reviewStatus !== 'confirmed') fail(`complete 会话仍有未确认需求：${item.id}`);
+      if (Object.values(item.decisionCoverage || {}).includes('open')) {
+        fail(`complete 会话仍有开放决策领域：${item.id}`);
+      }
+      if (!Array.isArray(item.remainingIssues) || item.remainingIssues.length !== 0) {
+        fail(`complete 会话仍有 remainingIssues：${item.id}`);
+      }
+    }
+  } else if (review.userConfirmed !== false) {
+    fail('paused 会话的 userConfirmed 必须为 false');
+  }
   if (!Array.isArray(review.scopeUpdatesRequired)) {
     fail('review-result.scopeUpdatesRequired 必须是数组');
   }