@ranger1/dx 0.1.39 → 0.1.41

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})