@ranger1/dx 0.1.39 → 0.1.40

package/@opencode/agents/claude-reviewer.md

@@ -31,6 +31,21 @@ tools:
 - 写入 reviewFile：`./.cache/review-CLD-pr<PR_NUMBER>-r<ROUND>-<RUN_ID>.md`
 - findings id 必须以 `CLD-` 开头
 
+## 决策日志约束（强制）
+
+如果 prompt 中提供了 `decisionLogFile`，必须先读取并遵守以下规则：
+
+1. **已修复问题**：不再提出本质相同的问题
+2. **已拒绝问题**：
+   - 若你的发现 priority 比原问题高 ≥2 级（如 P3→P1, P2→P0），可以升级质疑
+   - 否则不再提出
+
+判断"问题本质相同"时，比对 decision-log 中的 `essence` 字段与你发现的问题描述。
+
+### 禁止事项
+- ⛔ 不质疑已修复问题的实现方式（除非发现修复引入了新 bug）
+- ⛔ 不重复提出已拒绝问题（除非满足升级质疑条件）
+
 ## Cache 约定（强制）
 
 - 缓存目录固定为 `./.cache/`；交接一律传 `./.cache/<file>`（repo 相对路径），禁止 basename-only（如 `foo.md`）。

package/@opencode/agents/codex-reviewer.md

@@ -32,6 +32,21 @@ tools:
 - 写入 reviewFile：`./.cache/review-CDX-pr<PR_NUMBER>-r<ROUND>-<RUN_ID>.md`
 - findings id 必须以 `CDX-` 开头
 
+## 决策日志约束（强制）
+
+如果 prompt 中提供了 `decisionLogFile`，必须先读取并遵守以下规则：
+
+1. **已修复问题**：不再提出本质相同的问题
+2. **已拒绝问题**：
+   - 若你的发现 priority 比原问题高 ≥2 级（如 P3→P1, P2→P0），可以升级质疑
+   - 否则不再提出
+
+判断"问题本质相同"时，比对 decision-log 中的 `essence` 字段与你发现的问题描述。
+
+### 禁止事项
+- ⛔ 不质疑已修复问题的实现方式（除非发现修复引入了新 bug）
+- ⛔ 不重复提出已拒绝问题（除非满足升级质疑条件）
+
 ## Cache 约定（强制）
 
 - 缓存目录固定为 `./.cache/`；交接一律传 `./.cache/<file>`（repo 相对路径），禁止 basename-only（如 `foo.md`）。

package/@opencode/agents/gemini-reviewer.md

@@ -31,6 +31,21 @@ tools:
 - 写入 reviewFile：`./.cache/review-GMN-pr<PR_NUMBER>-r<ROUND>-<RUN_ID>.md`
 - findings id 必须以 `GMN-` 开头
 
+## 决策日志约束（强制）
+
+如果 prompt 中提供了 `decisionLogFile`，必须先读取并遵守以下规则：
+
+1. **已修复问题**：不再提出本质相同的问题
+2. **已拒绝问题**：
+   - 若你的发现 priority 比原问题高 ≥2 级（如 P3→P1, P2→P0），可以升级质疑
+   - 否则不再提出
+
+判断"问题本质相同"时，比对 decision-log 中的 `essence` 字段与你发现的问题描述。
+
+### 禁止事项
+- ⛔ 不质疑已修复问题的实现方式（除非发现修复引入了新 bug）
+- ⛔ 不重复提出已拒绝问题（除非满足升级质疑条件）
+
 ## Cache 约定（强制）
 
 - 缓存目录固定为 `./.cache/`；交接一律传 `./.cache/<file>`（repo 相对路径），禁止 basename-only（如 `foo.md`）。

package/@opencode/agents/gh-thread-reviewer.md

@@ -100,3 +100,18 @@ python3 ~/.opencode/agents/gh_review_harvest.py \
 - ⛔ 不发布 GitHub 评论（不调用 `gh pr comment/review`）
 - ⛔ 不修改代码（只输出 reviewFile）
 - ⛔ 不生成/伪造 runId
+
+## 决策日志约束（强制）
+
+如果 prompt 中提供了 `decisionLogFile`，必须先读取并遵守以下规则：
+
+1. **已修复问题**：不再提出本质相同的问题
+2. **已拒绝问题**：
+   - 若你的发现 priority 比原问题高 ≥2 级（如 P3→P1, P2→P0），可以升级质疑
+   - 否则不再提出
+
+判断"问题本质相同"时，比对 decision-log 中的 `essence` 字段与你发现的问题描述。
+
+### 禁止事项
+- ⛔ 不质疑已修复问题的实现方式（除非发现修复引入了新 bug）
+- ⛔ 不重复提出已拒绝问题（除非满足升级质疑条件）

package/@opencode/agents/pr-fix.md

@@ -81,7 +81,7 @@ Round: 2
 
 解析规则（强制）：
 
-- 仅处理 `## IssuesToFix` 段落里的条目；`## OptionalIssues` 可忽略或按需处理
+- 仅处理 `## IssuesToFix` 段落里的条目；`## OptionalIssues` 可忽略或按需处理（建议：根据 PR 目标/风险/时间预算自行裁决）
 - 每条必须至少包含：`id`、`priority`、`file`、`title`、`suggestion`
 - `line` 允许为 `null`
 
@@ -134,6 +134,68 @@ Round: 2
 `fixReportFile: ./.cache/<file>.md`
 
 
