kc-beta 0.1.0

package/template/skills/en/skill-creator/scripts/run_loop.py

@@ -0,0 +1,332 @@
+#!/usr/bin/env python3
+"""Run the eval + improve loop until all pass or max iterations reached.
+
+Combines run_eval.py and improve_description.py in a loop, tracking history
+and returning the best description found. Supports train/test split to prevent
+overfitting.
+"""
+
+import argparse
+import json
+import random
+import sys
+import tempfile
+import time
+import webbrowser
+from pathlib import Path
+
+import anthropic
+
+from scripts.generate_report import generate_html
+from scripts.improve_description import improve_description
+from scripts.run_eval import find_project_root, run_eval
+from scripts.utils import parse_skill_md
+
+
+def split_eval_set(eval_set: list[dict], holdout: float, seed: int = 42) -> tuple[list[dict], list[dict]]:
+    """Split eval set into train and test sets, stratified by should_trigger."""
+    random.seed(seed)
+
+    # Separate by should_trigger
+    trigger = [e for e in eval_set if e["should_trigger"]]
+    no_trigger = [e for e in eval_set if not e["should_trigger"]]
+
+    # Shuffle each group
+    random.shuffle(trigger)
+    random.shuffle(no_trigger)
+
+    # Calculate split points
+    n_trigger_test = max(1, int(len(trigger) * holdout))
+    n_no_trigger_test = max(1, int(len(no_trigger) * holdout))
+
+    # Split
+    test_set = trigger[:n_trigger_test] + no_trigger[:n_no_trigger_test]
+    train_set = trigger[n_trigger_test:] + no_trigger[n_no_trigger_test:]
+
+    return train_set, test_set
+
+
+def run_loop(
+    eval_set: list[dict],
+    skill_path: Path,
+    description_override: str | None,
+    num_workers: int,
+    timeout: int,
+    max_iterations: int,
+    runs_per_query: int,
+    trigger_threshold: float,
+    holdout: float,
+    model: str,
+    verbose: bool,
+    live_report_path: Path | None = None,
+    log_dir: Path | None = None,
+) -> dict:
+    """Run the eval + improvement loop."""
+    project_root = find_project_root()
+    name, original_description, content = parse_skill_md(skill_path)
+    current_description = description_override or original_description
+
+    # Split into train/test if holdout > 0
+    if holdout > 0:
+        train_set, test_set = split_eval_set(eval_set, holdout)
+        if verbose:
+            print(f"Split: {len(train_set)} train, {len(test_set)} test (holdout={holdout})", file=sys.stderr)
+    else:
+        train_set = eval_set
+        test_set = []
+
+    client = anthropic.Anthropic()
+    history = []
+    exit_reason = "unknown"
+
+    for iteration in range(1, max_iterations + 1):
+        if verbose:
+            print(f"\n{'='*60}", file=sys.stderr)
+            print(f"Iteration {iteration}/{max_iterations}", file=sys.stderr)
+            print(f"Description: {current_description}", file=sys.stderr)
+            print(f"{'='*60}", file=sys.stderr)
+
+        # Evaluate train + test together in one batch for parallelism
+        all_queries = train_set + test_set
+        t0 = time.time()
+        all_results = run_eval(
+            eval_set=all_queries,
+            skill_name=name,
+            description=current_description,
+            num_workers=num_workers,
+            timeout=timeout,
+            project_root=project_root,
+            runs_per_query=runs_per_query,
+            trigger_threshold=trigger_threshold,
+            model=model,
+        )
+        eval_elapsed = time.time() - t0
+
+        # Split results back into train/test by matching queries
+        train_queries_set = {q["query"] for q in train_set}
+        train_result_list = [r for r in all_results["results"] if r["query"] in train_queries_set]
+        test_result_list = [r for r in all_results["results"] if r["query"] not in train_queries_set]
+
+        train_passed = sum(1 for r in train_result_list if r["pass"])
+        train_total = len(train_result_list)
+        train_summary = {"passed": train_passed, "failed": train_total - train_passed, "total": train_total}
+        train_results = {"results": train_result_list, "summary": train_summary}
+
+        if test_set:
+            test_passed = sum(1 for r in test_result_list if r["pass"])
+            test_total = len(test_result_list)
+            test_summary = {"passed": test_passed, "failed": test_total - test_passed, "total": test_total}
+            test_results = {"results": test_result_list, "summary": test_summary}
+        else:
+            test_results = None
+            test_summary = None
+
+        history.append({
+            "iteration": iteration,
+            "description": current_description,
+            "train_passed": train_summary["passed"],
+            "train_failed": train_summary["failed"],
+            "train_total": train_summary["total"],
+            "train_results": train_results["results"],
+            "test_passed": test_summary["passed"] if test_summary else None,
+            "test_failed": test_summary["failed"] if test_summary else None,
+            "test_total": test_summary["total"] if test_summary else None,
+            "test_results": test_results["results"] if test_results else None,
+            # For backward compat with report generator
+            "passed": train_summary["passed"],
+            "failed": train_summary["failed"],
+            "total": train_summary["total"],
+            "results": train_results["results"],
+        })
+
+        # Write live report if path provided
+        if live_report_path:
+            partial_output = {
+                "original_description": original_description,
+                "best_description": current_description,
+                "best_score": "in progress",
+                "iterations_run": len(history),
+                "holdout": holdout,
+                "train_size": len(train_set),
+                "test_size": len(test_set),
+                "history": history,
+            }
+            live_report_path.write_text(generate_html(partial_output, auto_refresh=True, skill_name=name))
+
+        if verbose:
+            def print_eval_stats(label, results, elapsed):
+                pos = [r for r in results if r["should_trigger"]]
+                neg = [r for r in results if not r["should_trigger"]]
+                tp = sum(r["triggers"] for r in pos)
+                pos_runs = sum(r["runs"] for r in pos)
+                fn = pos_runs - tp
+                fp = sum(r["triggers"] for r in neg)
+                neg_runs = sum(r["runs"] for r in neg)
+                tn = neg_runs - fp
+                total = tp + tn + fp + fn
+                precision = tp / (tp + fp) if (tp + fp) > 0 else 1.0
+                recall = tp / (tp + fn) if (tp + fn) > 0 else 1.0
+                accuracy = (tp + tn) / total if total > 0 else 0.0
+                print(f"{label}: {tp+tn}/{total} correct, precision={precision:.0%} recall={recall:.0%} accuracy={accuracy:.0%} ({elapsed:.1f}s)", file=sys.stderr)
+                for r in results:
+                    status = "PASS" if r["pass"] else "FAIL"
+                    rate_str = f"{r['triggers']}/{r['runs']}"
+                    print(f"  [{status}] rate={rate_str} expected={r['should_trigger']}: {r['query'][:60]}", file=sys.stderr)
+
+            print_eval_stats("Train", train_results["results"], eval_elapsed)
+            if test_summary:
+                print_eval_stats("Test ", test_results["results"], 0)
+
+        if train_summary["failed"] == 0:
+            exit_reason = f"all_passed (iteration {iteration})"
+            if verbose:
+                print(f"\nAll train queries passed on iteration {iteration}!", file=sys.stderr)
+            break
+
+        if iteration == max_iterations:
+            exit_reason = f"max_iterations ({max_iterations})"
+            if verbose:
+                print(f"\nMax iterations reached ({max_iterations}).", file=sys.stderr)
+            break
+
+        # Improve the description based on train results
+        if verbose:
+            print(f"\nImproving description...", file=sys.stderr)
+
+        t0 = time.time()
+        # Strip test scores from history so improvement model can't see them
+        blinded_history = [
+            {k: v for k, v in h.items() if not k.startswith("test_")}
+            for h in history
+        ]
+        new_description = improve_description(
+            client=client,
+            skill_name=name,
+            skill_content=content,
+            current_description=current_description,
+            eval_results=train_results,
+            history=blinded_history,
+            model=model,
+            log_dir=log_dir,
+            iteration=iteration,
+        )
+        improve_elapsed = time.time() - t0
+
+        if verbose:
+            print(f"Proposed ({improve_elapsed:.1f}s): {new_description}", file=sys.stderr)
+
+        current_description = new_description
+
+    # Find the best iteration by TEST score (or train if no test set)
+    if test_set:
+        best = max(history, key=lambda h: h["test_passed"] or 0)
+        best_score = f"{best['test_passed']}/{best['test_total']}"
+    else:
+        best = max(history, key=lambda h: h["train_passed"])
+        best_score = f"{best['train_passed']}/{best['train_total']}"
+
+    if verbose:
+        print(f"\nExit reason: {exit_reason}", file=sys.stderr)
+        print(f"Best score: {best_score} (iteration {best['iteration']})", file=sys.stderr)
+
+    return {
+        "exit_reason": exit_reason,
+        "original_description": original_description,
+        "best_description": best["description"],
+        "best_score": best_score,
+        "best_train_score": f"{best['train_passed']}/{best['train_total']}",
+        "best_test_score": f"{best['test_passed']}/{best['test_total']}" if test_set else None,
+        "final_description": current_description,
+        "iterations_run": len(history),
+        "holdout": holdout,
+        "train_size": len(train_set),
+        "test_size": len(test_set),
+        "history": history,
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run eval + improve loop")
+    parser.add_argument("--eval-set", required=True, help="Path to eval set JSON file")
+    parser.add_argument("--skill-path", required=True, help="Path to skill directory")
+    parser.add_argument("--description", default=None, help="Override starting description")
+    parser.add_argument("--num-workers", type=int, default=10, help="Number of parallel workers")
+    parser.add_argument("--timeout", type=int, default=30, help="Timeout per query in seconds")
+    parser.add_argument("--max-iterations", type=int, default=5, help="Max improvement iterations")
+    parser.add_argument("--runs-per-query", type=int, default=3, help="Number of runs per query")
+    parser.add_argument("--trigger-threshold", type=float, default=0.5, help="Trigger rate threshold")
+    parser.add_argument("--holdout", type=float, default=0.4, help="Fraction of eval set to hold out for testing (0 to disable)")
+    parser.add_argument("--model", required=True, help="Model for improvement")
+    parser.add_argument("--verbose", action="store_true", help="Print progress to stderr")
+    parser.add_argument("--report", default="auto", help="Generate HTML report at this path (default: 'auto' for temp file, 'none' to disable)")
+    parser.add_argument("--results-dir", default=None, help="Save all outputs (results.json, report.html, log.txt) to a timestamped subdirectory here")
+    args = parser.parse_args()
+
+    eval_set = json.loads(Path(args.eval_set).read_text())
+    skill_path = Path(args.skill_path)
+
+    if not (skill_path / "SKILL.md").exists():
+        print(f"Error: No SKILL.md found at {skill_path}", file=sys.stderr)
+        sys.exit(1)
+
+    name, _, _ = parse_skill_md(skill_path)
+
+    # Set up live report path
+    if args.report != "none":
+        if args.report == "auto":
+            timestamp = time.strftime("%Y%m%d_%H%M%S")
+            live_report_path = Path(tempfile.gettempdir()) / f"skill_description_report_{skill_path.name}_{timestamp}.html"
+        else:
+            live_report_path = Path(args.report)
+        # Open the report immediately so the user can watch
+        live_report_path.write_text("<html><body><h1>Starting optimization loop...</h1><meta http-equiv='refresh' content='5'></body></html>")
+        webbrowser.open(str(live_report_path))
+    else:
+        live_report_path = None
+
+    # Determine output directory (create before run_loop so logs can be written)
+    if args.results_dir:
+        timestamp = time.strftime("%Y-%m-%d_%H%M%S")
+        results_dir = Path(args.results_dir) / timestamp
+        results_dir.mkdir(parents=True, exist_ok=True)
+    else:
+        results_dir = None
+
+    log_dir = results_dir / "logs" if results_dir else None
+
+    output = run_loop(
+        eval_set=eval_set,
+        skill_path=skill_path,
+        description_override=args.description,
+        num_workers=args.num_workers,
+        timeout=args.timeout,
+        max_iterations=args.max_iterations,
+        runs_per_query=args.runs_per_query,
+        trigger_threshold=args.trigger_threshold,
+        holdout=args.holdout,
+        model=args.model,
+        verbose=args.verbose,
+        live_report_path=live_report_path,
+        log_dir=log_dir,
+    )
+
+    # Save JSON output
+    json_output = json.dumps(output, indent=2)
+    print(json_output)
+    if results_dir:
+        (results_dir / "results.json").write_text(json_output)
+
+    # Write final HTML report (without auto-refresh)
+    if live_report_path:
+        live_report_path.write_text(generate_html(output, auto_refresh=False, skill_name=name))
+        print(f"\nReport: {live_report_path}", file=sys.stderr)
+
+    if results_dir and live_report_path:
+        (results_dir / "report.html").write_text(generate_html(output, auto_refresh=False, skill_name=name))
+
+    if results_dir:
+        print(f"Results saved to: {results_dir}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

package/template/skills/en/skill-creator/scripts/utils.py

@@ -0,0 +1,47 @@
+"""Shared utilities for skill-creator scripts."""
+
+from pathlib import Path
+
+
+
+def parse_skill_md(skill_path: Path) -> tuple[str, str, str]:
+    """Parse a SKILL.md file, returning (name, description, full_content)."""
+    content = (skill_path / "SKILL.md").read_text()
+    lines = content.split("\n")
+
+    if lines[0].strip() != "---":
+        raise ValueError("SKILL.md missing frontmatter (no opening ---)")
+
+    end_idx = None
+    for i, line in enumerate(lines[1:], start=1):
+        if line.strip() == "---":
+            end_idx = i
+            break
+
+    if end_idx is None:
+        raise ValueError("SKILL.md missing frontmatter (no closing ---)")
+
+    name = ""
+    description = ""
+    frontmatter_lines = lines[1:end_idx]
+    i = 0
+    while i < len(frontmatter_lines):
+        line = frontmatter_lines[i]
+        if line.startswith("name:"):
+            name = line[len("name:"):].strip().strip('"').strip("'")
+        elif line.startswith("description:"):
+            value = line[len("description:"):].strip()
+            # Handle YAML multiline indicators (>, |, >-, |-)
+            if value in (">", "|", ">-", "|-"):
+                continuation_lines: list[str] = []
+                i += 1
+                while i < len(frontmatter_lines) and (frontmatter_lines[i].startswith("  ") or frontmatter_lines[i].startswith("\t")):
+                    continuation_lines.append(frontmatter_lines[i].strip())
+                    i += 1
+                description = " ".join(continuation_lines)
+                continue
+            else:
+                description = value.strip('"').strip("'")
+        i += 1
+
+    return name, description, content

package/template/skills/zh/meta/compliance-judgment/SKILL.md

@@ -0,0 +1,303 @@
+---
+name: compliance-judgment
+description: Determine whether extracted entities comply with verification rules. Use after entity extraction to make the pass/fail judgment for each rule on each document. Covers translating natural language rules into executable logic, choosing between Python calculation and LLM semantic judgment, and producing actionable comments on failures. Also use when designing the judgment step of a workflow or when a rule's judgment logic needs debugging.
+---
+
+# 合规判定
+
+判定是核查流程的关键时刻。你已经提取到了实体值，你手里有规则要求。现在要回答一个问题：**合规还是不合规？**
+
+答案必须清晰、正确，并且在不合规时附带简洁、可操作的评论。
+
+## 判定类型谱
+
+规则落在一个谱系上，从完全确定性到完全语义化：
+
+```
+确定性判定（Python）◄───────────────────────►语义判定（LLM）
+阈值检查  格式验证  日期计算  交叉一致  充分性  完整性  一致性  模板合规
+```
+
+左侧的判定用代码解决——免费、即时、确定。右侧的判定需要语言理解——需要 LLM、有成本、有不确定性。大多数规则处于中间位置，需要混合方法。
+
+## 确定性判定（用 Python）
+
+规则有明确、可计算的标准时，用 Python 实现判定逻辑。
+
+### 阈值检查
+
+金融监管中最常见的判定类型。
+
+```python
+# 资本充足率 ≥ 8%（银保监会要求）
+result = "pass" if extracted_ratio >= 8.0 else "fail"
+comment = f"资本充足率为{extracted_ratio}%，低于监管最低要求8.0%" if result == "fail" else ""
+
+# 不良贷款率（通常监控 < 5%，但阈值因机构类型而异）
+result = "pass" if npl_ratio < threshold else "fail"
+
+# 拨备覆盖率 ≥ 150%
+result = "pass" if provision_coverage >= 150.0 else "fail"
+
+# 单一客户贷款集中度 ≤ 10%
+result = "pass" if single_exposure <= 10.0 else "fail"
+```
+
+注意事项：
+- 边界值的处理要明确：`>=` 还是 `>`？监管文件中"不低于"对应 `>=`，"低于"对应 `<`。
+- 浮点精度：用 `Decimal` 或设定合理的容差（如 0.01%）。金融数据通常精确到小数点后两位。
+
+### 格式验证
+
+```python
+import re
+
+# 贷款编号格式：XX-YYYY-ZZZZZZ
+result = "pass" if re.match(r"[A-Z]{2}-\d{4}-\d{6}", loan_number) else "fail"
+
+# 统一社会信用代码：18位
+result = "pass" if re.match(r"^[0-9A-Z]{18}$", uscc) else "fail"
+
+# 手机号格式
+result = "pass" if re.match(r"^1[3-9]\d{9}$", phone) else "fail"
+```
+
+### 日期计算
+
+```python
+from datetime import datetime, timedelta
+
+# 合同签署日期在申请日期30天内
+sign_date = datetime.strptime(extracted_sign_date, "%Y-%m-%d")
+app_date = datetime.strptime(extracted_app_date, "%Y-%m-%d")
+result = "pass" if (sign_date - app_date).days <= 30 else "fail"
+comment = f"签署日期{extracted_sign_date}距申请日期{extracted_app_date}为{(sign_date - app_date).days}天，超过30天限制" if result == "fail" else ""
+
+# 贷款到期日不早于合同约定
+result = "pass" if actual_maturity >= contracted_maturity else "fail"
+
+# 报告出具日期在报告期末后4个月内（年报要求）
+report_date = datetime.strptime(extracted_report_date, "%Y-%m-%d")
+period_end = datetime.strptime(extracted_period_end, "%Y-%m-%d")
+deadline = period_end + timedelta(days=120)  # 约4个月
+result = "pass" if report_date <= deadline else "fail"
+```
+
+### 交叉一致性检查
+
+```python
+# 合计数等于明细之和
+result = "pass" if abs(total - sum(items)) < 0.01 else "fail"
+comment = f"合计数{total}与明细之和{sum(items)}不一致，差额{total - sum(items)}" if result == "fail" else ""
+
+# 资产负债表平衡：资产 = 负债 + 所有者权益
+result = "pass" if abs(assets - liabilities - equity) < 0.01 else "fail"
+
+# 同一指标在不同章节的值一致
+result = "pass" if value_in_summary == value_in_detail else "fail"
+comment = f"摘要中为{value_in_summary}，明细中为{value_in_detail}" if result == "fail" else ""
+```
+
+确定性判定是首选。它们免费、即时、可复现。能用 Python 解决的判定，绝不调用 LLM。
+
+## 语义判定（用 LLM）
+
+规则需要语言理解时使用 LLM。
+
+### 充分性判定
+
+"风险披露是否充分描述了主要风险因素。"
+
+这无法用 Python 判定——"充分"是一个需要理解内容的语义概念。
+
+LLM 判定提示词设计要点：
+1. 提供规则全文（什么构成合规）。
+2. 提供提取的文档内容（文档实际说了什么）。
+3. 要求结构化输出：pass/fail、推理过程、评论。
+4. 要求保守判定——只在明确不合规时判 fail。真正模糊的情况用 uncertain。
+
+### 完整性判定
+
+"管理层讨论与分析是否涵盖了财务状况、经营成果和现金流量三个方面。"
+
+这是一个清单式的语义判定：内容是否覆盖了规定的多个主题。
+
+```
+请判定以下管理层讨论与分析是否涵盖以下三个必要主题：
+1. 财务状况分析
+2. 经营成果分析  
+3. 现金流量分析
+
+文档内容：
+{extracted_section}
+
+对每个主题，判定是否有实质性讨论（不只是提及标题）。
+返回 JSON：
+{
+  "topic_1_covered": true/false,
+  "topic_2_covered": true/false,
+  "topic_3_covered": true/false,
+  "overall": "pass/fail",
+  "comment": "..."
+}
+```
+
+### 一致性判定
+
+"执行摘要与详细调查结果是否一致。"
+
+需要对两段文本进行语义比较，检查是否存在矛盾或遗漏。
+
+### 模板合规判定
+
+"报告是否按照《XX管理办法》附件一的格式编写。"
+
+需要将实际文档结构与模板要求进行逐项对比。
+
+## 混合判定
+
+大多数规则实际上需要混合方法。先跑廉价的确定性步骤，必要时再调用 LLM。
+
+### 示例：资本充足率核查
+
+```
+步骤1（正则提取）：提取"资本充足率"对应的数值 → 12.5%
+步骤2（Python判定）：12.5% >= 8.0% → pass
+```
+如果步骤 1 提取失败或置信度低：
+```
+步骤3（LLM提取）：请从以下内容中找出资本充足率的最新值 → 12.50%
+步骤4（Python判定）：12.50% >= 8.0% → pass
+```
+如果值在边界附近（如 8.02%）：
+```
+步骤5（LLM审查）：请确认12.50%是否为最终调整后的资本充足率，而非中间计算值
+```
+
+这个漏斗保证了：90% 的文档在步骤 2 就完成（零 LLM 成本），只有困难情况才调用 LLM。
+
+## 输出格式
+
+每条规则对每份文档的判定结果：
+
+```json
+{
+  "rule_id": "R001",
+  "document": "bank_annual_report_2024.pdf",
+  "result": "pass",
+  "extracted_value": "12.5%",
+  "expected": ">= 8.0%",
+  "comment": "",
+  "confidence": 0.95
+}
+```
+
+### result 取值说明
+
+| 值 | 含义 | 评论要求 |
+|---|------|---------|
+| **pass** | 实体合规 | 通常无需评论 |
+| **fail** | 实体不合规 | **必须**附带评论 |
+| **missing** | 实体在文档中未找到 | 注明搜索范围 |
+| **error** | 提取或判定过程出错 | 注明错误类型 |
+| **uncertain** | 判定模糊，需人工审查 | 说明不确定原因 |
+
+**missing 与 fail 的区别至关重要**：missing 是提取层面的问题（信息不存在），fail 是判定层面的问题（信息存在但不合规）。混淆二者会导致错误的统计和错误的行动方向。
+
+## 评论要求
+
+评论是给人看的。它应该让审查人员一眼明白问题所在。
+
+### 好的评论
+
+```
+"资本充足率为7.2%，低于监管最低要求8.0%。"
+"贷款合同签署日期2024-05-15距申请日期2024-03-01为75天，超过规定的30天期限。"
+"资产负债表不平衡：总资产1,234,567万元，负债+所有者权益为1,234,590万元，差额23万元。"
+"未在风险管理章节中找到流动性风险的专项讨论。"
+```
+
+### 不好的评论
+
+```
+"不合规。"  ← 没有具体信息
+"资本充足率不达标，存在重大风险隐患。"  ← 加了主观判断
+"该银行的资本充足率为7.2%，根据银保监会2023年发布的……（长篇大论）"  ← 过于冗长
+```
+
+### 评论原则
+
+- **简洁事实**：提取值 + 期望值 + 差异，三句话以内。
+- **仅在 fail 时给出**：pass 的结果不需要评论，除非开发者用户明确要求。
+- **不加主观判断**：不说"严重"、"重大"、"令人担忧"。只陈述事实。
+- **包含关键数值**：让审查人员无需回看原文就能理解问题。
+
+### 轻量标注格式
+
+为便于人工审查、节省 token 开销、以及在不同核查轮次之间做 diff 比较，判定结果也可以用紧凑的文本标注格式表达：
+
+```
+[PASS] capital_adequacy <- 12.5% (>= 8.0%) | conf:0.95 | src:p3-s2
+[FAIL] sign_date_gap <- 75d (<= 30d) | conf:0.90 | src:p1-s4 | note:签署超期45天
+[MISSING] collateral_value | conf:0.60 | note:未在文档中找到担保物估值
+```
+
+此格式与上述 JSON 格式可无损互转。在以下场景中使用此格式：向开发者用户展示结果以便快速审阅、在演化迭代摘要中记录日志以节省 token、在核查轮次之间计算 diff。参见 `references/output-format.md` 获取完整的格式规范和转换规则。
+
+## 判定顺序
+
+有些规则之间存在依赖关系：
+
+- **条件依赖**：规则 B 只在规则 A 通过时适用。"如果借款人为新客户（规则 A），则需要额外的尽调文件（规则 B）。"
+- **值依赖**：规则 C 使用规则 A 计算的值。"风险加权资本比率（规则 A）决定了所需的拨备水平（规则 C）。"
+- **逻辑依赖**：规则 D 只在规则 A 和 B 都失败时才需要检查。
+
+在规则目录中标注这些依赖关系。按依赖顺序执行规则。将上游规则的结果作为下游规则的上下文传递。
+
+### 依赖图示例
+
+```
+R001（资本充足率提取） → R002（资本充足率阈值判定）
+R003（核心一级资本提取）→ R004（核心一级资本充足率计算）→ R002
+R001 + R005（杠杆率）→ R006（综合评级）
+```
+
+如果上游规则结果为 missing 或 error，下游规则也应标记为 error 或 unable_to_judge，而非强行判定。
+
+## 边缘情况处理
+
+### 空提取
+
+实体未找到。默认判定为 **missing**，而非 fail。缺失值是提取层面的问题，不是合规层面的问题。将其反馈给解析和提取步骤，可能需要升级解析器或调整提取策略。
+
+### 多值冲突
+
+文档中同一实体出现在多处，且值不一致。
+
+- 标记为 **uncertain**。
+- 在评论中列出所有找到的值及其来源位置。
+- 如果规则指定了优先来源（如"以审计报告中的数值为准"），使用该来源的值。
+
+### 条件规则
+
+"如果贷款金额超过 1000 万元，则需要提供担保。"
+
+- 先检查条件：贷款金额是否超过 1000 万？
+- 条件不满足 → 规则不适用 → 结果为 pass（或 not_applicable）。
+- 条件满足 → 继续检查后续要求。
+
+### 否定规则
+
+"文档中不应包含对关联方的担保承诺。"
+
+搜索"不存在"比搜索"存在"更难。策略：
+- 在文档中搜索关键词（"关联方"+"担保"+"承诺"）。
+- 如果找到匹配，提取上下文送 LLM 确认是否构成实际的担保承诺（可能只是声明"未提供担保"）。
+- 如果没有找到任何匹配，判定 pass，但置信度降低（因为搜索可能不完整）。
+
+### 数值精度问题
+
+金融数据经常面临精度问题：
+- 报告中写"12.5%"，但实际精确值可能是"12.4997%"。
+- 四舍五入导致的微小差异不应被判为 fail。
+- 在阈值比较中设定合理容差。如"资本充足率 >= 8%"，可设定容差为 0.05%，即 7.95% 以上都不直接判 fail，而是标记为 uncertain 并提请人工审查。