+## Decision Log 输出（强制）
+
+修复完成后，必须生成/追加 Decision Log 文件，用于跨轮次的决策持久化存储。
+
+### 文件路径
+
+`./.cache/decision-log-pr<PR_NUMBER>.md`
+
+### 格式规范
+
+```markdown
+# Decision Log
+
+PR: <PR_NUMBER>
+
+## Round <ROUND>
+
+### Fixed
+
+- id: <FINDING_ID>
+  commit: <SHA>
+  essence: <问题本质的一句话描述>
+
+### Rejected
+
+- id: <FINDING_ID>
+  priority: <P0|P1|P2|P3>
+  reason: <拒绝原因>
+  essence: <问题本质的一句话描述>
+```
+
+### 追加规则（强制）
+
+- 如果文件不存在：创建新文件，包含 `# Decision Log` 头、`PR: <PR_NUMBER>` 字段，以及第一个 `## Round <ROUND>` 段落
+- 如果文件存在：追加新的 `## Round <ROUND>` 段落到文件末尾
+- **禁止删除或覆盖历史轮次的记录**
+
+### essence 字段要求
+
+essence 是问题本质的一句话描述，用于后续轮次的智能匹配和重复检测。要求：
+
+- 简洁性：≤ 50 字
+- 问题导向：描述问题核心（而非具体代码位置、文件行号）
+- 可匹配性：后续轮次的 reviewer 能通过关键词匹配识别该问题
+
+**示例对比：**
+
+| ✅ 好的 essence | ❌ 不好的 essence |
+|---|---|
+| "JSON.parse 未捕获异常" | "apps/backend/src/foo.ts 第 42 行缺少 try/catch" |
+| "缺少输入验证" | "在 UserController 中没有验证 username 参数" |
+| "密码明文存储" | "第 156 行 password 字段未加密" |
+
+### Decision Log 的用途
+
+Decision Log 供后续工作流参考：
+
+- **pr-review-loop**：检查 decision-log 是否存在，避免重复提出已拒绝的问题
+- **pr-review-aggregate**：使用 LLM 智能匹配 essence 字段，识别本轮与历史轮的重复问题
+- **交接文档**：跨团队成员阅读，理解历史决策
+
+
 ## fixReportFile 内容格式（强制）
 
 fixReportFile 内容必须是可直接粘贴到 GitHub 评论的 Markdown，且不得包含本地缓存文件路径。

package/@opencode/agents/pr-review-aggregate.md

@@ -61,9 +61,37 @@ runId: abcdef123456
 {"duplicateGroups":[["CDX-001","CLD-003"],["GMN-002","CLD-005","CDX-004"]]}
 ```
 
+## 智能匹配（仅在模式 A + decision-log 存在时）
+
+如果 decision-log（`./.cache/decision-log-pr<PR_NUMBER>.md`）存在，你需要基于 LLM 判断每个新 finding 与已决策问题的本质是否相同，从而生成 **escalation_groups** 参数。
+
+**流程**：
+
+1. 读取 decision-log，提取已 rejected 问题的 `essence` 字段
+2. 逐个新 finding，与所有已 rejected 问题的 essence 做语义比对（使用 LLM）
+3. 判断是否"问题本质相同"（即便表述不同）
+4. 收集可升级的问题（重新质疑阈值）：
+   - **升级阈值**：优先级差距 ≥ 2 级
+   - 例如：已 rejected P3 but finding 为 P1 → 可升级质疑
+   - 例如：已 rejected P2 but finding 为 P0 → 可升级质疑
+   - 例如：已 rejected P2 but finding 为 P1 → 不升级（仅差 1 级）
+5. 生成**一行 JSON**（不要代码块、不要解释文字、不要换行），结构如下：
+
+```json
+{"escalationGroups":[["CDX-001"],["GMN-002","CLD-005"]]}
+```
+
+其中每个组表示「可以作为已 rejected 问题的升级质疑」的 finding ID 集合。若无可升级问题，输出空数组：
+
+```json
+{"escalationGroups":[]}
+```
+
+注意：escalation_groups JSON **不是你的最终输出**，它只用于生成 `--escalation-groups-b64` 传给脚本。
+
 ## 调用脚本（强制）
 
-模式 A（带 reviewFile + 重复分组）：
+模式 A（带 reviewFile + 重复分组 + 智能匹配）：
 
 ```bash
 python3 ~/.opencode/agents/pr_review_aggregate.py \
@@ -74,9 +102,17 @@ python3 ~/.opencode/agents/pr_review_aggregate.py \
   --review-file <REVIEW_FILE_1> \
   --review-file <REVIEW_FILE_2> \
   --review-file <REVIEW_FILE_3> \
-  --duplicate-groups-b64 <BASE64_JSON>
+  --duplicate-groups-b64 <BASE64_JSON> \
+  --decision-log-file ./.cache/decision-log-pr<PR_NUMBER>.md \
+  --escalation-groups-b64 <BASE64_JSON>
 ```
 
+**参数说明**：
+
+- `--duplicate-groups-b64`：base64 编码的 JSON，格式同上，例如 `eyJkdXBsaWNhdGVHcm91cHMiOltbIkNEWC0wMDEiLCJDTEQtMDAzIl1dfQ==`
+- `--decision-log-file`：decision-log 文件路径（可选；若不存在则跳过智能匹配逻辑）
+- `--escalation-groups-b64`：base64 编码的 escalation groups JSON，格式如上，例如 `eyJlc2NhbGF0aW9uR3JvdXBzIjpbWyJDRFgtMDAxIl1dfQ==`
+
 模式 B（带 fixReportFile）：
 
 ```bash
@@ -98,3 +134,10 @@ python3 ~/.opencode/agents/pr_review_aggregate.py \
 - **失败/异常时**：
   - 若脚本 stdout 已输出合法 JSON（包含 `error` 或其他字段）→ 仍然**原样返回该 JSON**。
   - 若脚本未输出合法 JSON / 退出异常 → 仅输出一行 JSON：`{"error":"PR_REVIEW_AGGREGATE_AGENT_FAILED"}`（必要时可加 `detail` 字段）。
+
+## fixFile 结构（补充说明）
+
+脚本在模式 A 下生成的 fixFile 分为两段：
+
+- `## IssuesToFix`：只包含 P0/P1（必须修）
+- `## OptionalIssues`：包含 P2/P3（由 pr-fix 自主决定是否修复/或拒绝并说明原因）

package/@opencode/agents/pr_review_aggregate.py

@@ -23,7 +23,9 @@
 # - Comment body must NOT contain local filesystem paths (this script scrubs cache paths, $HOME, and repo absolute paths).
 #
 # fixFile rules:
-# - fixFile includes ONLY P0/P1/P2 findings.
+# - fixFile includes all findings, split into:
+#   - IssuesToFix: P0/P1 (must fix)
+#   - OptionalIssues: P2/P3 (pr-fix may decide)
 # - Each merged duplicate group keeps ONE canonical id; merged IDs are appended into canonical description.
 # - Do NOT rewrite id prefixes (CDX-/CLD-/GMN-); preserve reviewer-provided finding IDs.
 
@@ -220,6 +222,202 @@ def _parse_duplicate_groups_b64(s):
         return []
 
 
+def _parse_escalation_groups_json(s):
+    """Parse escalation groups JSON (same format as duplicate groups)."""
+    if not s:
+        return []
+    try:
+        data = json.loads(s)
+    except Exception:
+        return []
+
+    groups = []
+    if isinstance(data, dict) and isinstance(data.get("escalationGroups"), list):
+        groups = data.get("escalationGroups")
+    elif isinstance(data, list):
+        groups = data
+    else:
+        return []
+
+    out = []
+    for g in (groups or []):
+        if not isinstance(g, list):
+            continue
+        ids = []
+        for it in g:
+            if isinstance(it, str) and it.strip():
+                ids.append(it.strip())
+        ids = list(dict.fromkeys(ids))
+        if len(ids) >= 2:
+            out.append(ids)
+    return out
+
+
+def _parse_escalation_groups_b64(s):
+    """Decode base64 escalation groups JSON."""
+    if not s:
+        return []
+    try:
+        raw = base64.b64decode(s.encode("ascii"), validate=True)
+        return _parse_escalation_groups_json(raw.decode("utf-8", errors="replace"))
+    except Exception:
+        return []
+
+
+def _parse_decision_log(md_text):
+    """
+    Parse decision log markdown and extract fixed/rejected decisions.
+    
+    Format:
+      # Decision Log
+      PR: 123
+      ## Round 1
+      ### Fixed
+      - id: CDX-001
+        commit: abc123
+        essence: JSON.parse error handling
+      ### Rejected
+      - id: GMN-004
+        priority: P2
+        reason: needs product decision
+        essence: component split suggestion
+    
+    Returns: [
+      {"id": "CDX-001", "status": "fixed", "essence": "...", "commit": "..."},
+      {"id": "GMN-004", "status": "rejected", "essence": "...", "reason": "...", "priority": "P2"}
+    ]
+    """
+    if not md_text:
+        return []
+    
+    lines = md_text.splitlines()
+    decisions = []
+    
+    current_status = None  # "fixed" or "rejected"
+    current_entry = None
+    
+    for raw in lines:
+        line = raw.rstrip("\n")
+        
+        # Detect status section headers
+        if line.strip().lower() == "### fixed":
+            current_status = "fixed"
+            if current_entry:
+                decisions.append(current_entry)
+                current_entry = None
+            continue
+        
+        if line.strip().lower() == "### rejected":
+            current_status = "rejected"
+            if current_entry:
+                decisions.append(current_entry)
+                current_entry = None
+            continue
+        
+        # Reset on new round headers
+        if line.startswith("## Round "):
+            if current_entry:
+                decisions.append(current_entry)
+            current_entry = None
+            continue
+        
+        # Start new entry
+        if line.startswith("- id:") and current_status:
+            if current_entry:
+                decisions.append(current_entry)
+            fid = line.split(":", 1)[1].strip()
+            current_entry = {"id": fid, "status": current_status}
+            continue
+        
+        # Parse entry fields
+        if current_entry and line.startswith("  "):
+            m = re.match(r"^\s{2}([a-zA-Z][a-zA-Z0-9]*):\s*(.*)$", line)
+            if m:
+                k = m.group(1).strip()
+                v = m.group(2).strip()
+                current_entry[k] = v
+    
+    # Don't forget last entry
+    if current_entry:
+        decisions.append(current_entry)
+    
+    return decisions
+
+
+def _filter_by_decision_log(findings, prior_decisions, escalation_groups):
+    """
+    Filter findings based on decision log.
+    
+    Rules:
+    1. Filter out findings matching any "fixed" decision (by escalation group)
+    2. Filter out findings matching "rejected" decisions UNLESS in escalation group
+    
+    Args:
+      findings: list of finding dicts
+      prior_decisions: list from _parse_decision_log()
+      escalation_groups: list of [rejected_id, new_finding_id] pairs
+    
+    Returns:
+      filtered list of findings
+    """
+    if not prior_decisions:
+        return findings
+    
+    escalation_map = {}
+    for group in escalation_groups:
+        if len(group) >= 2:
+            prior_id = group[0]
+            new_finding_ids = group[1:]
+            if prior_id not in escalation_map:
+                escalation_map[prior_id] = set()
+            escalation_map[prior_id].update(new_finding_ids)
+    
+    fixed_ids = set()
+    rejected_ids = set()
+    
+    for dec in prior_decisions:
+        status = dec.get("status", "").lower()
+        fid = dec.get("id", "").strip()
+        if not fid:
+            continue
+        
+        if status == "fixed":
+            fixed_ids.add(fid)
+        elif status == "rejected":
+            rejected_ids.add(fid)
+    
+    filtered = []
+    for f in findings:
+        fid = f.get("id", "").strip()
+        if not fid:
+            continue
+        
+        should_filter = False
+        
+        if fid in fixed_ids:
+            should_filter = True
+        
+        if not should_filter:
+            for fixed_id in fixed_ids:
+                if fixed_id in escalation_map and fid in escalation_map[fixed_id]:
+                    should_filter = True
+                    break
+        
+        if not should_filter:
+            if fid in rejected_ids:
+                should_filter = True
+            
+            for rejected_id in rejected_ids:
+                if rejected_id in escalation_map and fid in escalation_map[rejected_id]:
+                    should_filter = False
+                    break
+        
+        if not should_filter:
+            filtered.append(f)
+    
+    return filtered
+
+
 def _parse_review_findings(md_text):
     lines = md_text.splitlines()
     items = []
@@ -399,7 +597,7 @@ def _render_mode_a_comment(pr_number, round_num, run_id, counts, must_fix, merge
     lines.append("")
 
     if must_fix:
-        lines.append("## Must Fix (P0/P1/P2)")
+        lines.append("## Must Fix (P0/P1)")
         lines.append("")
         for f in must_fix:
             fid = f.get("id") or ""
@@ -418,7 +616,7 @@ def _render_mode_a_comment(pr_number, round_num, run_id, counts, must_fix, merge
     else:
         lines.append("## Result")
         lines.append("")
-        lines.append("No P0/P1/P2 issues found.")
+        lines.append("No P0/P1 issues found.")
         lines.append("")
 
     lines.append("<details>")
@@ -464,7 +662,7 @@ def _render_final_comment(pr_number, round_num, run_id, status):
     if status == "RESOLVED":
         lines.append("### Status: ✅ All issues resolved")
         lines.append("")
-        lines.append("All P0/P1/P2 issues from the automated review have been addressed.")
+        lines.append("All P0/P1 issues from the automated review have been addressed.")
         lines.append("The PR is ready for human review and merge.")
     else:
         lines.append("### Status: ⚠️ Max rounds reached")
@@ -491,6 +689,8 @@ def main(argv):
     parser.add_argument("--final-report")
     parser.add_argument("--duplicate-groups-json")
     parser.add_argument("--duplicate-groups-b64")
+    parser.add_argument("--decision-log-file")
+    parser.add_argument("--escalation-groups-b64")
 
     try:
         args = parser.parse_args(argv)
@@ -571,9 +771,25 @@ def main(argv):
     if not duplicate_groups:
         duplicate_groups = _parse_duplicate_groups_b64(args.duplicate_groups_b64 or "")
     merged_findings, merged_map = _merge_duplicates(all_findings, duplicate_groups)
+    
+    decision_log_file = (args.decision_log_file or "").strip() or None
+    prior_decisions = []
+    if decision_log_file:
+        try:
+            decision_log_md = _read_cache_text(decision_log_file)
+            prior_decisions = _parse_decision_log(decision_log_md)
+        except Exception:
+            pass
+    
+    escalation_groups = _parse_escalation_groups_b64(args.escalation_groups_b64 or "")
+    
+    if prior_decisions:
+        merged_findings = _filter_by_decision_log(merged_findings, prior_decisions, escalation_groups)
+    
     counts = _counts(merged_findings)
 
-    must_fix = [f for f in merged_findings if _priority_rank(f.get("priority")) <= 2]
+    must_fix = [f for f in merged_findings if _priority_rank(f.get("priority")) <= 1]
+    optional = [f for f in merged_findings if _priority_rank(f.get("priority")) >= 2]
     stop = len(must_fix) == 0
 
     body = _render_mode_a_comment(pr_number, round_num, run_id, counts, must_fix, merged_map, raw_reviews)
@@ -616,6 +832,28 @@ def main(argv):
         lines.append(f"  description: {desc}")
         lines.append(f"  suggestion: {sugg}")
 
+    lines.append("")
+    lines.append("## OptionalIssues")
+    lines.append("")
+    for f in optional:
+        fid = f.get("id") or ""
+        pri = (f.get("priority") or "P3").strip()
+        cat = (f.get("category") or "quality").strip()
+        file = (f.get("file") or "<unknown>").strip()
+        line = (f.get("line") or "null").strip()
+        title = (f.get("title") or "").strip()
+        desc = (f.get("description") or "").replace("\n", "\\n").strip()
+        sugg = (f.get("suggestion") or "(no suggestion provided)").replace("\n", "\\n").strip()
+
+        lines.append(f"- id: {fid}")
+        lines.append(f"  priority: {pri}")
+        lines.append(f"  category: {cat}")
+        lines.append(f"  file: {file}")
+        lines.append(f"  line: {line}")
+        lines.append(f"  title: {title}")
+        lines.append(f"  description: {desc}")
+        lines.append(f"  suggestion: {sugg}")
+
     fix_ref = _repo_relpath(REPO_ROOT, CACHE_DIR / fix_file)
     _write_cache_text(fix_ref, "\n".join(lines) + "\n")
     _json_out({"stop": False, "fixFile": fix_ref})

package/@opencode/agents/test_pr_review_aggregate.py

@@ -0,0 +1,500 @@
+#!/usr/bin/env python3
+"""
+Unit tests for pr_review_aggregate.py decision log parsing and filtering.
+
+Tests cover:
+1. _parse_decision_log() - parsing markdown decision logs
+2. _filter_by_decision_log() - filtering findings based on prior decisions
+3. Edge cases: empty input, malformed data, cross-reviewer matching
+"""
+
+import pytest
+from unittest.mock import patch, MagicMock
+import sys
+from pathlib import Path
+
+# Add parent directory to path for importing pr_review_aggregate
+sys.path.insert(0, str(Path(__file__).parent))
+
+# Import functions under test
+from pr_review_aggregate import (
+    _parse_decision_log,
+    _filter_by_decision_log,
+    _parse_escalation_groups_json,
+    _parse_escalation_groups_b64,
+)
+
+
+# ============================================================
+# Fixtures
+# ============================================================
+
+@pytest.fixture
+def empty_decision_log():
+    """Empty decision log markdown."""
+    return ""
+
+
+@pytest.fixture
+def valid_decision_log():
+    """Valid decision log with Fixed and Rejected entries."""
+    return """# Decision Log
+
+PR: 123
+
+## Round 1
+
+### Fixed
+- id: CDX-001
+  commit: abc123
+  essence: JSON.parse 未捕获异常
+
+- id: GMN-002
+  commit: def456
+  essence: 缺少错误边界处理
+
+### Rejected
+- id: GMN-004
+  priority: P2
+  reason: 需要产品决策，超出 PR 范围
+  essence: 组件拆分建议
+
+- id: CLD-003
+  priority: P3
+  reason: 性能优化非当前优先级
+  essence: 批量查询优化
+"""
+
+
+@pytest.fixture
+def malformed_decision_log():
+    """Malformed decision log with missing fields and bad formatting."""
+    return """# Decision Log
+
+PR: 123
+
+### Fixed
+- id: BROKEN-001
+  # Missing essence field
+
+### Rejected
+- id: BROKEN-002
+  priority: P2
+  # Missing essence and reason
+
+Some random text that should be ignored
+
+- id: BROKEN-003
+  this is not a valid field format
+"""
+
+
+@pytest.fixture
+def sample_findings():
+    """Sample findings list for filter tests."""
+    return [
+        {
+            "id": "CDX-001",
+            "priority": "P1",
+            "category": "bug",
+            "file": "api.ts",
+            "line": "42",
+            "title": "JSON parse error",
+            "description": "JSON.parse 未捕获异常",
+            "suggestion": "Add try-catch"
+        },
+        {
+            "id": "GMN-004",
+            "priority": "P2",
+            "category": "quality",
+            "file": "Component.tsx",
+            "line": "100",
+            "title": "Component split",
+            "description": "组件拆分建议",
+            "suggestion": "Split into smaller components"
+        },
+        {
+            "id": "CLD-007",
+            "priority": "P0",
+            "category": "bug",
+            "file": "Component.tsx",
+            "line": "100",
+            "title": "Component split (escalated)",
+            "description": "组件拆分建议 - 升级为 P0",
+            "suggestion": "Split into smaller components - critical"
+        },
+        {
+            "id": "NEW-001",
+            "priority": "P1",
+            "category": "bug",
+            "file": "utils.ts",
+            "line": "20",
+            "title": "New issue",
+            "description": "This is a new issue",
+            "suggestion": "Fix it"
+        }
+    ]
+
+
+@pytest.fixture
+def prior_decisions():
+    """Sample prior decisions from _parse_decision_log."""
+    return [
+        {
+            "id": "CDX-001",
+            "status": "fixed",
+            "commit": "abc123",
+            "essence": "JSON.parse 未捕获异常"
+        },
+        {
+            "id": "GMN-004",
+            "status": "rejected",
+            "priority": "P2",
+            "reason": "需要产品决策，超出 PR 范围",
+            "essence": "组件拆分建议"
+        }
+    ]
+
+
+# ============================================================
+# Test: _parse_decision_log() - Empty Input
+# ============================================================
+
+def test_parse_decision_log_empty(empty_decision_log):
+    """
+    Test that empty decision log returns empty list.
+    
+    Given: empty string
+    When: _parse_decision_log() is called
+    Then: returns []
+    """
+    result = _parse_decision_log(empty_decision_log)
+    assert result == []
+    assert isinstance(result, list)
+
+
+# ============================================================
+# Test: _parse_decision_log() - Valid Input
+# ============================================================
+
+def test_parse_decision_log_valid(valid_decision_log):
+    """
+    Test that valid decision log is parsed into structured data.
+    
+    Given: valid markdown with Fixed and Rejected sections
+    When: _parse_decision_log() is called
+    Then: returns list of dicts with id, status, essence, and optional fields
+    """
+    result = _parse_decision_log(valid_decision_log)
+    
+    # Should have 4 entries (2 Fixed, 2 Rejected)
+    assert len(result) == 4
+    
+    # Verify first Fixed entry
+    fixed_1 = result[0]
+    assert fixed_1["id"] == "CDX-001"
+    assert fixed_1["status"] == "fixed"
+    assert fixed_1["commit"] == "abc123"
+    assert fixed_1["essence"] == "JSON.parse 未捕获异常"
+    
+    # Verify second Fixed entry
+    fixed_2 = result[1]
+    assert fixed_2["id"] == "GMN-002"
+    assert fixed_2["status"] == "fixed"
+    assert fixed_2["commit"] == "def456"
+    assert fixed_2["essence"] == "缺少错误边界处理"
+    
+    # Verify first Rejected entry
+    rejected_1 = result[2]
+    assert rejected_1["id"] == "GMN-004"
+    assert rejected_1["status"] == "rejected"
+    assert rejected_1["priority"] == "P2"
+    assert rejected_1["reason"] == "需要产品决策，超出 PR 范围"
+    assert rejected_1["essence"] == "组件拆分建议"
+    
+    # Verify second Rejected entry
+    rejected_2 = result[3]
+    assert rejected_2["id"] == "CLD-003"
+    assert rejected_2["status"] == "rejected"
+    assert rejected_2["priority"] == "P3"
+
+
+# ============================================================
+# Test: _parse_decision_log() - Malformed Input
+# ============================================================
+
+def test_parse_decision_log_malformed(malformed_decision_log):
+    """
+    Test that malformed decision log degrades gracefully.
+    
+    Given: decision log with missing required fields
+    When: _parse_decision_log() is called
+    Then: returns partial data without raising exceptions
+    """
+    # Should not raise exception
+    result = _parse_decision_log(malformed_decision_log)
+    
+    # Should return some data (even if incomplete)
+    assert isinstance(result, list)
+    
+    # Entries should have at least id and status
+    for entry in result:
+        assert "id" in entry
+        assert "status" in entry
+
+
+# ============================================================
+# Test: _filter_by_decision_log() - Fixed Issues
+# ============================================================
+
+def test_filter_fixed_issues(sample_findings, prior_decisions):
+    """
+    Test that findings matching Fixed decisions are filtered out.
+    
+    Given: findings containing CDX-001 which is in Fixed decisions
+    When: _filter_by_decision_log() is called with empty escalation_groups
+    Then: CDX-001 is filtered out
+    """
+    escalation_groups = []
+    
+    result = _filter_by_decision_log(sample_findings, prior_decisions, escalation_groups)
+    
+    # CDX-001 should be filtered (it's in Fixed decisions)
+    result_ids = [f["id"] for f in result]
+    assert "CDX-001" not in result_ids
+    
+    # Other findings should remain
+    assert "GMN-004" in result_ids or "CLD-007" in result_ids or "NEW-001" in result_ids
+
+
+# ============================================================
+# Test: _filter_by_decision_log() - Rejected Without Escalation
+# ============================================================
+
+def test_filter_rejected_without_escalation(sample_findings, prior_decisions):
+    """
+    Test that findings matching Rejected decisions are filtered out when NOT in escalation_groups.
+    
+    Given: findings containing GMN-004 which is in Rejected decisions
+          and escalation_groups is empty
+    When: _filter_by_decision_log() is called
+    Then: GMN-004 is filtered out
+    """
+    escalation_groups = []
+    
+    result = _filter_by_decision_log(sample_findings, prior_decisions, escalation_groups)
+    
+    # GMN-004 should be filtered (it's Rejected and not escalated)
+    result_ids = [f["id"] for f in result]
+    assert "GMN-004" not in result_ids
+    
+    # New findings should remain
+    assert "NEW-001" in result_ids
+
+
+# ============================================================
+# Test: _filter_by_decision_log() - Rejected With Escalation
+# ============================================================
+
+def test_filter_rejected_with_escalation(sample_findings, prior_decisions):
+    """
+    Test that findings matching Rejected decisions are kept when in escalation_groups.
+    
+    Given: findings containing CLD-007 which is an escalation of GMN-004
+          and escalation_groups contains ["GMN-004", "CLD-007"]
+    When: _filter_by_decision_log() is called
+    Then: CLD-007 is NOT filtered (it's an escalation)
+    """
+    # GMN-004 (Rejected P2) -> CLD-007 (escalated to P0, ≥2 level jump)
+    escalation_groups = [["GMN-004", "CLD-007"]]
+    
+    result = _filter_by_decision_log(sample_findings, prior_decisions, escalation_groups)
+    
+    # CLD-007 should NOT be filtered (it's an escalation)
+    result_ids = [f["id"] for f in result]
+    assert "CLD-007" in result_ids
+    
+    # GMN-004 itself (P2) should still be filtered
+    assert "GMN-004" not in result_ids
+
+
+# ============================================================
+# Test: _filter_by_decision_log() - Cross-Reviewer Match
+# ============================================================
+
+def test_filter_cross_reviewer_match():
+    """
+    Test that findings with different reviewer IDs but same essence are filtered.
+    
+    Given: findings containing GMN-005 (different ID from CDX-001)
+          but prior decisions contain CDX-001 as Fixed
+          and escalation_groups links them: ["CDX-001", "GMN-005"]
+    When: _filter_by_decision_log() is called
+    Then: GMN-005 is filtered (matched via escalation group to Fixed decision)
+    """
+    findings = [
+        {
+            "id": "GMN-005",
+            "priority": "P1",
+            "category": "bug",
+            "file": "api.ts",
+            "line": "42",
+            "title": "JSON parse error",
+            "description": "JSON.parse 未捕获异常 (same essence as CDX-001)",
+            "suggestion": "Add try-catch"
+        },
+        {
+            "id": "NEW-002",
+            "priority": "P2",
+            "category": "quality",
+            "file": "utils.ts",
+            "line": "10",
+            "title": "Different issue",
+            "description": "Completely different",
+            "suggestion": "Fix differently"
+        }
+    ]
+    
+    prior_decisions = [
+        {
+            "id": "CDX-001",
+            "status": "fixed",
+            "commit": "abc123",
+            "essence": "JSON.parse 未捕获异常"
+        }
+    ]
+    
+    # Escalation group indicates GMN-005 is related to CDX-001
+    escalation_groups = [["CDX-001", "GMN-005"]]
+    
+    result = _filter_by_decision_log(findings, prior_decisions, escalation_groups)
+    
+    # GMN-005 should be filtered (linked to Fixed CDX-001 via escalation group)
+    result_ids = [f["id"] for f in result]
+    assert "GMN-005" not in result_ids
+    
+    # NEW-002 should remain
+    assert "NEW-002" in result_ids
+
+
+# ============================================================
+# Test: _parse_escalation_groups_json()
+# ============================================================
+
+def test_parse_escalation_groups_json_valid():
+    """Test parsing valid escalation groups JSON."""
+    json_str = '{"escalationGroups": [["GMN-004", "CLD-007"], ["CDX-001", "GMN-005"]]}'
+    result = _parse_escalation_groups_json(json_str)
+    
+    assert len(result) == 2
+    assert ["GMN-004", "CLD-007"] in result
+    assert ["CDX-001", "GMN-005"] in result
+
+
+def test_parse_escalation_groups_json_empty():
+    """Test parsing empty escalation groups JSON."""
+    result = _parse_escalation_groups_json("")
+    assert result == []
+
+
+def test_parse_escalation_groups_json_malformed():
+    """Test parsing malformed JSON returns empty list."""
+    result = _parse_escalation_groups_json("not valid json {{{")
+    assert result == []
+
+
+# ============================================================
+# Test: _parse_escalation_groups_b64()
+# ============================================================
+
+def test_parse_escalation_groups_b64_valid():
+    """Test parsing valid base64-encoded escalation groups."""
+    import base64
+    json_str = '{"escalationGroups": [["GMN-004", "CLD-007"]]}'
+    b64_str = base64.b64encode(json_str.encode("utf-8")).decode("ascii")
+    
+    result = _parse_escalation_groups_b64(b64_str)
+    
+    assert len(result) == 1
+    assert ["GMN-004", "CLD-007"] in result
+
+
+def test_parse_escalation_groups_b64_empty():
+    """Test parsing empty base64 string."""
+    result = _parse_escalation_groups_b64("")
+    assert result == []
+
+
+def test_parse_escalation_groups_b64_invalid():
+    """Test parsing invalid base64 returns empty list."""
+    result = _parse_escalation_groups_b64("not-valid-base64!!!")
+    assert result == []
+
+
+# ============================================================
+# Test: Integration - Full Workflow
+# ============================================================
+
+def test_integration_full_filter_workflow():
+    """
+    Integration test: parse decision log and filter findings.
+    
+    Simulates real workflow:
+    1. Parse decision log markdown
+    2. Parse escalation groups
+    3. Filter findings based on decisions and escalations
+    """
+    decision_log_md = """# Decision Log
+
+PR: 456
+
+## Round 1
+
+### Fixed
+- id: CDX-010
+  commit: sha1
+  essence: 类型错误修复
+
+### Rejected
+- id: GMN-020
+  priority: P3
+  reason: 低优先级优化
+  essence: 性能优化建议
+"""
+    
+    findings = [
+        {"id": "CDX-010", "priority": "P1", "category": "bug", "file": "a.ts", "line": "1", "title": "Type error", "description": "类型错误修复", "suggestion": "Fix"},
+        {"id": "GMN-020", "priority": "P3", "category": "perf", "file": "b.ts", "line": "2", "title": "Perf opt", "description": "性能优化建议", "suggestion": "Optimize"},
+        {"id": "CLD-030", "priority": "P1", "category": "perf", "file": "b.ts", "line": "2", "title": "Perf opt escalated", "description": "性能优化建议 - 升级", "suggestion": "Optimize now"},
+        {"id": "NEW-100", "priority": "P2", "category": "quality", "file": "c.ts", "line": "3", "title": "New", "description": "新问题", "suggestion": "Fix new"},
+    ]
+    
+    # Parse decision log
+    prior_decisions = _parse_decision_log(decision_log_md)
+    assert len(prior_decisions) == 2
+    
+    # Escalation: GMN-020 (P3) -> CLD-030 (P1, ≥2 level jump)
+    escalation_groups = [["GMN-020", "CLD-030"]]
+    
+    # Filter findings
+    result = _filter_by_decision_log(findings, prior_decisions, escalation_groups)
+    result_ids = [f["id"] for f in result]
+    
+    # CDX-010 should be filtered (Fixed)
+    assert "CDX-010" not in result_ids
+    
+    # GMN-020 should be filtered (Rejected, not escalated)
+    assert "GMN-020" not in result_ids
+    
+    # CLD-030 should remain (escalation of Rejected)
+    assert "CLD-030" in result_ids
+    
+    # NEW-100 should remain (new issue)
+    assert "NEW-100" in result_ids
+    
+    # Final count: 2 findings remain
+    assert len(result) == 2
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

package/@opencode/commands/pr-review-loop.md

@@ -58,24 +58,32 @@ agent: sisyphus
 - 取出：`contextFile`、`runId`、`headOid`（如有）
 - **CRITICAL**: 必须等待此 Task 成功完成并获取到 `contextFile` 后，才能进入 Step 2
 
-2. Task（并行）: `codex-reviewer` + `claude-reviewer` + `gemini-reviewer` + `gh-thread-reviewer` **（依赖 Step 1 的 contextFile）**
+**检查 Decision Log**：
+- 检查是否存在 `./.cache/decision-log-pr{{PR_NUMBER}}.md`
+- 如存在，将路径记录为 `decisionLogFile`（用于后续步骤）
+- 如不存在，`decisionLogFile` 为空或不传递
 
-- **DEPENDENCY**: 这些 reviewers 依赖 Step 1 返回的 `contextFile`，因此**必须等 Step 1 完成后才能并行启动**
+2. Task（并行）: `codex-reviewer` + `claude-reviewer` + `gemini-reviewer` + `gh-thread-reviewer` **（依赖 Step 1 的 contextFile 和 decisionLogFile）**
+
+- **DEPENDENCY**: 这些 reviewers 依赖 Step 1 返回的 `contextFile` 和 `decisionLogFile`（如存在），因此**必须等 Step 1 完成后才能并行启动**
 - 每个 reviewer prompt 必须包含：
   - `PR #{{PR_NUMBER}}`
   - `round: <ROUND>`
   - `runId: <RUN_ID>`（来自 Step 1 的输出，必须透传，禁止自行生成）
   - `contextFile: ./.cache/<file>.md`（来自 Step 1 的输出）
-- reviewer 默认读 `contextFile`；必要时允许用 `git/gh` 只读命令拿 diff
+  - `decisionLogFile: ./.cache/decision-log-pr{{PR_NUMBER}}.md`（如存在，来自检查后得出）
+- reviewer 默认读 `contextFile`；如果 `decisionLogFile` 存在，reviewer 应在 prompt 中提供该文件路径以参考前轮决策；必要时允许用 `git/gh` 只读命令拿 diff
 - 忽略问题：1.格式化代码引起的噪音 2.已经lint检查以外的格式问题 3.忽略单元测试不足的问题
 - 特别关注: 逻辑、安全、性能、可维护性
 - 同时要注意 pr 前面轮次的 修复和讨论，对于已经拒绝、已修复的问题不要反复的提出
 - 同时也要注意fix的过程中有没有引入新的问题。
+
+备注：fixFile 分为 `IssuesToFix`（P0/P1，必须修）与 `OptionalIssues`（P2/P3，pr-fix 自主裁决）。
 - 每个 reviewer 输出：`reviewFile: ./.cache/<file>.md`（Markdown）
 
 3. Task: `pr-review-aggregate`
 
-- prompt 必须包含：`PR #{{PR_NUMBER}}`、`round: <ROUND>`、`runId: <RUN_ID>`、`contextFile: ./.cache/<file>.md`、以及 1+ 条 `reviewFile: ./.cache/<file>.md`
+- prompt 必须包含：`PR #{{PR_NUMBER}}`、`round: <ROUND>`、`runId: <RUN_ID>`、`contextFile: ./.cache/<file>.md`、以及 1+ 条 `reviewFile: ./.cache/<file>.md`、以及 `decisionLogFile: ./.cache/decision-log-pr{{PR_NUMBER}}.md`（如存在）
 - 输出：`{"stop":true}` 或 `{"stop":false,"fixFile":"..."}`
 - 若 `stop=true`：本轮结束并退出循环
 - **唯一性约束**: 每轮只能发布一次 Review Summary；脚本内置幂等检查，重复调用不会重复发布
@@ -97,6 +105,10 @@ agent: sisyphus
 - 输出：`{"ok":true}`
 - **唯一性约束**: 每轮只能发布一次 Fix Report；脚本内置幂等检查，重复调用不会重复发布
 
+**Decision Log 更新**：
+- `pr-fix` agent 在修复过程中会在 `./.cache/decision-log-pr{{PR_NUMBER}}.md` 中追加本轮决策（Fixed/Rejected）
+- 下一轮 review 将自动使用更新后的 decision-log，避免重复提出已决策问题
+
 6. 下一轮
 
 - 回到 1（进入下一轮 reviewers）

package/README.md

@@ -128,6 +128,63 @@ target（端）不写死，由 `env-policy.jsonc.targets` 定义；`commands.jso
 
 查看 `example/`：包含一个最小可读的 `dx/config` 配置示例，以及如何在一个 pnpm+nx monorepo 中接入 dx。
 
+## PR Review Loop（自动评审-修复闭环）
+
+dx 内置一套 PR 评审自动化工作流：并行评审 → 聚合结论 → 生成修复清单 → 自动修复 → 再评审，最多循环 3 轮，用于让 PR 更快收敛。
+
+### 什么时候用
+
+- PR 变更较大、想要更系统地覆盖安全/性能/可维护性问题
+- 希望在 CI 通过的前提下，把评审建议落成可执行的修复清单（fixFile）
+- 希望避免同一个问题在不同轮次被反复提出（通过 Decision Log 机制）
+
+### 如何运行
+
+在创建 PR 后执行：
+
+```
+/pr-review-loop --pr <PR_NUMBER>
+```
+
+更多命令说明见：`@opencode/commands/pr-review-loop.md`。
+
+提示：在创建 PR 的流程中也会给出快捷入口，见：`@opencode/commands/git-commit-and-pr.md`。
+
+### 工作流概览
+
+- 预检（`pr-precheck`）：先做编译/预检 gate，不通过则进入修复再预检（最多 2 次）
+- 获取上下文（`pr-context`）：生成本轮上下文缓存 `contextFile`
+- 并行评审（4 个 reviewer）：`codex-reviewer` / `claude-reviewer` / `gemini-reviewer` / `gh-thread-reviewer`
+- 聚合（`pr-review-aggregate`）：合并各 reviewer 结果、去重、输出 `fixFile`，并发布本轮 Review Summary
+- 修复（`pr-fix`）：按 `fixFile` 逐条修复（每条 findingId 单独 commit + push），输出 `fixReportFile`
+- 发布修复报告（`pr-review-aggregate` 模式 B）：发布 Fix Report
+
+备注：每轮发布到 PR 的评论都会带 `<!-- pr-review-loop-marker -->`，用于幂等与避免反复采集机器人评论。
+
+### 缓存文件（项目内 ./\.cache/）
+
+该流程的中间产物都写入项目内 `./.cache/`，并在 agent/命令之间传递 repo 相对路径：
+
+- `./.cache/pr-context-pr<PR>-r<ROUND>-<RUN_ID>.md`（contextFile）
+- `./.cache/review-<REVIEWER>-pr<PR>-r<ROUND>-<RUN_ID>.md`（reviewFile）
+- `./.cache/fix-pr<PR>-r<ROUND>-<RUN_ID>.md`（fixFile）
+- `./.cache/fix-report-pr<PR>-r<ROUND>-<RUN_ID>.md`（fixReportFile）
+
+### Decision Log（跨轮次决策日志，用于收敛）
+
+为了解决“第一轮拒绝的问题在后续轮次反复出现”的问题，PR Review Loop 使用 Decision Log 持久化每轮的决策：
+
+- 文件：`./.cache/decision-log-pr<PR_NUMBER>.md`
+- 生成者：`pr-fix` 在修复完成后创建/追加（append-only，禁止覆盖历史）
+- 内容：记录每轮的 Fixed/Rejected，以及 `essence`（问题本质的一句话描述，用于后续智能匹配）
+
+在后续轮次：
+
+- reviewers 若收到 `decisionLogFile`，必须读取并遵守：已修复不再提、已拒绝不再提（除非严重性升级）
+- aggregate 在模式 A 中基于 LLM 对比 `essence` 做“问题本质相同”的判断，并生成 `escalation_groups` 入参给脚本
+
+升级质疑规则：只有当新 finding 的优先级比历史 rejected 高 ≥2 级（例如 P3→P1、P2→P0）时，才允许重新打开。
+
 ## 命令
 
 dx 的命令由 `dx/config/commands.json` 驱动，并且内置了一些 internal runner（避免项目侧依赖任何 `scripts/lib/*.js`）：

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ranger1/dx",
-  "version": "0.1.39",
+  "version": "0.1.40",
   "type": "module",
   "license": "MIT",
   "repository": {