Add workplace verifiers for ClawBenchPro

manifest.json

@@ -16,9 +16,10 @@
         "multi_turn_aligned": 200,
         "skills_aligned": 200
       },
-      "files": 5554,
-      "bytes": 25587458,
-      "checksums": "round_01_aligned_mix_800/checksums.sha256"
+      "files": 6358,
+      "bytes": 23733095,
+      "checksums": "round_01_aligned_mix_800/checksums.sha256",
+      "verifiers": "round_01_aligned_mix_800/verifiers"
     },
     {
       "name": "persona_aligned_mix_200",
@@ -31,9 +32,10 @@
         "multi_turn": 50,
         "skills": 50
       },
-      "files": 1192,
-      "bytes": 7007060,
-      "checksums": "persona_aligned_mix_200/checksums.sha256"
+      "files": 1396,
+      "bytes": 5965620,
+      "checksums": "persona_aligned_mix_200/checksums.sha256",
+      "verifiers": "persona_aligned_mix_200/verifiers"
     }
   ]
 }

persona_aligned_mix_200/manifest.json

@@ -39,8 +39,8 @@
     }
   },
   "files": {
-    "count": 26411,
-    "bytes": 178577935,
+    "count": 1396,
+    "bytes": 5965620,
     "checksums": "checksums.sha256"
   },
   "skills": {
@@ -177,5 +177,11 @@
       "data-persona-aligned-skills-50-0050-query-xid-v1",
       "data-persona-aligned-skills-50-0050-query-xid-v2"
     ]
+  },
+  "verifiers": {
+    "base": "verifiers/base.jsonl",
+    "multi_turn": "verifiers/multi_turn.jsonl",
+    "hard": "verifiers/hard.jsonl",
+    "skills": "verifiers/skills.jsonl"
   }
 }

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0001/verify_workplace.py

@@ -0,0 +1,68 @@
+import os
+import sys
+import json
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    target_file = os.path.join(workspace, "triage", "conflict_target.json")
+    
+    score = 0
+    details = []
+
+    # 1. 检查文件是否存在与基础格式 (10分)
+    if os.path.exists(target_file):
+        try:
+            with open(target_file, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            score += 10
+            details.append({"item": "JSON文件存在且格式正确", "score": 10, "max_score": 10, "passed": True, "reason": "文件读取成功"})
+        except Exception as e:
+            details.append({"item": "JSON文件格式解析", "score": 0, "max_score": 10, "passed": False, "reason": f"解析失败: {str(e)}"})
+            data = {}
+    else:
+        details.append({"item": "JSON文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "未找到 triage/conflict_target.json"})
+        data = {}
+
+    # 预定义的标准答案 (根据 env_builder.py 的逻辑)
+    # 冲突发生点：node-beta 在收到 node-gamma (T5) 的心跳时，本地 index 100 的 term 是 4
+    expected_node = "node-beta"
+    expected_term = 4
+    expected_index = 100
+
+    # 2. 检查 node_id (30分)
+    node_id = data.get("node_id")
+    if node_id == expected_node:
+        score += 30
+        details.append({"item": "匹配冲突节点 ID", "score": 30, "max_score": 30, "passed": True, "reason": f"成功识别节点: {node_id}"})
+    else:
+        details.append({"item": "匹配冲突节点 ID", "score": 0, "max_score": 30, "passed": False, "reason": f"期望 {expected_node}, 实际得到 {node_id}"})
+
+    # 3. 检查 conflict_term (30分)
+    try:
+        term = int(data.get("conflict_term", -1))
+        if term == expected_term:
+            score += 30
+            details.append({"item": "匹配冲突任期号 (Term)", "score": 30, "max_score": 30, "passed": True, "reason": f"成功识别任期: {term}"})
+        else:
+            details.append({"item": "匹配冲突任期号 (Term)", "score": 0, "max_score": 30, "passed": False, "reason": f"期望 {expected_term}, 实际得到 {term}"})
+    except (ValueError, TypeError):
+        details.append({"item": "匹配冲突任期号 (Term)", "score": 0, "max_score": 30, "passed": False, "reason": "任期号缺失或非整数"})
+
+    # 4. 检查 conflict_index (30分)
+    try:
+        idx = int(data.get("conflict_index", -1))
+        if idx == expected_index:
+            score += 30
+            details.append({"item": "匹配冲突日志索引 (Log Index)", "score": 30, "max_score": 30, "passed": True, "reason": f"成功识别索引: {idx}"})
+        else:
+            details.append({"item": "匹配冲突日志索引 (Log Index)", "score": 0, "max_score": 30, "passed": False, "reason": f"期望 {expected_index}, 实际得到 {idx}"})
+    except (ValueError, TypeError):
+        details.append({"item": "匹配冲突日志索引 (Log Index)", "score": 0, "max_score": 30, "passed": False, "reason": "索引号缺失或非整数"})
+
+    # 结果写入
+    output_file = "workplace_score.json"
+    with open(output_file, 'w', encoding='utf-8') as f:
+        json.dump({"total_score": score, "details": details}, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0002/verify_workplace.py

@@ -0,0 +1,78 @@
+import os
+import sys
+import json
+
+def verify_workplace():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    report_path = os.path.join(workspace, "ci_patch/conflict_report.json")
+    
+    score = 0
+    details = []
+
+    # 1. Check if the directory and file exist (10 points)
+    if os.path.exists(report_path):
+        score += 10
+        details.append({"item": "检查结果文件是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "文件 ci_patch/conflict_report.json 存在"})
+        
+        # 2. Check if the file is valid JSON (10 points)
+        try:
+            with open(report_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            score += 10
+            details.append({"item": "检查 JSON 格式合法性", "score": 10, "max_score": 10, "passed": True, "reason": "JSON 解析成功"})
+            
+            # 3. Check for required fields (10 points)
+            required_fields = ["package", "version_a", "version_b"]
+            missing_fields = [f for f in required_fields if f not in data]
+            if not missing_fields:
+                score += 10
+                details.append({"item": "检查必填字段", "score": 10, "max_score": 10, "passed": True, "reason": "包含所有必需字段"})
+                
+                # 4. Check package name (30 points)
+                # Allow case-insensitive check and trim
+                actual_package = str(data.get("package", "")).strip().lower()
+                expected_package = "eigen_matrix"
+                if actual_package == expected_package:
+                    score += 30
+                    details.append({"item": "验证冲突包名", "score": 30, "max_score": 30, "passed": True, "reason": f"匹配正确: {expected_package}"})
+                else:
+                    details.append({"item": "验证冲突包名", "score": 0, "max_score": 30, "passed": False, "reason": f"期望 {expected_package}, 实际为 {actual_package}"})
+
+                # 5. Check versions (20 + 20 points)
+                # Versions might be swapped, we accept both orders
+                actual_versions = sorted([str(data.get("version_a", "")), str(data.get("version_b", ""))])
+                expected_versions = sorted(["3.3.9", "3.4.2"])
+                
+                if actual_versions[0] == expected_versions[0]:
+                    score += 20
+                    details.append({"item": "验证版本号 A", "score": 20, "max_score": 20, "passed": True, "reason": f"版本 {actual_versions[0]} 匹配成功"})
+                else:
+                    details.append({"item": "验证版本号 A", "score": 0, "max_score": 20, "passed": False, "reason": f"未找到版本 {expected_versions[0]}"})
+
+                if actual_versions[1] == expected_versions[1]:
+                    score += 20
+                    details.append({"item": "验证版本号 B", "score": 20, "max_score": 20, "passed": True, "reason": f"版本 {actual_versions[1]} 匹配成功"})
+                else:
+                    details.append({"item": "验证版本号 B", "score": 0, "max_score": 20, "passed": False, "reason": f"未找到版本 {expected_versions[1]}"})
+
+            else:
+                details.append({"item": "检查必填字段", "score": 0, "max_score": 10, "passed": False, "reason": f"缺失字段: {missing_fields}"})
+                details.append({"item": "验证详细内容", "score": 0, "max_score": 70, "passed": False, "reason": "由于 JSON 字段不全，无法进行内容比对"})
+
+        except json.JSONDecodeError:
+            details.append({"item": "检查 JSON 格式合法性", "score": 0, "max_score": 10, "passed": False, "reason": "JSON 格式错误，无法解析"})
+            details.append({"item": "验证后续内容", "score": 0, "max_score": 80, "passed": False, "reason": "由于 JSON 解析失败，跳过内容验证"})
+    else:
+        details.append({"item": "检查结果文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "文件 ci_patch/conflict_report.json 未找到"})
+        details.append({"item": "验证后续所有项", "score": 0, "max_score": 90, "passed": False, "reason": "找不到目标文件"})
+
+    # Output results
+    output_data = {
+        "total_score": score,
+        "details": details
+    }
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump(output_data, f, ensure_ascii=False, indent=2)
+
+if __name__ == "__main__":
+    verify_workplace()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0003/verify_workplace.py

@@ -0,0 +1,105 @@
+import os
+import sys
+import json
+
+def calculate_average_phred(qual_str):
+    if not qual_str:
+        return 0
+    return sum(ord(c) - 33 for c in qual_str) / len(qual_str)
+
+def get_gold_standard(fastq_path):
+    adapter = "GATCGGAAGAGCACACGTC"
+    surviving_ids = []
+    
+    if not os.path.exists(fastq_path):
+        return surviving_ids
+
+    with open(fastq_path, 'r') as f:
+        while True:
+            header = f.readline().strip()
+            if not header:
+                break
+            seq = f.readline().strip()
+            plus = f.readline().strip()
+            qual = f.readline().strip()
+            
+            # 规则 1: 剔除包含接头的
+            if adapter in seq:
+                continue
+            
+            # 规则 2: 平均质量分数低于 20 的剔除
+            if calculate_average_phred(qual) < 20:
+                continue
+            
+            # 提取 ID (去除开头的 @)
+            read_id = header[1:] if header.startswith('@') else header
+            surviving_ids.append(read_id)
+            
+    return surviving_ids
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    fastq_path = os.path.join(workspace, "raw_data/run_774.fastq")
+    result_path = os.path.join(workspace, "results/surviving_reads.txt")
+    
+    score = 0
+    details = []
+
+    # 1. 检查结果文件是否存在
+    if os.path.exists(result_path):
+        score += 10
+        details.append({"item": "结果文件存在性", "score": 10, "max_score": 10, "passed": True, "reason": "results/surviving_reads.txt 已生成"})
+    else:
+        details.append({"item": "结果文件存在性", "score": 0, "max_score": 10, "passed": False, "reason": "未找到 results/surviving_reads.txt"})
+        # 如果文件不存在，后续检查无法进行
+        with open("workplace_score.json", "w") as f:
+            json.dump({"total_score": 0, "details": details}, f)
+        return
+
+    # 2. 读取并验证结果格式
+    with open(result_path, 'r') as f:
+        agent_lines = [line.strip() for line in f.readlines() if line.strip()]
+    
+    has_at_prefix = any(line.startswith('@') for line in agent_lines)
+    if not has_at_prefix:
+        score += 20
+        details.append({"item": "输出格式正确性（无@前缀）", "score": 20, "max_score": 20, "passed": True, "reason": "Read ID 符合要求，没有包含 @ 符号"})
+    else:
+        details.append({"item": "输出格式正确性（无@前缀）", "score": 0, "max_score": 20, "passed": False, "reason": "部分 Read ID 仍保留了 FASTQ 的 @ 前缀"})
+
+    # 3. 逻辑验证（金标准比对）
+    gold_ids = set(get_gold_standard(fastq_path))
+    agent_ids = set(agent_lines)
+    
+    # 计算交集、差集
+    tp = len(gold_ids.intersection(agent_ids))
+    fp = len(agent_ids - gold_ids)
+    fn = len(gold_ids - agent_ids)
+    
+    if len(gold_ids) == 0:
+        accuracy_score = 0 # 异常情况
+    else:
+        # 允许极小误差，但逻辑错误（如没过滤接头或质量分算错）会导致大量差异
+        accuracy = tp / len(gold_ids) if len(gold_ids) > 0 else 0
+        penalty = (fp / len(gold_ids)) * 0.5 # 错选惩罚
+        
+        final_acc_score = max(0, (accuracy - penalty) * 70)
+        score += int(final_acc_score)
+        
+        if final_acc_score >= 65:
+            details.append({"item": "数据过滤准确性", "score": int(final_acc_score), "max_score": 70, "passed": True, "reason": f"匹配率极高: 命中 {tp}, 多选 {fp}, 漏选 {fn}"})
+        else:
+            details.append({"item": "数据过滤准确性", "score": int(final_acc_score), "max_score": 70, "passed": False, "reason": f"过滤逻辑存在明显偏差: 命中 {tp}, 多选 {fp}, 漏选 {fn}"})
+
+    # 总结输出
+    final_score = min(100, score)
+    output = {
+        "total_score": int(final_score),
+        "details": details
+    }
+    
+    with open("workplace_score.json", "w") as f:
+        json.dump(output, f, indent=2)
+
+if __name__ == "__main__":
+    main()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0004/verify_workplace.py

@@ -0,0 +1,79 @@
+import os
+import sys
+import json
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    score = 0
+    details = []
+
+    target_file = os.path.join(workspace, "calibration/ghost_ids.txt")
+    
+    # 1. 基础检查：文件是否存在 (10分)
+    if os.path.exists(target_file):
+        score += 10
+        details.append({"item": "检查结果文件是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "文件 ghost_ids.txt 存在"})
+        
+        try:
+            with open(target_file, "r", encoding="utf-8") as f:
+                content = f.read().strip()
+            
+            # 解析内容
+            raw_ids = [s.strip() for s in content.split(",") if s.strip()]
+            try:
+                agent_ghost_ids = set(int(rid) for rid in raw_ids)
+            except ValueError:
+                details.append({"item": "检查文件内容格式", "score": 0, "max_score": 10, "passed": False, "reason": f"文件内容无法解析为整数列表: {content}"})
+                return score, details
+
+            # 2. 格式合规性检查 (10分)
+            # 要求：仅逗号分隔，无额外描述
+            if len(content.split("\n")) == 1 and "," in content:
+                score += 10
+                details.append({"item": "检查输出格式合规性", "score": 10, "max_score": 10, "passed": True, "reason": "格式符合逗号分隔要求"})
+            else:
+                details.append({"item": "检查输出格式合规性", "score": 0, "max_score": 10, "passed": False, "reason": "格式不符合单行逗号分隔要求"})
+
+            # 3. 核心逻辑：检测幽灵障碍物 ID 的准确性
+            # 根据 env_builder.py，正确答案是 {18, 27, 42, 68}
+            # 正常 ID 是 {12, 33, 55}
+            ground_truth_ghosts = {18, 27, 42, 68}
+            ground_truth_normals = {12, 33, 55}
+            
+            # 正确识别的幽灵 (每个15分，共60分)
+            for gid in ground_truth_ghosts:
+                if gid in agent_ghost_ids:
+                    score += 15
+                    details.append({"item": f"检测幽灵 ID {gid}", "score": 15, "max_score": 15, "passed": True, "reason": "正确识别"})
+                else:
+                    details.append({"item": f"检测幽灵 ID {gid}", "score": 0, "max_score": 15, "passed": False, "reason": "漏检"})
+
+            # 错误识别的正常障碍物 (误报，每个扣10分，最低到0分)
+            for nid in ground_truth_normals:
+                if nid in agent_ghost_ids:
+                    score -= 10
+                    details.append({"item": f"误报检查 ID {nid}", "score": -10, "max_score": 0, "passed": False, "reason": f"将正常目标 {nid} 误判为幽灵"})
+            
+            # 检查是否包含虚构的 ID
+            for aid in agent_ghost_ids:
+                if aid not in ground_truth_ghosts and aid not in ground_truth_normals:
+                    score -= 5
+                    details.append({"item": f"虚构检测 ID {aid}", "score": -5, "max_score": 0, "passed": False, "reason": "结果中包含数据中不存在的 ID"})
+
+        except Exception as e:
+            details.append({"item": "解析文件异常", "score": 0, "max_score": 80, "passed": False, "reason": str(e)})
+    else:
+        details.append({"item": "检查结果文件是否存在", "score": 0, "max_score": 100, "passed": False, "reason": "找不到 calibration/ghost_ids.txt"})
+
+    # 最终分修正
+    score = max(0, min(100, score))
+    return score, details
+
+if __name__ == "__main__":
+    total_score, score_details = verify()
+    output = {
+        "total_score": total_score,
+        "details": score_details
+    }
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump(output, f, indent=2, ensure_ascii=False)

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0005/verify_workplace.py

@@ -0,0 +1,96 @@
+import os
+import sys
+import json
+
+def load_json(path):
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    report_path = os.path.join(workspace, "reports/termination_list.json")
+    
+    score = 0
+    details = []
+
+    # 1. 基础结构检查 (10分)
+    if not os.path.exists(report_path):
+        details.append({"item": "文件存在性", "score": 0, "max_score": 10, "passed": False, "reason": "报告文件 reports/termination_list.json 未生成"})
+    else:
+        data = load_json(report_path)
+        if isinstance(data, list):
+            score += 10
+            details.append({"item": "JSON 格式检查", "score": 10, "max_score": 10, "passed": True, "reason": "报告为合法的 JSON 数组"})
+        else:
+            details.append({"item": "JSON 格式检查", "score": 0, "max_score": 10, "passed": False, "reason": "报告格式不是 JSON 数组"})
+            data = []
+
+    # 2. 核心数据解析与验证准备
+    # 预期结果集合 (根据 env_builder 生成逻辑)
+    # EBS: vol-0abcd111111111111 (ai-core -> alice), vol-0abcd222222222222 (data-eng -> charlie), vol-0abcd333333333333 (unknown-team -> unknown)
+    # EC2: i-0ffff111111111111 (ai-research -> bob)
+    expected_ebs = {"vol-0abcd111111111111", "vol-0abcd222222222222", "vol-0abcd333333333333"}
+    expected_ec2 = {"i-0ffff111111111111"}
+    
+    owners_map = {
+        "vol-0abcd111111111111": "alice.ai@mega-corp.local",
+        "vol-0abcd222222222222": "charlie.data@mega-corp.local",
+        "vol-0abcd333333333333": "unknown",
+        "i-0ffff111111111111": "bob.research@mega-corp.local"
+    }
+
+    if data:
+        # 3. EBS 资源识别 (30分)
+        found_ebs = {item['resource_id'] for item in data if item.get('resource_type') == 'EBS'}
+        ebs_correct = found_ebs == expected_ebs
+        ebs_excess = found_ebs - expected_ebs # 检查是否有误杀 (如 vol-0abcd999999999999)
+        
+        ebs_score = 0
+        if "vol-0abcd111111111111" in found_ebs: ebs_score += 10
+        if "vol-0abcd222222222222" in found_ebs: ebs_score += 10
+        if "vol-0abcd333333333333" in found_ebs: ebs_score += 10
+        if "vol-0abcd999999999999" in found_ebs: ebs_score -= 10 # 误杀扣分
+        
+        ebs_score = max(0, ebs_score)
+        score += ebs_score
+        details.append({"item": "EBS 闲置资源识别", "score": ebs_score, "max_score": 30, "passed": ebs_score >= 30, "reason": f"识别到 EBS: {found_ebs}"})
+
+        # 4. EC2 资源识别 (30分)
+        found_ec2 = {item['resource_id'] for item in data if item.get('resource_type') == 'EC2'}
+        ec2_score = 0
+        if "i-0ffff111111111111" in found_ec2: ec2_score += 30
+        if "i-0ffff222222222222" in found_ec2 or "i-0ffff333333333333" in found_ec2:
+            ec2_score = max(0, ec2_score - 20) # 误将高负载或平均负载正常的实例列入
+            
+        score += ec2_score
+        details.append({"item": "EC2 GPU低利用率识别", "score": ec2_score, "max_score": 30, "passed": ec2_score == 30, "reason": f"识别到 EC2: {found_ec2}"})
+
+        # 5. Owner 匹配正确性 (30分)
+        owner_correct_count = 0
+        total_items = len(data)
+        for item in data:
+            rid = item.get('resource_id')
+            provided_owner = item.get('owner')
+            if rid in owners_map and provided_owner == owners_map[rid]:
+                owner_correct_count += 1
+        
+        owner_score = int((owner_correct_count / total_items * 30)) if total_items > 0 else 0
+        score += owner_score
+        details.append({"item": "负责人邮箱交叉比对", "score": owner_score, "max_score": 30, "passed": owner_score == 30, "reason": f"正确匹配了 {owner_correct_count}/{total_items} 个负责人"})
+
+    # 最终分处理
+    final_score = min(100, max(0, score))
+    
+    result = {
+        "total_score": final_score,
+        "details": details
+    }
+    
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0006/verify_workplace.py

@@ -0,0 +1,120 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+# Configuration for potential LLM usage
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    score = 0
+    details = []
+    
+    output_path = os.path.join(workspace, "analysis/valid_p300_peaks.json")
+    
+    # 1. Check file existence (10 points)
+    if os.path.exists(output_path):
+        score += 10
+        details.append({"item": "Output file existence", "score": 10, "max_score": 10, "passed": True, "reason": "Found analysis/valid_p300_peaks.json"})
+        
+        # 2. JSON Validity & Structure (10 points)
+        try:
+            with open(output_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+                data = json.loads(content)
+            score += 10
+            details.append({"item": "JSON validity", "score": 10, "max_score": 10, "passed": True, "reason": "File is valid JSON"})
+            
+            # 3. Precision Check: EVT_001 (25 points)
+            # Expected: 14.5
+            if "EVT_001" in data and abs(float(data["EVT_001"]) - 14.5) < 0.01:
+                score += 25
+                details.append({"item": "EVT_001 Correctness", "score": 25, "max_score": 25, "passed": True, "reason": "Correct peak (14.5) for EVT_001"})
+            else:
+                details.append({"item": "EVT_001 Correctness", "score": 0, "max_score": 25, "passed": False, "reason": f"Expected 14.5, got {data.get('EVT_001')}"})
+
+            # 4. Precision Check: EVT_005 (25 points)
+            # Expected: 18.2
+            if "EVT_005" in data and abs(float(data["EVT_005"]) - 18.2) < 0.01:
+                score += 25
+                details.append({"item": "EVT_005 Correctness", "score": 25, "max_score": 25, "passed": True, "reason": "Correct peak (18.2) for EVT_005"})
+            else:
+                details.append({"item": "EVT_005 Correctness", "score": 0, "max_score": 25, "passed": False, "reason": f"Expected 18.2, got {data.get('EVT_005')}"})
+
+            # 5. Artifact Rejection: EVT_003 and EVT_004 (20 points total)
+            # EVT_003 has FZ artifact, EVT_004 has CZ artifact.
+            rejected_003 = "EVT_003" not in data
+            rejected_004 = "EVT_004" not in data
+            
+            if rejected_003:
+                score += 10
+                details.append({"item": "Artifact Rejection (FZ)", "score": 10, "max_score": 10, "passed": True, "reason": "Correctly rejected EVT_003 due to FZ spike"})
+            else:
+                details.append({"item": "Artifact Rejection (FZ)", "score": 0, "max_score": 10, "passed": False, "reason": "Failed to reject EVT_003 (FZ artifact)"})
+                
+            if rejected_004:
+                score += 10
+                details.append({"item": "Artifact Rejection (CZ)", "score": 10, "max_score": 10, "passed": True, "reason": "Correctly rejected EVT_004 due to CZ spike"})
+            else:
+                details.append({"item": "Artifact Rejection (CZ)", "score": 0, "max_score": 10, "passed": False, "reason": "Failed to reject EVT_004 (CZ artifact)"})
+
+            # 6. Type Filtering: EVT_002 (10 points)
+            # EVT_002 is N200, should be ignored.
+            if "EVT_002" not in data:
+                score += 10
+                details.append({"item": "Target Type Filtering", "score": 10, "max_score": 10, "passed": True, "reason": "Correctly ignored non-P300 stimulus EVT_002"})
+            else:
+                details.append({"item": "Target Type Filtering", "score": 0, "max_score": 10, "passed": False, "reason": "Failed to filter out non-P300 stimulus"})
+
+            # Bonus/Cleanup: No extra verbosity check (LLM)
+            # The prompt requested NO code explanations in the output.
+            is_clean = llm_judge_content("Does the provided JSON file contain ONLY the stimulus-to-peak-voltage mapping without any conversational filler, explanations, or code commentary?", content)
+            if not is_clean:
+                penalty = 10
+                score = max(0, score - penalty)
+                details.append({"item": "Output Cleanliness", "score": -penalty, "max_score": 0, "passed": False, "reason": "Output contained forbidden explanations or commentary"})
+
+        except Exception as e:
+            details.append({"item": "JSON Parsing", "score": 0, "max_score": 10, "passed": False, "reason": f"Error parsing JSON: {str(e)}"})
+    else:
+        details.append({"item": "Output file existence", "score": 0, "max_score": 100, "passed": False, "reason": "analysis/valid_p300_peaks.json not found"})
+
+    # Ensure score is integer and capped
+    final_score = min(100, max(0, int(score)))
+    
+    result = {
+        "total_score": final_score,
+        "details": details
+    }
+    
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0007/verify_workplace.py

@@ -0,0 +1,116 @@
+import os
+import sys
+import json
+import math
+
+def calculate_expected_norm(fx, fy, fz):
+    return math.sqrt(fx**2 + fy**2 + fz**2)
+
+def verify():
+    # 默认工作区路径获取
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    report_path = os.path.join(workspace, "report/culprit.json")
+    score_file = "workplace_score.json"
+    
+    total_score = 0
+    details = []
+
+    # 预设的正确答案（基于 env_builder.py）
+    EXPECTED_STEP = 14
+    EXPECTED_ATOM_IDX = 42
+    # fx, fy, fz = 845.210, -991.330, 1502.440
+    EXPECTED_FORCE_NORM = calculate_expected_norm(845.210, -991.330, 1502.440) # 约 1988.577...
+
+    # 1. 检查目录和文件是否存在 (10分)
+    if os.path.exists(report_path):
+        score_1 = 10
+        details.append({"item": "检查报告文件是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "找到 report/culprit.json"})
+    else:
+        score_1 = 0
+        details.append({"item": "检查报告文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "未找到 report/culprit.json"})
+        # 如果文件不存在，后续检查无法进行，直接写入结果
+        with open(score_file, "w") as f:
+            json.dump({"total_score": 0, "details": details}, f, indent=2)
+        return
+
+    # 2. 检查 JSON 格式合法性 (10分)
+    try:
+        with open(report_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        score_2 = 10
+        details.append({"item": "检查 JSON 格式合法性", "score": 10, "max_score": 10, "passed": True, "reason": "JSON 解析成功"})
+    except Exception as e:
+        score_2 = 0
+        details.append({"item": "检查 JSON 格式合法性", "score": 0, "max_score": 10, "passed": False, "reason": f"JSON 解析失败: {str(e)}"})
+        with open(score_file, "w") as f:
+            json.dump({"total_score": score_1, "details": details}, f, indent=2)
+        return
+
+    # 3. 验证离子步序号 (20分)
+    # 字段名可能不唯一，允许 agent 使用常用字段名，但优先匹配题目要求的逻辑
+    step_keys = ["ionic_step", "step", "step_number", "fatal_step"]
+    found_step = None
+    for k in step_keys:
+        if k in data:
+            found_step = data[k]
+            break
+    
+    if found_step == EXPECTED_STEP:
+        score_3 = 20
+        details.append({"item": "验证致命离子步序号", "score": 20, "max_score": 20, "passed": True, "reason": f"离子步序号正确: {found_step}"})
+    else:
+        score_3 = 0
+        details.append({"item": "验证致命离子步序号", "score": 0, "max_score": 20, "passed": False, "reason": f"序号错误或缺失，期望 {EXPECTED_STEP}，实际拿到 {found_step}"})
+
+    # 4. 验证原子索引 (30分)
+    atom_keys = ["atom_index", "culprit_atom", "atom_id", "atom_idx"]
+    found_atom = None
+    for k in atom_keys:
+        if k in data:
+            found_atom = data[k]
+            break
+    
+    if found_atom == EXPECTED_ATOM_IDX:
+        score_4 = 30
+        details.append({"item": "验证异常原子索引", "score": 30, "max_score": 30, "passed": True, "reason": f"原子索引正确: {found_atom}"})
+    else:
+        score_4 = 0
+        details.append({"item": "验证异常原子索引", "score": 0, "max_score": 30, "passed": False, "reason": f"索引错误或缺失，期望 {EXPECTED_ATOM_IDX}，实际拿到 {found_atom}"})
+
+    # 5. 验证受力大小 (30分)
+    force_keys = ["force_magnitude", "force_norm", "max_force", "force"]
+    found_force = None
+    for k in force_keys:
+        if k in data:
+            found_force = data[k]
+            break
+    
+    if found_force is not None:
+        try:
+            val = float(found_force)
+            if math.isclose(val, EXPECTED_FORCE_NORM, rel_tol=1e-3):
+                score_5 = 30
+                details.append({"item": "验证受力绝对值计算", "score": 30, "max_score": 30, "passed": True, "reason": f"受力大小符合预期: {val}"})
+            else:
+                score_5 = 0
+                details.append({"item": "验证受力绝对值计算", "score": 0, "max_score": 30, "passed": False, "reason": f"数值偏差过大，期望约 {EXPECTED_FORCE_NORM:.4f}, 实际为 {val}"})
+        except:
+            score_5 = 0
+            details.append({"item": "验证受力绝对值计算", "score": 0, "max_score": 30, "passed": False, "reason": "受力字段无法转换为浮点数"})
+    else:
+        score_5 = 0
+        details.append({"item": "验证受力绝对值计算", "score": 0, "max_score": 30, "passed": False, "reason": "未找到受力大小字段"})
+
+    # 汇总
+    total_score = score_1 + score_2 + score_3 + score_4 + score_5
+    
+    # 额外检查：如果 Agent 提供了多余的虚假字段（如猜测的化学元素等题目没给的信息），酌情扣分 (可选防御性逻辑)
+    if len(data) > 6:
+         total_score = max(0, total_score - 5)
+         details.append({"item": "冗余信息惩罚", "score": -5, "max_score": 0, "passed": False, "reason": "JSON中包含过量未要求的字段，可能存在幻觉"})
+
+    with open(score_file, "w") as f:
+        json.dump({"total_score": int(total_score), "details": details}, f, indent=2)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0008/verify_workplace.py

@@ -0,0 +1,61 @@
+import os
+import sys
+import json
+
+def verify():
+    # 基础路径处理
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    report_path = os.path.join(workspace, "reports/bottleneck.json")
+    
+    score = 0
+    details = []
+
+    # 1. 检查结果文件是否存在 (10分)
+    if os.path.exists(report_path):
+        score += 10
+        details.append({"item": "Check reports/bottleneck.json existence", "score": 10, "max_score": 10, "passed": True, "reason": "Report file found."})
+    else:
+        details.append({"item": "Check reports/bottleneck.json existence", "score": 0, "max_score": 10, "passed": False, "reason": "Report file not found."})
+        # 如果文件不存在，后续检查无法进行，直接写入结果
+        write_score(score, details)
+        return
+
+    # 2. 检查 JSON 格式与 Schema 合法性 (20分)
+    try:
+        with open(report_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        if "bottleneck_entity" in data:
+            score += 20
+            details.append({"item": "Verify JSON Schema", "score": 20, "max_score": 20, "passed": True, "reason": "Key 'bottleneck_entity' exists."})
+            
+            # 3. 检查 Entity ID 准确性 (70分)
+            # 根据 env_builder.py, target_entity = "8847291"
+            actual_id = str(data["bottleneck_entity"]).strip()
+            expected_id = "8847291"
+            
+            if actual_id == expected_id:
+                score += 70
+                details.append({"item": "Verify Bottleneck Entity ID", "score": 70, "max_score": 70, "passed": True, "reason": f"Correct entity ID found: {actual_id}"})
+            else:
+                details.append({"item": "Verify Bottleneck Entity ID", "score": 0, "max_score": 70, "passed": False, "reason": f"Incorrect entity ID. Expected {expected_id}, but got {actual_id}"})
+        
+        else:
+            details.append({"item": "Verify JSON Schema", "score": 0, "max_score": 20, "passed": False, "reason": "Required key 'bottleneck_entity' is missing."})
+
+    except json.JSONDecodeError:
+        details.append({"item": "Verify JSON Schema", "score": 0, "max_score": 20, "passed": False, "reason": "File is not a valid JSON."})
+    except Exception as e:
+        details.append({"item": "Verify JSON Schema", "score": 0, "max_score": 20, "passed": False, "reason": f"Unexpected error: {str(e)}"})
+
+    write_score(score, details)
+
+def write_score(total_score, details):
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump({
+            "total_score": total_score,
+            "details": details
+        }, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0009/verify_workplace.py

@@ -0,0 +1,216 @@
+import os
+import sys
+import json
+import math
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，强制关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify(workspace):
+    score_details = []
+    total_score = 0
+    target_file = os.path.join(workspace, "output", "critical_state.json")
+
+    # 1. 检查文件是否存在 (20分)
+    if not os.path.exists(target_file):
+        score_details.append({
+            "item": "检查结果文件是否存在",
+            "score": 0,
+            "max_score": 20,
+            "passed": False,
+            "reason": f"未找到文件 {target_file}"
+        })
+        write_score(0, score_details, workspace)
+        return
+    else:
+        score_details.append({
+            "item": "检查结果文件是否存在",
+            "score": 20,
+            "max_score": 20,
+            "passed": True,
+            "reason": "文件 output/critical_state.json 存在"
+        })
+        total_score += 20
+
+    # 2. 检查 JSON 格式合法性 (15分)
+    try:
+        with open(target_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        score_details.append({
+            "item": "检查 JSON 解析",
+            "score": 15,
+            "max_score": 15,
+            "passed": True,
+            "reason": "文件为合法 JSON"
+        })
+        total_score += 15
+    except Exception as e:
+        score_details.append({
+            "item": "检查 JSON 解析",
+            "score": 0,
+            "max_score": 15,
+            "passed": False,
+            "reason": f"解析 JSON 失败: {e}"
+        })
+        write_score(total_score, score_details, workspace)
+        return
+
+    # 3. 检查 JSON 键名准确性与无幻觉字段 (15分)
+    expected_keys = {"latest_quaternion", "max_temperature"}
+    actual_keys = set(data.keys())
+    if actual_keys == expected_keys:
+        score_details.append({
+            "item": "检查 JSON 字段严格匹配",
+            "score": 15,
+            "max_score": 15,
+            "passed": True,
+            "reason": "字段名称完全匹配，无多余捏造字段"
+        })
+        total_score += 15
+    else:
+        missing = expected_keys - actual_keys
+        extra = actual_keys - expected_keys
+        reason_parts = []
+        if missing: reason_parts.append(f"缺失: {missing}")
+        if extra: reason_parts.append(f"多余: {extra}")
+        score_details.append({
+            "item": "检查 JSON 字段严格匹配",
+            "score": 0,
+            "max_score": 15,
+            "passed": False,
+            "reason": "字段不完全匹配。 " + " | ".join(reason_parts)
+        })
+
+    # 4. 检查 max_temperature 计算结果 (25分)
+    temp = data.get("max_temperature", None)
+    if temp is not None:
+        try:
+            temp_val = float(temp)
+            # 正确值为 94.75。容忍度很低
+            if math.isclose(temp_val, 94.75, abs_tol=0.01):
+                score_details.append({
+                    "item": "验证最大异常温度峰值",
+                    "score": 25,
+                    "max_score": 25,
+                    "passed": True,
+                    "reason": "最高异常温度峰值精确等于 94.75"
+                })
+                total_score += 25
+            else:
+                score_details.append({
+                    "item": "验证最大异常温度峰值",
+                    "score": 0,
+                    "max_score": 25,
+                    "passed": False,
+                    "reason": f"温度值错误，期望 94.75，实际为 {temp_val}"
+                })
+        except ValueError:
+            score_details.append({
+                "item": "验证最大异常温度峰值",
+                "score": 0,
+                "max_score": 25,
+                "passed": False,
+                "reason": "max_temperature 并非有效数值类型"
+            })
+    else:
+        score_details.append({
+            "item": "验证最大异常温度峰值",
+            "score": 0,
+            "max_score": 25,
+            "passed": False,
+            "reason": "未找到 max_temperature 字段"
+        })
+
+    # 5. 检查 latest_quaternion 提取与计算结果 (25分)
+    quat = data.get("latest_quaternion", None)
+    if quat is not None:
+        if isinstance(quat, list) and len(quat) == 4:
+            expected_quat = [0.4999, 0.5001, -0.4999, -0.5001]
+            try:
+                match_all = True
+                for val, exp in zip(quat, expected_quat):
+                    if not math.isclose(float(val), exp, abs_tol=0.0002):
+                        match_all = False
+                        break
+                if match_all:
+                    score_details.append({
+                        "item": "验证最新星象仪四元数",
+                        "score": 25,
+                        "max_score": 25,
+                        "passed": True,
+                        "reason": f"成功提取有效时间最新的一帧四元数并保留正确小数位"
+                    })
+                    total_score += 25
+                else:
+                    score_details.append({
+                        "item": "验证最新星象仪四元数",
+                        "score": 0,
+                        "max_score": 25,
+                        "passed": False,
+                        "reason": f"四元数值不匹配，可能找错了时间帧、提取到了被破坏的帧头数据或解析小/大端序出错。实际值：{quat}"
+                    })
+            except ValueError:
+                score_details.append({
+                    "item": "验证最新星象仪四元数",
+                    "score": 0,
+                    "max_score": 25,
+                    "passed": False,
+                    "reason": "数组内含有非数值数据"
+                })
+        else:
+            score_details.append({
+                "item": "验证最新星象仪四元数",
+                "score": 0,
+                "max_score": 25,
+                "passed": False,
+                "reason": "latest_quaternion 格式错误，必须为包含4个数值的数组"
+            })
+    else:
+        score_details.append({
+            "item": "验证最新星象仪四元数",
+            "score": 0,
+            "max_score": 25,
+            "passed": False,
+            "reason": "未找到 latest_quaternion 字段"
+        })
+
+    write_score(total_score, score_details, workspace)
+
+def write_score(total_score, details, workspace):
+    result = {
+        "total_score": total_score,
+        "details": details
+    }
+    with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+if __name__ == "__main__":
+    work_dir = sys.argv[1] if len(sys.argv) > 1 else "."
+    verify(work_dir)

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0010/verify_workplace.py

@@ -0,0 +1,117 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    target_file = os.path.join(workspace, "report", "failed_init.json")
+    
+    total_score = 0
+    details = []
+
+    # 1. 检查目标文件是否存在 (20分)
+    if os.path.isfile(target_file):
+        total_score += 20
+        details.append({"item": "检查结果文件是否存在", "score": 20, "max_score": 20, "passed": True, "reason": "文件 report/failed_init.json 存在"})
+    else:
+        details.append({"item": "检查结果文件是否存在", "score": 0, "max_score": 20, "passed": False, "reason": "文件 report/failed_init.json 不存在"})
+        write_score(total_score, details)
+        return
+
+    # 2. 检查文件是否为合法的 JSON 格式 (20分)
+    try:
+        with open(target_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        total_score += 20
+        details.append({"item": "检查文件是否为合法 JSON", "score": 20, "max_score": 20, "passed": True, "reason": "成功解析 JSON 文件"})
+    except json.JSONDecodeError:
+        details.append({"item": "检查文件是否为合法 JSON", "score": 0, "max_score": 20, "passed": False, "reason": "文件内容不是合法的 JSON 格式"})
+        write_score(total_score, details)
+        return
+    except Exception as e:
+        details.append({"item": "检查文件是否为合法 JSON", "score": 0, "max_score": 20, "passed": False, "reason": f"文件读取发生未知错误: {str(e)}"})
+        write_score(total_score, details)
+        return
+
+    # 3. 检查 JSON 字段完整性 (10分)
+    if not isinstance(data, dict):
+        details.append({"item": "检查 JSON 结构类型", "score": 0, "max_score": 10, "passed": False, "reason": "JSON 根节点必须是一个对象 (dict)"})
+        write_score(total_score, details)
+        return
+
+    has_register = "register" in data
+    has_value = "value" in data
+    extra_keys = set(data.keys()) - {"register", "value"}
+
+    if has_register and has_value:
+        if extra_keys:
+            # 存在冗余字段，扣5分
+            total_score += 5
+            details.append({"item": "检查 JSON 字段", "score": 5, "max_score": 10, "passed": False, "reason": f"包含了必要的字段，但存在冗余字段: {extra_keys}"})
+        else:
+            total_score += 10
+            details.append({"item": "检查 JSON 字段", "score": 10, "max_score": 10, "passed": True, "reason": "精确包含了 register 和 value 字段"})
+    else:
+        details.append({"item": "检查 JSON 字段", "score": 0, "max_score": 10, "passed": False, "reason": "缺失 register 或 value 字段"})
+        write_score(total_score, details)
+        return
+
+    # 4. 提取并校验 register 的值 (25分)
+    reg_val = str(data.get("register", "")).strip().lower()
+    if reg_val == "0x2a":
+        total_score += 25
+        details.append({"item": "校验报错的寄存器地址", "score": 25, "max_score": 25, "passed": True, "reason": "找到了正确的寄存器地址 0x2A"})
+    else:
+        details.append({"item": "校验报错的寄存器地址", "score": 0, "max_score": 25, "passed": False, "reason": f"寄存器地址错误或格式不标准，预期 '0x2A'，实际获取到 '{reg_val}'"})
+
+    # 5. 提取并校验 value 的值 (25分)
+    val_val = str(data.get("value", "")).strip().lower()
+    if val_val == "0x7f":
+        total_score += 25
+        details.append({"item": "校验试图写入的错误数据", "score": 25, "max_score": 25, "passed": True, "reason": "找到了正确的报错数据 0x7F"})
+    else:
+        details.append({"item": "校验试图写入的错误数据", "score": 0, "max_score": 25, "passed": False, "reason": f"试图写入的数据错误或格式不标准，预期 '0x7F'，实际获取到 '{val_val}'"})
+
+    write_score(total_score, details)
+
+def write_score(total_score, details):
+    report = {
+        "total_score": total_score,
+        "details": details
+    }
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump(report, f, indent=2, ensure_ascii=False)
+    print(json.dumps(report, indent=2, ensure_ascii=False))
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0011/verify_workplace.py

@@ -0,0 +1,74 @@
+import os
+import sys
+import json
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    score = 0
+    details = []
+
+    target_file = os.path.join(workspace, "ops/kill_target.json")
+    
+    # 预期结果
+    EXPECTED_PID = 14920
+    EXPECTED_XID = 9948271
+
+    # 1. 检查文件是否存在 (10分)
+    if os.path.exists(target_file):
+        score += 10
+        details.append({"item": "文件检查", "score": 10, "max_score": 10, "passed": True, "reason": "ops/kill_target.json 存在"})
+        
+        # 2. 检查 JSON 格式与合法性 (20分)
+        try:
+            with open(target_file, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            score += 20
+            details.append({"item": "JSON格式验证", "score": 20, "max_score": 20, "passed": True, "reason": "JSON 解析成功"})
+            
+            # 3. 检查 PID 是否正确 (30分)
+            actual_pid = data.get("pid")
+            if actual_pid == EXPECTED_PID:
+                score += 30
+                details.append({"item": "PID 识别", "score": 30, "max_score": 30, "passed": True, "reason": "成功识别罪魁祸首 PID: 14920"})
+            elif str(actual_pid) == "0x3a48":
+                score += 15
+                details.append({"item": "PID 识别", "score": 15, "max_score": 30, "passed": False, "reason": "未将 PID 从十六进制转换为十进制"})
+            else:
+                details.append({"item": "PID 识别", "score": 0, "max_score": 30, "passed": False, "reason": f"PID 错误，识别为 {actual_pid}"})
+
+            # 4. 检查 XID 是否正确 (30分)
+            actual_xid = data.get("xid")
+            if actual_xid == EXPECTED_XID:
+                score += 30
+                details.append({"item": "XID 识别", "score": 30, "max_score": 30, "passed": True, "reason": "成功识别事务 ID: 9948271"})
+            else:
+                details.append({"item": "XID 识别", "score": 0, "max_score": 30, "passed": False, "reason": f"XID 错误，识别为 {actual_xid}"})
+
+            # 5. 检查是否存在多余字段或干扰项 (10分)
+            # 要求只有 pid 和 xid
+            allowed_keys = {"pid", "xid"}
+            actual_keys = set(data.keys())
+            if actual_keys == allowed_keys:
+                score += 10
+                details.append({"item": "字段精简度", "score": 10, "max_score": 10, "passed": True, "reason": "输出字段精准，无多余分析"})
+            else:
+                details.append({"item": "字段精简度", "score": 0, "max_score": 10, "passed": False, "reason": f"包含多余字段: {actual_keys - allowed_keys}"})
+
+        except json.JSONDecodeError:
+            details.append({"item": "JSON格式验证", "score": 0, "max_score": 20, "passed": False, "reason": "JSON 格式非法"})
+        except Exception as e:
+            details.append({"item": "异常错误", "score": 0, "max_score": 0, "passed": False, "reason": str(e)})
+    else:
+        details.append({"item": "文件检查", "score": 0, "max_score": 10, "passed": False, "reason": "ops/kill_target.json 不存在"})
+
+    # 写入评分结果
+    output_result = {
+        "total_score": score,
+        "details": details
+    }
+    with open("workplace_score.json", "w", encoding='utf-8') as f:
+        json.dump(output_result, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0012/verify_workplace.py

@@ -0,0 +1,111 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+# Configuration for LLM Judge
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    """Unified interface for non-structured text validation."""
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    score = 0
+    details = []
+    
+    report_path = os.path.join(workspace, "report/conflict_summary.json")
+    
+    # 1. Check file existence (10 points)
+    if os.path.exists(report_path):
+        score += 10
+        details.append({"item": "Check report existence", "score": 10, "max_score": 10, "passed": True, "reason": "File exists."})
+    else:
+        details.append({"item": "Check report existence", "score": 0, "max_score": 10, "passed": False, "reason": "File not found."})
+        # Cannot proceed without file
+        final_output(score, details)
+        return
+
+    # 2. Check JSON validity (10 points)
+    data = {}
+    try:
+        with open(report_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        score += 10
+        details.append({"item": "JSON Format Validation", "score": 10, "max_score": 10, "passed": True, "reason": "Valid JSON format."})
+    except Exception as e:
+        details.append({"item": "JSON Format Validation", "score": 0, "max_score": 10, "passed": False, "reason": f"Invalid JSON: {e}"})
+        final_output(score, details)
+        return
+
+    # 3. Check for the exactly three pieces of information constraint (10 points)
+    # The prompt asks for "exactly three pieces of information"
+    if len(data.keys()) == 3:
+        score += 10
+        details.append({"item": "Constraint: Exactly 3 fields", "score": 10, "max_score": 10, "passed": True, "reason": "Report contains exactly three keys."})
+    else:
+        details.append({"item": "Constraint: Exactly 3 fields", "score": 0, "max_score": 10, "passed": False, "reason": f"Expected 3 fields, found {len(data.keys())}."})
+
+    # 4. Verify Library Name (25 points)
+    # Use LLM to ensure flexible naming (fmt vs fmtlib)
+    lib_name = str(next(iter(data.values()))) # Get first value as a placeholder if keys aren't named
+    # Better to look for specific key logic, but prompt didn't define keys. Let's find the library name in the values.
+    values_str = json.dumps(data)
+    lib_correct = llm_judge_content("Does the following JSON content identify 'fmt' or 'fmtlib' as the conflicting library?", values_str)
+    if lib_correct:
+        score += 25
+        details.append({"item": "Library Identification", "score": 25, "max_score": 25, "passed": True, "reason": "Identified 'fmtlib' correctly."})
+    else:
+        details.append({"item": "Library Identification", "score": 0, "max_score": 25, "passed": False, "reason": "Failed to identify 'fmtlib' as the conflicting library."})
+
+    # 5. Verify Expected Version (20 points)
+    # Expected version in manifest is 9.1.0
+    if "9.1.0" in values_str:
+        score += 20
+        details.append({"item": "Expected Version Accuracy", "score": 20, "max_score": 20, "passed": True, "reason": "Found expected version 9.1.0."})
+    else:
+        details.append({"item": "Expected Version Accuracy", "score": 0, "max_score": 20, "passed": False, "reason": "Missing or incorrect expected version (should be 9.1.0)."})
+
+    # 6. Verify Rogue Version (25 points)
+    # Rogue version in log is 8.0.1
+    if "8.0.1" in values_str:
+        score += 25
+        details.append({"item": "Rogue Version Accuracy", "score": 25, "max_score": 25, "passed": True, "reason": "Found rogue version 8.0.1."})
+    else:
+        details.append({"item": "Rogue Version Accuracy", "score": 0, "max_score": 25, "passed": False, "reason": "Missing or incorrect rogue version (should be 8.0.1)."})
+
+    final_output(score, details)
+
+def final_output(score, details):
+    output = {
+        "total_score": min(100, score),
+        "details": details
+    }
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump(output, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0013/verify_workplace.py

@@ -0,0 +1,110 @@
+import os
+import sys
+import json
+
+def run_reference_logic(file_path):
+    """
+    参考实现逻辑：解析原始 L2 数据并找出首个有效的买卖盘倒挂。
+    """
+    max_ts = -1
+    result = None
+
+    if not os.path.exists(file_path):
+        return None
+
+    with open(file_path, "r", encoding="utf-8") as f:
+        for line in f:
+            parts = line.strip().split('\x01')
+            if len(parts) != 4:
+                continue
+            
+            try:
+                ts = int(parts[0])
+                symbol = parts[1]
+                bids_str = parts[2]
+                asks_str = parts[3]
+            except ValueError:
+                continue
+
+            # 严格单调递增检查
+            if ts <= max_ts:
+                continue
+            max_ts = ts
+
+            # 解析买盘最优价 (Bid[0])
+            try:
+                best_bid = float(bids_str.split('|')[0].split(':')[0])
+                best_ask = float(asks_str.split('|')[0].split(':')[0])
+            except (IndexError, ValueError):
+                continue
+
+            # 检查买卖盘倒挂 (Crossed Book)
+            if best_bid >= best_ask:
+                result = {"symbol": symbol, "timestamp": ts}
+                break # 找到第一个符合条件的即可
+    return result
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    target_json_path = os.path.join(workspace, "ops/target_replay.json")
+    raw_data_path = os.path.join(workspace, "snapshots/l2_orderbook.dat")
+    
+    score = 0
+    details = []
+
+    # 1. 检查目标文件是否存在 (10分)
+    if os.path.exists(target_json_path):
+        score += 10
+        details.append({"item": "检查结果文件是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "文件 ops/target_replay.json 已生成"})
+    else:
+        details.append({"item": "检查结果文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "文件 ops/target_replay.json 未找到"})
+        # 写入最终结果并提前退出
+        with open("workplace_score.json", "w") as f:
+            json.dump({"total_score": 0, "details": details}, f)
+        return
+
+    # 2. 检查 JSON 格式及字段 (20分)
+    agent_data = {}
+    try:
+        with open(target_json_path, "r") as f:
+            agent_data = json.load(f)
+        score += 10
+        details.append({"item": "JSON 格式合法性", "score": 10, "max_score": 10, "passed": True, "reason": "JSON 解析成功"})
+        
+        # 检查是否包含核心字段（允许大小写差异，但必须逻辑清晰）
+        keys = [k.lower() for k in agent_data.keys()]
+        if any("symbol" in k for k in keys) and any("timestamp" in k for k in keys):
+            score += 10
+            details.append({"item": "核心字段检查", "score": 10, "max_score": 10, "passed": True, "reason": "包含 symbol 和 timestamp 相关字段"})
+        else:
+            details.append({"item": "核心字段检查", "score": 0, "max_score": 10, "passed": False, "reason": f"缺少必要字段，当前包含: {list(agent_data.keys())}"})
+    except Exception as e:
+        details.append({"item": "JSON 格式合法性", "score": 0, "max_score": 20, "passed": False, "reason": f"解析失败: {str(e)}"})
+
+    # 3. 核心逻辑验证 (70分)
+    gold_standard = run_reference_logic(raw_data_path)
+    if not gold_standard:
+        details.append({"item": "数据源验证", "score": 0, "max_score": 70, "passed": False, "reason": "无法从原始数据中计算出参考答案，请检查环境"})
+    else:
+        agent_symbol = None
+        agent_ts = None
+        # 模糊匹配 Key
+        for k, v in agent_data.items():
+            if "symbol" in k.lower(): agent_symbol = v
+            if "timestamp" in k.lower() or "ts" in k.lower(): agent_ts = v
+
+        if str(agent_symbol) == str(gold_standard["symbol"]) and str(agent_ts) == str(gold_standard["timestamp"]):
+            score += 70
+            details.append({"item": "计算结果准确性", "score": 70, "max_score": 70, "passed": True, "reason": "成功定位到唯一的有效倒挂记录：FAT_FINGER_X"})
+        elif str(agent_symbol) == "TRAP_SYM":
+            score += 20
+            details.append({"item": "计算结果准确性", "score": 20, "max_score": 70, "passed": False, "reason": "错误！Agent 抓取了被时间戳倒挂过滤掉的陷阱数据 (TRAP_SYM)"})
+        else:
+            details.append({"item": "计算结果准确性", "score": 0, "max_score": 70, "passed": False, "reason": f"结果不匹配。期望: {gold_standard}, 实际: {agent_data}"})
+
+    # 写入最终总分
+    with open("workplace_score.json", "w") as f:
+        json.dump({"total_score": score, "details": details}, f, indent=2)
+
+if __name__ == "__main__":
+    main()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0014/verify_workplace.py

@@ -0,0 +1,93 @@
+import os
+import sys
+import json
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    report_path = os.path.join(workspace, "report/root_cause.json")
+    score = 0
+    details = []
+
+    # 1. Check Directory and File Existence (10 points)
+    if os.path.exists(os.path.join(workspace, "report")):
+        score += 5
+        details.append({"item": "检查报告目录", "score": 5, "max_score": 5, "passed": True, "reason": "目录 report 存在"})
+    else:
+        details.append({"item": "检查报告目录", "score": 0, "max_score": 5, "passed": False, "reason": "目录 report 不存在"})
+
+    if os.path.exists(report_path):
+        score += 5
+        details.append({"item": "检查报告文件是否存在", "score": 5, "max_score": 5, "passed": True, "reason": "文件 root_cause.json 存在"})
+    else:
+        details.append({"item": "检查报告文件是否存在", "score": 0, "max_score": 5, "passed": False, "reason": "文件 root_cause.json 不存在"})
+        # If the file doesn't exist, we can't perform further checks
+        save_results(score, details)
+        return
+
+    # 2. JSON Validity and Structure (20 points)
+    try:
+        with open(report_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        score += 10
+        details.append({"item": "检查JSON格式合法性", "score": 10, "max_score": 10, "passed": True, "reason": "JSON解析成功"})
+        
+        required_keys = ["device_address", "register_address", "illegal_value"]
+        missing_keys = [k for k in required_keys if k not in data]
+        if not missing_keys:
+            score += 10
+            details.append({"item": "检查JSON关键字段", "score": 10, "max_score": 10, "passed": True, "reason": "包含所有必需字段"})
+        else:
+            details.append({"item": "检查JSON关键字段", "score": 0, "max_score": 10, "passed": False, "reason": f"缺失字段: {missing_keys}"})
+    except Exception as e:
+        details.append({"item": "检查JSON格式合法性", "score": 0, "max_score": 20, "passed": False, "reason": f"JSON解析失败: {str(e)}"})
+        save_results(score, details)
+        return
+
+    # 3. Content Accuracy (70 points)
+    # Target Values based on env_builder.py: 
+    # device_address: 0x5C, register_address: 0x10, illegal_value: 0x4B
+    
+    def normalize_hex(val):
+        if not isinstance(val, str): return None
+        try:
+            return hex(int(val, 16)).lower()
+        except:
+            return None
+
+    dev_addr = normalize_hex(data.get("device_address"))
+    reg_addr = normalize_hex(data.get("register_address"))
+    ill_val = normalize_hex(data.get("illegal_value"))
+
+    # Device Address (20 points)
+    if dev_addr == "0x5c":
+        score += 20
+        details.append({"item": "验证设备地址 (device_address)", "score": 20, "max_score": 20, "passed": True, "reason": "正确识别 PMIC 地址 0x5C"})
+    else:
+        details.append({"item": "验证设备地址 (device_address)", "score": 0, "max_score": 20, "passed": False, "reason": f"预期 0x5C, 实际得到 {data.get('device_address')}"})
+
+    # Register Address (20 points)
+    if reg_addr == "0x10":
+        score += 20
+        details.append({"item": "验证寄存器地址 (register_address)", "score": 20, "max_score": 20, "passed": True, "reason": "正确识别核心电压寄存器 0x10"})
+    else:
+        details.append({"item": "验证寄存器地址 (register_address)", "score": 0, "max_score": 20, "passed": False, "reason": f"预期 0x10, 实际得到 {data.get('register_address')}"})
+
+    # Illegal Value (30 points)
+    if ill_val == "0x4b":
+        score += 30
+        details.append({"item": "验证非法写入值 (illegal_value)", "score": 30, "max_score": 30, "passed": True, "reason": "正确锁定导致崩溃的非法值 0x4B (超过 0x3F)"})
+    else:
+        details.append({"item": "验证非法写入值 (illegal_value)", "score": 0, "max_score": 30, "passed": False, "reason": f"预期 0x4B, 实际得到 {data.get('illegal_value')}"})
+
+    save_results(score, details)
+
+def save_results(score, details):
+    output = {
+        "total_score": score,
+        "details": details
+    }
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump(output, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0015/verify_workplace.py

@@ -0,0 +1,114 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    target_file = os.path.join(workspace, "optimizations", "target_gates.json")
+    
+    details = []
+    total_score = 0
+    
+    # 1. 检查目标文件是否存在 (10分)
+    if os.path.exists(target_file):
+        details.append({"item": "检查目标文件 target_gates.json 是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "文件已建立"})
+        total_score += 10
+    else:
+        details.append({"item": "检查目标文件 target_gates.json 是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "文件不存在，未按要求输出"})
+        write_score(total_score, details)
+        return
+
+    # 2. 检查 JSON 格式合法性 (10分)
+    # 此处严禁对结构化数据进行模糊匹配，必须原生解析
+    try:
+        with open(target_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        details.append({"item": "检查 JSON 格式合法性", "score": 10, "max_score": 10, "passed": True, "reason": "可成功解析为 JSON"})
+        total_score += 10
+    except Exception as e:
+        details.append({"item": "检查 JSON 格式合法性", "score": 0, "max_score": 10, "passed": False, "reason": f"非合法 JSON 格式，解析报错: {e}"})
+        write_score(total_score, details)
+        return
+
+    # 3. 检查 Schema 数据结构合规性 (10分)
+    # 题目明确要求输出 3 个逻辑门的 ID
+    if isinstance(data, list) and len(data) == 3 and all(isinstance(x, str) for x in data):
+        details.append({"item": "检查 Schema（含有3个字符串的数组）", "score": 10, "max_score": 10, "passed": True, "reason": "结构符合要求：一个包含3个字符串元素的列表"})
+        total_score += 10
+    else:
+        details.append({"item": "检查 Schema（含有3个字符串的数组）", "score": 0, "max_score": 10, "passed": False, "reason": f"未返回仅包含 3 个字符串的数组。当前数据：{data}"})
+        # 结构不对扣光后续分数，结束验证
+        write_score(total_score, details)
+        return
+        
+    # 4. 检查内容：命中率 (30分，每个关键 ID 10分)
+    # 根据底层注入规则：数据量最大的 3 个门固定为 F9A1, F9A2, F9A3
+    expected_gates = {"GATE_F9A1", "GATE_F9A2", "GATE_F9A3"}
+    matched = set(data).intersection(expected_gates)
+    hit_count = len(matched)
+    hit_score = hit_count * 10
+    
+    if hit_count == 3:
+        details.append({"item": "检查提取目标门 ID 的精确度", "score": 30, "max_score": 30, "passed": True, "reason": "完美找出所有 3 个异常通信量的逻辑门"})
+    else:
+        missing = expected_gates - set(data)
+        details.append({"item": "检查提取目标门 ID 的精确度", "score": hit_score, "max_score": 30, "passed": False, "reason": f"找到了 {hit_count} 个异常逻辑门, 缺失 {missing}"})
+    total_score += hit_score
+    
+    # 5. 检查内容：排序正确性 (40分)
+    # 数据量排序：GATE_F9A1(3500B) > GATE_F9A2(2800B) > GATE_F9A3(2100B)
+    expected_order = ["GATE_F9A1", "GATE_F9A2", "GATE_F9A3"]
+    if data == expected_order:
+        details.append({"item": "检查数组降序排序正确性", "score": 40, "max_score": 40, "passed": True, "reason": "元素严格按数据载荷大小从大到小排列"})
+        total_score += 40
+    else:
+        # 如果找齐了三个，但排序错误，可给出部分分数 10 分以作梯度区分，如果没找齐则得 0 分。
+        if hit_count == 3:
+            details.append({"item": "检查数组降序排序正确性", "score": 10, "max_score": 40, "passed": False, "reason": f"找出了所有门但排序错误，期望 {expected_order}，实际 {data}"})
+            total_score += 10
+        else:
+            details.append({"item": "检查数组降序排序正��性", "score": 0, "max_score": 40, "passed": False, "reason": "由于存在找错的门，排序亦判定为完全失败"})
+
+    write_score(total_score, details)
+
+def write_score(total_score, details):
+    res = {
+        "total_score": total_score,
+        "details": details
+    }
+    # 确保写入工作目录下的 workplace_score.json
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump(res, f, ensure_ascii=False, indent=2)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0016/verify_workplace.py

@@ -0,0 +1,160 @@
+import os
+import sys
+import json
+import re
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    target_file = os.path.join(workspace, "processed", "clean_traj_ids.txt")
+    
+    score_details = []
+    total_score = 0
+    
+    # 1. 检查目标文件是否存在 (15分)
+    file_exists = os.path.exists(target_file) and os.path.isfile(target_file)
+    if file_exists:
+        score_details.append({"item": "检查目标文件是否存在", "score": 15, "max_score": 15, "passed": True, "reason": "成功找到 `processed/clean_traj_ids.txt`"})
+        total_score += 15
+    else:
+        score_details.append({"item": "检查目标文件是否存在", "score": 0, "max_score": 15, "passed": False, "reason": "未找到目标文件 `processed/clean_traj_ids.txt`"})
+        
+    extracted_ids = []
+    pure_format = False
+    
+    if file_exists:
+        try:
+            with open(target_file, "r", encoding="utf-8") as f:
+                lines = f.readlines()
+            
+            # 清理空行并解析
+            raw_lines = [line.strip() for line in lines if line.strip()]
+            
+            # 2. 检查输出纯净度 (10分)
+            # 要求：别整那些没用的报告，只要 ID。所有的非空行应当全都是形如 T-xxxx 的格式。
+            pure_format = all(re.match(r'^T-\d+$', line) for line in raw_lines)
+            if pure_format and len(raw_lines) > 0:
+                score_details.append({"item": "检查输出纯净度", "score": 10, "max_score": 10, "passed": True, "reason": "输出无冗余报告废话，每行格式均为合法的 ID"})
+                total_score += 10
+            else:
+                score_details.append({"item": "检查输出纯净度", "score": 0, "max_score": 10, "passed": False, "reason": "输出中混杂了自然语言报告、无效格式或文件全空"})
+            
+            # 尝试提取出里面看起来像ID的串用于进一步逻辑验证
+            extracted_ids = []
+            for line in raw_lines:
+                # 若包含自然语言，则利用正则从中强行提取 T-xxx 评估实质清洗逻辑
+                matches = re.findall(r'T-\d+', line)
+                extracted_ids.extend(matches)
+                
+        except Exception as e:
+            score_details.append({"item": "检查输出纯净度", "score": 0, "max_score": 10, "passed": False, "reason": f"文件读取异常: {e}"})
+    else:
+        score_details.append({"item": "检查输出纯净度", "score": 0, "max_score": 10, "passed": False, "reason": "文件不存在，跳过纯净度检查"})
+
+    extracted_set = set(extracted_ids)
+
+    # 3. 检查乱码与损坏数据过滤能力 (15分)
+    # T-1005 (json未闭合) 和 T-1006 (十六进制乱码前缀) 不应存在
+    if file_exists:
+        if "T-1005" not in extracted_set and "T-1006" not in extracted_set:
+            score_details.append({"item": "过滤损坏的JSON与乱码数据", "score": 15, "max_score": 15, "passed": True, "reason": "正确剔除了无法被正常解析的 T-1005 和 T-1006"})
+            total_score += 15
+        else:
+            score_details.append({"item": "过滤损坏的JSON与乱码数据", "score": 0, "max_score": 15, "passed": False, "reason": "未正确拦截格式残缺或含乱码前缀的脏数据"})
+    else:
+         score_details.append({"item": "过滤损坏的JSON与乱码数据", "score": 0, "max_score": 15, "passed": False, "reason": "文件不存在，该项记 0 分"})
+
+    # 4. 检查 Token 截断数据的过滤能力 (15分)
+    # T-1003 (finish_reason = length) 不应存在
+    if file_exists:
+        if "T-1003" not in extracted_set:
+            score_details.append({"item": "过滤严重截断数据", "score": 15, "max_score": 15, "passed": True, "reason": "正确剔除了因为 max_tokens 截断（length）的残缺数据 T-1003"})
+            total_score += 15
+        else:
+            score_details.append({"item": "过滤严重截断数据", "score": 0, "max_score": 15, "passed": False, "reason": "未正确拦截 finish_reason 为 length 的数据"})
+    else:
+         score_details.append({"item": "过滤严重截断数据", "score": 0, "max_score": 15, "passed": False, "reason": "文件不存在，该项记 0 分"})
+
+    # 5. 检查 Agent 死循环数据的过滤能力 (15分)
+    # T-1002 (连续相同的 tool calls) 不应存在
+    if file_exists:
+        if "T-1002" not in extracted_set:
+            score_details.append({"item": "过滤陷入死循环的工具调用数据", "score": 15, "max_score": 15, "passed": True, "reason": "正确剔除了陷入无意义重复调用的 T-1002 数据"})
+            total_score += 15
+        else:
+            score_details.append({"item": "过滤陷入死循环的工具调用数据", "score": 0, "max_score": 15, "passed": False, "reason": "未正确拦截呈现死循环特征的轨迹数据 T-1002"})
+    else:
+         score_details.append({"item": "过滤陷入死循环的工具调用数据", "score": 0, "max_score": 15, "passed": False, "reason": "文件不存在，该项记 0 分"})
+
+    # 6. 检查健康轨迹的全量留存与拒答幻觉情况 (30分)
+    # 正确的数据集应当只包含：T-1001, T-1004, T-1007
+    if file_exists:
+        expected_ids = {"T-1001", "T-1004", "T-1007"}
+        missing_ids = expected_ids - extracted_set
+        # 计算提取列表中多出的且不在剔除名单里的虚构 ID (幻觉)
+        dirty_ids = {"T-1002", "T-1003", "T-1005", "T-1006"}
+        hallucinated_ids = extracted_set - expected_ids - dirty_ids
+        
+        health_score = 30
+        penalties = []
+        
+        if len(missing_ids) > 0:
+            penalty = len(missing_ids) * 10
+            health_score -= penalty
+            penalties.append(f"遗漏了合法数据 {missing_ids}，扣 {penalty} 分")
+            
+        if len(hallucinated_ids) > 0:
+            penalty = len(hallucinated_ids) * 10
+            health_score -= penalty
+            penalties.append(f"捏造了不存在的数据 ID {hallucinated_ids}，扣 {penalty} 分")
+            
+        health_score = max(0, health_score)
+        
+        if health_score == 30:
+            score_details.append({"item": "精准留存合法数据与幻觉抑制", "score": 30, "max_score": 30, "passed": True, "reason": "完美找出了所有的健康数据 T-1001, T-1004, T-1007，且无捏造或多余数据！"})
+        else:
+            score_details.append({"item": "精准留存合法数据与幻觉抑制", "score": health_score, "max_score": 30, "passed": False, "reason": "; ".join(penalties)})
+            
+        total_score += health_score
+    else:
+         score_details.append({"item": "精准留存合法数据与幻觉抑制", "score": 0, "max_score": 30, "passed": False, "reason": "文件不存在，该项记 0 分"})
+
+    # 保存评分文件
+    score_data = {
+        "total_score": total_score,
+        "details": score_details
+    }
+    
+    with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+        json.dump(score_data, f, ensure_ascii=False, indent=2)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0017/verify_workplace.py

@@ -0,0 +1,124 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    report_file = os.path.join(workspace, "report", "hacker.json")
+    
+    score = 0
+    details = []
+    
+    # 1. 检查目标目录存在性 (5分)
+    has_dir = os.path.isdir(os.path.join(workspace, "report"))
+    if has_dir:
+        score += 5
+        details.append({"item": "检查 report 目录是否存在", "score": 5, "max_score": 5, "passed": True, "reason": "report 目录存在"})
+    else:
+        details.append({"item": "检查 report 目录是否存在", "score": 0, "max_score": 5, "passed": False, "reason": "report 目录不存在"})
+        
+    # 2. 检查结果文件存在性 (15分)
+    has_file = os.path.isfile(report_file)
+    if has_file:
+        score += 15
+        details.append({"item": "检查 hacker.json 文件是否存在", "score": 15, "max_score": 15, "passed": True, "reason": "hacker.json 文件存在"})
+    else:
+        details.append({"item": "检查 hacker.json 文件是否存在", "score": 0, "max_score": 15, "passed": False, "reason": "hacker.json 文件不存在"})
+        
+    if not has_file:
+        save_score(score, details)
+        return
+        
+    # 3. 检查文件格式合法性 (10分)
+    try:
+        with open(report_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        score += 10
+        details.append({"item": "文件 JSON 格式合法性", "score": 10, "max_score": 10, "passed": True, "reason": "成功解析为 JSON 格式"})
+    except Exception as e:
+        details.append({"item": "文件 JSON 格式合法性", "score": 0, "max_score": 10, "passed": False, "reason": f"无法解析为 JSON，解析失败: {str(e)}"})
+        save_score(score, details)
+        return
+        
+    # 4. 字段规范与幻觉严查 (10分)
+    if not isinstance(data, dict):
+        details.append({"item": "字段规范检查", "score": 0, "max_score": 10, "passed": False, "reason": "JSON 根节点不是对象(dict)结构"})
+    else:
+        keys = list(data.keys())
+        expected_keys = {"hacker_address", "exploit_tx_hash"}
+        if set(keys) == expected_keys:
+            score += 10
+            details.append({"item": "字段规范检查", "score": 10, "max_score": 10, "passed": True, "reason": "字段完全匹配要求，无多余捏造字段"})
+        elif expected_keys.issubset(set(keys)):
+            score += 5
+            details.append({"item": "字段规范检查", "score": 5, "max_score": 10, "passed": False, "reason": "包含目标字段，但存在捏造的多余字段，部分扣分"})
+        else:
+            missing = expected_keys - set(keys)
+            details.append({"item": "字段规范检查", "score": 0, "max_score": 10, "passed": False, "reason": f"缺失必要字段: {missing}"})
+            
+    # 5. 黑客原始地址提取准确性 (30分)
+    ans_addr = "0xbadc0ffeebadc0ffeebadc0ffeebadc0ffeebadc"
+    if isinstance(data, dict) and "hacker_address" in data:
+        addr = str(data["hacker_address"]).strip().lower()
+        if addr == ans_addr:
+            score += 30
+            details.append({"item": "黑客地址正确性", "score": 30, "max_score": 30, "passed": True, "reason": "精准定位并提取了对应的 hacker_address"})
+        else:
+            details.append({"item": "黑客地址正确性", "score": 0, "max_score": 30, "passed": False, "reason": f"hacker_address 错误。期望: {ans_addr}，实际: {addr}"})
+    else:
+        details.append({"item": "黑客地址正确性", "score": 0, "max_score": 30, "passed": False, "reason": "无法验证，因文件内缺失 hacker_address 字段"})
+        
+    # 6. 致命交易哈希提取准确性 (30分)
+    ans_hash = "0xdeadbeef999999999999999999999999999999999999999999999999deadbeef"
+    if isinstance(data, dict) and "exploit_tx_hash" in data:
+        tx_hash = str(data["exploit_tx_hash"]).strip().lower()
+        if tx_hash == ans_hash:
+            score += 30
+            details.append({"item": "攻击交易哈希正确性", "score": 30, "max_score": 30, "passed": True, "reason": "精准提取了对应的 exploit_tx_hash"})
+        else:
+            details.append({"item": "攻击交易哈希正确性", "score": 0, "max_score": 30, "passed": False, "reason": f"exploit_tx_hash 错误。期望: {ans_hash}，实际: {tx_hash}"})
+    else:
+        details.append({"item": "攻击交易哈希正确性", "score": 0, "max_score": 30, "passed": False, "reason": "无法验证，因文件内缺失 exploit_tx_hash 字段"})
+        
+    save_score(score, details)
+
+def save_score(score, details):
+    res = {
+        "total_score": score,
+        "details": details
+    }
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump(res, f, ensure_ascii=False, indent=2)
+
+if __name__ == "__main__":
+    main()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0018/verify_workplace.py

@@ -0,0 +1,142 @@
+import os
+import sys
+import json
+import re
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def get_ground_truth(workspace):
+    """
+    沙盒内探针自己执行硬核逻辑，重新解析数据计算 Ground Truth，避免假阴性/假阳性。
+    """
+    can_log = os.path.join(workspace, "chassis_can.log")
+    radar_json = os.path.join(workspace, "sensor_data", "radar_track.json")
+    
+    if not os.path.exists(can_log) or not os.path.exists(radar_json):
+        return set()
+        
+    aeb_timestamps = []
+    with open(can_log, "r", encoding="utf-8") as f:
+        for line in f:
+            # 必须满足双重条件: 刹车CAN ID = 0x2B0, PAYLOAD 前两字节 = FF 01
+            if "MSG_ID:0x2B0" in line and "PAYLOAD:[FF 01" in line:
+                m = re.search(r"<(\d+)>", line)
+                if m:
+                    aeb_timestamps.append(int(m.group(1)))
+                    
+    truth_ids = set()
+    with open(radar_json, "r", encoding="utf-8") as f:
+        radar_data = json.load(f)
+        
+    frames = radar_data.get("data_stream", {}).get("radar_front_center", {}).get("frames", [])
+    for frame in frames:
+        stamp_ms = frame.get("header", {}).get("stamp_ms", 0)
+        # 严密的时间戳对齐：雷达比底盘快 1500ms
+        if (stamp_ms - 1500) in aeb_timestamps:
+            objects = frame.get("payload", {}).get("tracked_entities", {}).get("radar_objects", [])
+            for obj in objects:
+                rcs = obj.get("attributes", {}).get("rcs_dbsm", 999.0)
+                conf = obj.get("attributes", {}).get("track_confidence", 999)
+                # 必须满足 rcs < 5.0 且 confidence < 60
+                if rcs < 5.0 and conf < 60:
+                    tid = obj.get("metadata", {}).get("track_id", "")
+                    if tid:
+                        truth_ids.add(tid)
+                        
+    return truth_ids
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    target_file = os.path.join(workspace, "analysis", "ghost_ids.json")
+    
+    details = []
+    total_score = 0
+    
+    # 1. 验证目标文件存在性 (10分)
+    if os.path.exists(target_file):
+        total_score += 10
+        details.append({"item": "检查目标文件是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "文件 analysis/ghost_ids.json 存在"})
+    else:
+        details.append({"item": "检查目标文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "文件 analysis/ghost_ids.json 不存在"})
+        
+    # 2. 验证结构纯净性 (20分)
+    # 绝对禁止使用正则去匹配结构化结果，必须使用 json 库严格解析
+    agent_ids = []
+    is_valid_format = False
+    if os.path.exists(target_file):
+        try:
+            with open(target_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            if isinstance(data, list) and all(isinstance(i, str) for i in data):
+                is_valid_format = True
+                agent_ids = data
+                total_score += 20
+                details.append({"item": "JSON格式规范性验证", "score": 20, "max_score": 20, "passed": True, "reason": "是一个纯净的字符串数组"})
+            else:
+                details.append({"item": "JSON格式规范性验证", "score": 0, "max_score": 20, "passed": False, "reason": "结构错误，不是纯净的字符串数组"})
+        except json.JSONDecodeError:
+            details.append({"item": "JSON格式规范性验证", "score": 0, "max_score": 20, "passed": False, "reason": "非法的JSON文件"})
+    else:
+        details.append({"item": "JSON格式规范性验证", "score": 0, "max_score": 20, "passed": False, "reason": "文件缺失，无法验证"})
+
+    # 3. 数据精准度 (70分)
+    if is_valid_format:
+        truth_ids = get_ground_truth(workspace)
+        agent_set = set(agent_ids)
+        
+        if not truth_ids:
+            # 如果极端��况环境加载异常，这里进行容错
+            details.append({"item": "验证提取的 ID 准确性", "score": 0, "max_score": 70, "passed": False, "reason": "Ground Truth 数据生成错误，请检查环境"})
+        else:
+            intersection = agent_set.intersection(truth_ids)
+            false_positives = agent_set - truth_ids
+            false_negatives = truth_ids - agent_set
+            
+            union_len = len(agent_set.union(truth_ids))
+            # 使用严格的 Jaccard 相似度来反映 F1 维度的惩罚机制，有捏造、漏报均会急剧降分
+            data_score = int(70 * (len(intersection) / union_len)) if union_len > 0 else 0
+            
+            total_score += data_score
+            passed = (data_score == 70)
+            reason = f"精准度检查完成。正确提取: {len(intersection)}项, 漏报: {len(false_negatives)}项, 误报(幻觉/条件错误): {len(false_positives)}项"
+            details.append({"item": "验证提取的 ID 准确性", "score": data_score, "max_score": 70, "passed": passed, "reason": reason})
+    else:
+        details.append({"item": "验证提取的 ID 准确性", "score": 0, "max_score": 70, "passed": False, "reason": "由于文件不存在或格式不合规，跳过数据校验"})
+
+    # 统分写入
+    with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+        json.dump({
+            "total_score": total_score,
+            "details": details
+        }, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    main()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0019/verify_workplace.py

@@ -0,0 +1,107 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify_target(workspace):
+    score = 0
+    details = []
+
+    # 1. 检查目标目录是否存在 (10 分)
+    fix_list_dir = os.path.join(workspace, "fix_list")
+    if os.path.isdir(fix_list_dir):
+        score += 10
+        details.append({"item": "检查 fix_list 目录是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "目录 fix_list 成功创建"})
+    else:
+        details.append({"item": "检查 fix_list 目录是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "目录 fix_list 不存在"})
+
+    # 2. 检查结果文件是否存在 (20 分)
+    target_file = os.path.join(workspace, "fix_list", "target.json")
+    if os.path.isfile(target_file):
+        score += 20
+        details.append({"item": "检查 target.json 文件是否存在", "score": 20, "max_score": 20, "passed": True, "reason": "文件 target.json 存在"})
+        
+        # 3. 检查 JSON 格式是否合法 (20 分)
+        try:
+            with open(target_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            score += 20
+            details.append({"item": "检查 target.json 格式是否合法", "score": 20, "max_score": 20, "passed": True, "reason": "JSON 格式完全合法且可解析"})
+            
+            if isinstance(data, dict):
+                keys = list(data.keys())
+                
+                # 4. 检查字段完整性及防止作弊冗余 (10 分)
+                if "culprit_asset" in keys:
+                    if len(keys) > 1:
+                        score += 5
+                        details.append({"item": "检查是否仅包含 culprit_asset 字段", "score": 5, "max_score": 10, "passed": False, "reason": "包含 culprit_asset，但捏造/附带了冗余多余的字段，扣除 5 分"})
+                    else:
+                        score += 10
+                        details.append({"item": "检查是否仅包含 culprit_asset 字段", "score": 10, "max_score": 10, "passed": True, "reason": "有且仅有 culprit_asset 字段，非常干净"})
+                        
+                    # 5. 精准比对最终找到的资产路径值 (40 分)
+                    expected_value = "environments/ruins/statue_shattered_piece_04_cinematic.mesh"
+                    if data["culprit_asset"] == expected_value:
+                        score += 40
+                        details.append({"item": "比对 culprit_asset 值是否准确无误", "score": 40, "max_score": 40, "passed": True, "reason": "成功揪出了性能毛刺对应的超高顶点过场静态网格体"})
+                    else:
+                        details.append({"item": "比对 culprit_asset 值是否准确无误", "score": 0, "max_score": 40, "passed": False, "reason": f"资产路径不匹配。期望: {expected_value}，实际: {data['culprit_asset']}"})
+                else:
+                    details.append({"item": "检查是否仅包含 culprit_asset 字段", "score": 0, "max_score": 10, "passed": False, "reason": "完全缺失必须的 culprit_asset 键"})
+                    details.append({"item": "比对 culprit_asset 值是否准确无误", "score": 0, "max_score": 40, "passed": False, "reason": "因为键缺失，无法验证具体值"})
+            else:
+                details.append({"item": "检查 JSON 的根节点是否为字典结构", "score": 0, "max_score": 10, "passed": False, "reason": "目标 JSON 不是 Key-Value 格式的字典"})
+                details.append({"item": "比对 culprit_asset 值是否准确无误", "score": 0, "max_score": 40, "passed": False, "reason": "数据结构错误，无法获取对应键值"})
+
+        except json.JSONDecodeError as e:
+            details.append({"item": "检查 target.json 格式是否合法", "score": 0, "max_score": 20, "passed": False, "reason": f"JSON 解析失败或包含非法字符: {e}"})
+            details.append({"item": "检查是否仅包含 culprit_asset 字段", "score": 0, "max_score": 10, "passed": False, "reason": "JSON 无法解析，中止验证"})
+            details.append({"item": "比对 culprit_asset 值是否准确无误", "score": 0, "max_score": 40, "passed": False, "reason": "JSON 无法解析，中止验证"})
+            
+    else:
+        details.append({"item": "检查 target.json 文件是否存在", "score": 0, "max_score": 20, "passed": False, "reason": "文件 target.json 未找到"})
+        details.append({"item": "检查 target.json 格式是否合法", "score": 0, "max_score": 20, "passed": False, "reason": "文件缺失，中止验证"})
+        details.append({"item": "检查是否仅包含 culprit_asset 字段", "score": 0, "max_score": 10, "passed": False, "reason": "文件缺失，中止验证"})
+        details.append({"item": "比对 culprit_asset 值是否准确无误", "score": 0, "max_score": 40, "passed": False, "reason": "文件缺失，中止验证"})
+
+    # 输出结果记录
+    result = {
+        "total_score": score,
+        "details": details
+    }
+    with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    workspace_dir = sys.argv[1] if len(sys.argv) > 1 else "."
+    verify_target(workspace_dir)

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0020/verify_workplace.py

@@ -0,0 +1,156 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+# ----------------- 强制 API 规范 -----------------
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    """大模型语义检测接口，只用于检测自然语言语义/格式外废话"""
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+# -------------------------------------------------
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    target_file = os.path.join(workspace, "hotfix_target.json")
+    
+    score_details = []
+    total_score = 0
+    
+    # Check 1: 检查物理文件是否存在 (15分)
+    if os.path.exists(target_file):
+        total_score += 15
+        score_details.append({
+            "item": "检查 hotfix_target.json 文件是否存在",
+            "score": 15, "max_score": 15, "passed": True,
+            "reason": "目标文件 hotfix_target.json 存在"
+        })
+    else:
+        score_details.append({
+            "item": "检查 hotfix_target.json 文件是否存在",
+            "score": 0, "max_score": 15, "passed": False,
+            "reason": "未找到 hotfix_target.json 文件"
+        })
+        with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+            json.dump({"total_score": total_score, "details": score_details}, f, indent=2, ensure_ascii=False)
+        return
+
+    # Check 2: 检查文件格式及其内容结构 (15分)
+    try:
+        with open(target_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            
+        total_score += 15
+        score_details.append({
+            "item": "检查文件是否为合法 JSON",
+            "score": 15, "max_score": 15, "passed": True,
+            "reason": "成功以 JSON 格式解析文件"
+        })
+    except json.JSONDecodeError:
+        score_details.append({
+            "item": "检查文件是否为合法 JSON",
+            "score": 0, "max_score": 15, "passed": False,
+            "reason": "JSON 格式非法或存在语法错误"
+        })
+        with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+            json.dump({"total_score": total_score, "details": score_details}, f, indent=2, ensure_ascii=False)
+        return
+
+    # 附加语义检测：检查是否违背“不要废话内存管理原理”的指令
+    # 提取多余的文本字段或过长的注释值交由 LLM 判别
+    has_waste_talk = False
+    for key, value in data.items():
+        if isinstance(value, str) and len(value) > 30 and key not in ["archetype_id", "memory_address"]:
+            prompt = "Does the following text contain unsolicited textbook-style explanations or tutorials about computer memory management or ECS principles? If yes, answer 'YES', else 'NO'."
+            if llm_judge_content(prompt, value):
+                has_waste_talk = True
+                break
+                
+    if has_waste_talk:
+        # 一票否决性质的倒扣分
+        total_score = max(0, total_score - 10)
+        score_details.append({
+            "item": "严格遵守禁止说教的要求",
+            "score": -10, "max_score": 0, "passed": False,
+            "reason": "检测到多余的内存管理教科书原理解释（幻觉或违背 Persona），倒扣 10 分"
+        })
+    else:
+        score_details.append({
+            "item": "严格遵守禁止说教的要求",
+            "score": 0, "max_score": 0, "passed": True,
+            "reason": "输出干净简洁，未包含啰嗦的原理解释"
+        })
+
+    # Check 3: 精准检查 archetype_id 提取结果 (30分)
+    arch_id = str(data.get("archetype_id", "")).strip()
+    if arch_id == "ARCH_E7_DYNAMIC_MESH":
+        total_score += 30
+        score_details.append({
+            "item": "检查 archetype_id 定位是否精准",
+            "score": 30, "max_score": 30, "passed": True,
+            "reason": "成功分析日志并提取出发生高延迟的 ARCH_E7_DYNAMIC_MESH"
+        })
+    else:
+        score_details.append({
+            "item": "检查 archetype_id 定位是否精准",
+            "score": 0, "max_score": 30, "passed": False,
+            "reason": f"提取错误。期望为 ARCH_E7_DYNAMIC_MESH，实际为: '{arch_id}'"
+        })
+
+    # Check 4: 精准检查 memory_address 提取结果并排查诱饵陷阱 (40分)
+    mem_addr = str(data.get("memory_address", "")).strip().upper()
+    if mem_addr == "0X000002B47C90F000":
+        total_score += 40
+        score_details.append({
+            "item": "检查 memory_address 定位是否精准并避开诱饵",
+            "score": 40, "max_score": 40, "passed": True,
+            "reason": "成功定位具有最多碎片的正确内存块 0x000002B47C90F000，且没有掉入诱饵陷阱"
+        })
+    elif mem_addr == "0X000001FA88000000":
+        # 掉入了 Decoy 陷阱：找到了 F 最多的块，但没验证这个块是不是属于前面的 archetype
+        total_score += 10
+        score_details.append({
+            "item": "检查 memory_address 定位是否精准并避开诱饵",
+            "score": 10, "max_score": 40, "passed": False,
+            "reason": "错误！定位到了包含大量碎片的诱饵块 0x000001FA88000000，但在多表关联时未验证它的 ArchID 是否一致！"
+        })
+    else:
+        score_details.append({
+            "item": "检查 memory_address 定位是否精准并避开诱饵",
+            "score": 0, "max_score": 40, "passed": False,
+            "reason": f"内存地址定位完全错误，实际提取值为: '{mem_addr}'"
+        })
+
+    # Ensure total limits
+    total_score = max(0, min(100, total_score))
+    
+    # Output to workplace_score.json
+    with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+        json.dump({"total_score": total_score, "details": score_details}, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0021/verify_workplace.py

@@ -0,0 +1,214 @@
+import os
+import sys
+import json
+import httpx
+import re
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，强制关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    """用于对非结构化文本内容进行兜底或辅助语义判定"""
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify():
+    # 动态获取沙盒挂载的工作区路径
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    target_json_path = os.path.join(workspace, "debug", "root_cause.json")
+    
+    total_score = 0
+    details = []
+
+    # 1. 检查物理文件是否存在 (10 分)
+    if not os.path.exists(target_json_path):
+        details.append({
+            "item": "检查目标文件是否存在", 
+            "score": 0, 
+            "max_score": 10, 
+            "passed": False, 
+            "reason": "未找到 debug/root_cause.json 文件，Agent 未能在指定路径输出结果"
+        })
+        with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+            json.dump({"total_score": 0, "details": details}, f, indent=2, ensure_ascii=False)
+        return
+    else:
+        details.append({
+            "item": "检查目标文件是否存在", 
+            "score": 10, 
+            "max_score": 10, 
+            "passed": True, 
+            "reason": "文件 debug/root_cause.json 存在"
+        })
+        total_score += 10
+
+    # 2. 检查 JSON 语法合法性 (10 分)
+    try:
+        with open(target_json_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        details.append({
+            "item": "JSON 格式解析", 
+            "score": 10, 
+            "max_score": 10, 
+            "passed": True, 
+            "reason": "JSON 格式合法且可被标准库解析"
+        })
+        total_score += 10
+    except Exception as e:
+        details.append({
+            "item": "JSON 格式解析", 
+            "score": 0, 
+            "max_score": 10, 
+            "passed": False, 
+            "reason": f"解析失败，可能混入了多余字符或 markdown 格式: {e}"
+        })
+        with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+            json.dump({"total_score": total_score, "details": details}, f, indent=2, ensure_ascii=False)
+        return
+
+    # 3. 检查 JSON Schema 完整性与数据类型 (20 分)
+    # 不允许少任何一个键，也不允许多出胡编乱造的键
+    expected_keys = {"device_addr", "reg_addr", "bad_value"}
+    actual_keys = set(data.keys()) if isinstance(data, dict) else set()
+    
+    if actual_keys == expected_keys:
+        if all(isinstance(data[k], str) for k in expected_keys):
+            # 严格检查值是否为 "0x" 加上两个十六进制字符（大小写均可）
+            format_pass = all(re.match(r"^0x[0-9a-fA-F]{2}$", data[k]) for k in expected_keys)
+            if format_pass:
+                details.append({
+                    "item": "Schema 完整性与类型验证", 
+                    "score": 20, 
+                    "max_score": 20, 
+                    "passed": True, 
+                    "reason": "所有必填键均存在，无幻觉字段，且值严格遵循标准的 0xXX 字符串格式"
+                })
+                total_score += 20
+            else:
+                details.append({
+                    "item": "Schema 完整性与类型验证", 
+                    "score": 10, 
+                    "max_score": 20, 
+                    "passed": False, 
+                    "reason": "键正确且为字符串，但值未严格遵循 0xXX 的标准两位十六进制格式"
+                })
+                total_score += 10
+        else:
+            details.append({
+                "item": "Schema 完整性与类型验证", 
+                "score": 5, 
+                "max_score": 20, 
+                "passed": False, 
+                "reason": "键正确，但部分数据不是纯字符串类型（如被写为整数或包含其它嵌套结构）"
+            })
+            total_score += 5
+    else:
+        missing = expected_keys - actual_keys
+        extra = actual_keys - expected_keys
+        reason_parts = []
+        if missing: reason_parts.append(f"缺少必填键: {missing}")
+        if extra: reason_parts.append(f"捏造或多余键: {extra}")
+        details.append({
+            "item": "Schema 完整性与类型验证", 
+            "score": 0, 
+            "max_score": 20, 
+            "passed": False, 
+            "reason": " | ".join(reason_parts)
+        })
+
+    # 4. 严格值校验: device_addr (20 分)
+    device_addr = str(data.get("device_addr", "")).strip().lower()
+    if device_addr == "0x68":
+        details.append({
+            "item": "校验设备地址(device_addr)", 
+            "score": 20, 
+            "max_score": 20, 
+            "passed": True, 
+            "reason": "准确提取 I2C 基地址 0x68"
+        })
+        total_score += 20
+    elif device_addr == "0xd0":
+        details.append({
+            "item": "校验设备地址(device_addr)", 
+            "score": 10, 
+            "max_score": 20, 
+            "passed": False, 
+            "reason": "提取到 0xD0 (这是带 Write 位偏移后的传输地址)，虽然对应了抓包字节，但规范的 Base Addr 应为 0x68"
+        })
+        total_score += 10
+    else:
+        details.append({
+            "item": "校验设备地址(device_addr)", 
+            "score": 0, 
+            "max_score": 20, 
+            "passed": False, 
+            "reason": f"提取错误: {device_addr}"
+        })
+
+    # 5. 严格值校验: reg_addr (20 分)
+    reg_addr = str(data.get("reg_addr", "")).strip().lower()
+    if reg_addr == "0x6b":
+        details.append({
+            "item": "校验寄存器地址(reg_addr)", 
+            "score": 20, 
+            "max_score": 20, 
+            "passed": True, 
+            "reason": "准确提取触发死锁的 PWR_MGMT_1 寄存器地址 0x6B"
+        })
+        total_score += 20
+    else:
+        details.append({
+            "item": "校验寄存器地址(reg_addr)", 
+            "score": 0, 
+            "max_score": 20, 
+            "passed": False, 
+            "reason": f"寄存器地址提取错误: {reg_addr}"
+        })
+
+    # 6. 严格值校验: bad_value (20 分)
+    bad_value = str(data.get("bad_value", "")).strip().lower()
+    if bad_value == "0x80":
+        details.append({
+            "item": "校验致死错值(bad_value)", 
+            "score": 20, 
+            "max_score": 20, 
+            "passed": True, 
+            "reason": "准确提取触发 Errata 并导致看门狗复位的脏值 0x80"
+        })
+        total_score += 20
+    else:
+        details.append({
+            "item": "校验致死错值(bad_value)", 
+            "score": 0, 
+            "max_score": 20, 
+            "passed": False, 
+            "reason": f"错误值提取错误: {bad_value}"
+        })
+
+    # 写入最终判卷结果
+    with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+        json.dump({"total_score": total_score, "details": details}, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0022/verify_workplace.py

@@ -0,0 +1,117 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify_workplace(workspace):
+    score = 0
+    details = []
+    
+    # 目标路径配置
+    target_dir = os.path.join(workspace, "pipeline_fixes")
+    target_file = os.path.join(target_dir, "patch.json")
+    
+    # 真实数据源（防止基于大模型的幻觉或模糊匹配，必须通过精准代码强校验）
+    truth_node = "SHD_Flesh_Subsurface_09"
+    truth_texture = "/prod/show/SC043/assets/chars/mutant/tex/v003/diffuse_UDIM_1001.tx"
+    
+    # 1. 验证目标目录是否存在 (10分)
+    if os.path.isdir(target_dir):
+        score += 10
+        details.append({"item": "检查 pipeline_fixes 目录是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "成功创建 pipeline_fixes 目录"})
+    else:
+        details.append({"item": "检查 pipeline_fixes 目录是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "未找到 pipeline_fixes 目录"})
+        
+    # 2. 验证热修复文件是否存在 (10分)
+    file_exists = os.path.isfile(target_file)
+    if file_exists:
+        score += 10
+        details.append({"item": "检查 patch.json 文件是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "成功找到 patch.json 文件"})
+    else:
+        details.append({"item": "检查 patch.json 文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "未找到 patch.json 文件"})
+        
+    # 3. 严格验证 JSON 格式合法性及 Schema 字段约束 (20分)
+    data = None
+    if file_exists:
+        try:
+            with open(target_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            
+            # 使用强代码检查，严查任何画蛇添足的解释字段
+            if isinstance(data, dict):
+                keys = set(data.keys())
+                expected_keys = {"broken_node", "missing_texture"}
+                if keys == expected_keys:
+                    score += 20
+                    details.append({"item": "检查 JSON 格式与 Schema 合法性", "score": 20, "max_score": 20, "passed": True, "reason": "JSON 解析成功，且仅包含题目严格约束的两个字段，无冗余内容"})
+                else:
+                    details.append({"item": "检查 JSON 格式与 Schema 合法性", "score": 0, "max_score": 20, "passed": False, "reason": f"格式违规：包含预期外的字段或缺失字段，当前键集合：{list(keys)}"})
+            else:
+                details.append({"item": "检查 JSON 格式与 Schema 合法性", "score": 0, "max_score": 20, "passed": False, "reason": "JSON 根节点非字典(Object)类型"})
+        except json.JSONDecodeError:
+            details.append({"item": "检查 JSON 格式与 Schema 合法性", "score": 0, "max_score": 20, "passed": False, "reason": "文件不是合法的 JSON 格式，无法解析"})
+    else:
+        details.append({"item": "检查 JSON 格式与 Schema 合法性", "score": 0, "max_score": 20, "passed": False, "reason": "因文件不存在，无法进行格式校验"})
+
+    # 4. 验证核心数据：故障节点名的精准提取 (30分)
+    if data and isinstance(data, dict):
+        node_val = data.get("broken_node", "")
+        if node_val == truth_node:
+            score += 30
+            details.append({"item": "校验 broken_node 提取准确度", "score": 30, "max_score": 30, "passed": True, "reason": "成功在海量渲染日志的栈转储与十六进制报错中提取出真正的崩溃节点名"})
+        else:
+            details.append({"item": "校验 broken_node 提取准确度", "score": 0, "max_score": 30, "passed": False, "reason": f"节点提取错误，期望 [{truth_node}]，实际得到 [{node_val}]"})
+            
+    # 5. 验证核心数据：丢失贴图路径的精准解析与追踪 (30分)
+    if data and isinstance(data, dict):
+        tex_val = data.get("missing_texture", "")
+        if tex_val == truth_texture:
+            score += 30
+            details.append({"item": "校验 missing_texture 提取准确度", "score": 30, "max_score": 30, "passed": True, "reason": "成功在深层嵌套(拓扑极度复杂)的场景树中穿透干扰项，定位到了关联的贴图绝对路径"})
+        else:
+            details.append({"item": "校验 missing_texture 提取准确度", "score": 0, "max_score": 30, "passed": False, "reason": f"贴图路径追踪失败，期望 [{truth_texture}]，实际得到 [{tex_val}]"})
+    
+    if not data or not isinstance(data, dict):
+        details.append({"item": "校验 broken_node 提取准确度", "score": 0, "max_score": 30, "passed": False, "reason": "JSON 结构无效，无法校验提取准确度"})
+        details.append({"item": "校验 missing_texture 提取准确度", "score": 0, "max_score": 30, "passed": False, "reason": "JSON 结构无效，无法校验提取准确度"})
+        
+    result = {
+        "total_score": score,
+        "details": details
+    }
+    
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump(result, f, ensure_ascii=False, indent=2)
+
+if __name__ == "__main__":
+    workspace_dir = sys.argv[1] if len(sys.argv) > 1 else "."
+    verify_workplace(workspace_dir)

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0023/verify_workplace.py

@@ -0,0 +1,132 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify_workplace(workspace):
+    score = 0
+    details = []
+    
+    intel_dir = os.path.join(workspace, "intel")
+    iocs_file = os.path.join(intel_dir, "iocs.json")
+    
+    # 1. 检查目录与文件是否存在 (10 分)
+    if os.path.isdir(intel_dir) and os.path.isfile(iocs_file):
+        details.append({"item": "检查结果目录与目标文件是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "文件 intel/iocs.json 存在"})
+        score += 10
+    else:
+        details.append({"item": "检查结果目录与目标文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "未找到 intel/iocs.json 文件或目录"})
+        write_score(score, details, workspace)
+        return
+
+    # 2. 检查 JSON 格式合法性及结构严谨度 (10 分)
+    try:
+        with open(iocs_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        if isinstance(data, dict):
+            # 严格防止 Agent 幻觉或将大量数据直接全部导出作为 value 的作弊行为
+            if len(data.keys()) > 3:
+                details.append({"item": "检查 JSON 格式及结构严谨度", "score": 0, "max_score": 10, "passed": False, "reason": f"结构合法，但包含 {len(data.keys())} 个键，存在幻觉或冗余输出的作弊嫌疑"})
+            else:
+                details.append({"item": "检查 JSON 格式及结构严谨度", "score": 10, "max_score": 10, "passed": True, "reason": "合法的 JSON 字典结构，且无严重数据冗余"})
+                score += 10
+        else:
+            details.append({"item": "检查 JSON 格式及结构严谨度", "score": 0, "max_score": 10, "passed": False, "reason": "JSON 格式有效，但根节点不是预期的字典类型"})
+            write_score(score, details, workspace)
+            return
+    except Exception as e:
+        details.append({"item": "检查 JSON 格式及结构严谨度", "score": 0, "max_score": 10, "passed": False, "reason": f"JSON 解析失败: {str(e)}"})
+        write_score(score, details, workspace)
+        return
+
+    # 3 & 4. 精准比对确定性的业务结果 (各 30 分)
+    expected_path = r"c:/users/public/videos/svchost_stage2.exe"
+    expected_hex = "4D5A90000300000004000000FFFF0000"
+    
+    path_found = False
+    hex_found = False
+    
+    for v in data.values():
+        if not isinstance(v, str):
+            continue
+            
+        # 归一化：处理路径分隔符差异和大小写
+        v_path = v.replace("\\", "/").lower().strip()
+        # 归一化：剥除所有空格以适应不同的 hex 展现形式
+        v_hex = v.replace(" ", "").upper().strip()
+        
+        # 长度限制防止暴力照搬原文（超过200/100字符不认为是精准提取）
+        if len(v_path) < 200 and expected_path in v_path:
+            path_found = True
+        if len(v_hex) < 100 and expected_hex in v_hex:
+            hex_found = True
+
+    if path_found:
+        details.append({"item": "精准验证开机自启恶意路径提取", "score": 30, "max_score": 30, "passed": True, "reason": "正确提取了隐藏在茫茫系统调用日志中的目标文件路径"})
+        score += 30
+    else:
+        details.append({"item": "精准验证开机自启恶意路径提取", "score": 0, "max_score": 30, "passed": False, "reason": "未能精准提取并转换对应的启动项文件路径"})
+        
+    if hex_found:
+        details.append({"item": "精准验证 16 字节内存脱壳特征码", "score": 30, "max_score": 30, "passed": True, "reason": "正确提取了指定偏移量位置的纯净 16 字节特征码"})
+        score += 30
+    else:
+        details.append({"item": "精准验证 16 字节内存脱壳特征码", "score": 0, "max_score": 30, "passed": False, "reason": "未找到预期的特征码，或未进行 ASCII 数据清理清洗"})
+
+    # 5. 利用大模型对非结构化、由 Agent 自定义的键名���行语义检验 (20 分)
+    keys_str = ", ".join(data.keys())
+    llm_prompt = (
+        "The file content below represents the JSON keys an agent created to store Indicators of Compromise (IOCs).\n"
+        "According to the instruction, one key must logically represent an 'autostart file path' or 'registry payload',\n"
+        "and the other must represent a 'hex signature', 'MZ header', or 'file magic bytes'.\n"
+        "Are these keys appropriately named and easy for a human security analyst to read and understand?\n"
+    )
+    
+    if llm_judge_content(llm_prompt, f"JSON Keys Submitted: [{keys_str}]"):
+        details.append({"item": "LLM 语义校验：自定义键名可读性及专业度", "score": 20, "max_score": 20, "passed": True, "reason": f"大模型裁判认为自定义键名 [{keys_str}] 符合业务逻辑且人类可读"})
+        score += 20
+    else:
+        details.append({"item": "LLM 语义校验：自定义键名可读性及专业度", "score": 0, "max_score": 20, "passed": False, "reason": f"大模型裁判认为键名 [{keys_str}] 缺乏合理性、不知所云或未能概括数据属性"})
+
+    write_score(score, details, workspace)
+
+def write_score(score, details, workspace):
+    output = {
+        "total_score": score,
+        "details": details
+    }
+    with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+        json.dump(output, f, indent=4, ensure_ascii=False)
+    print(f"Verification completed. Score: {score}")
+
+if __name__ == "__main__":
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    verify_workplace(workspace)

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0024/verify_workplace.py

@@ -0,0 +1,122 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    
+    score_details = []
+    total_score = 0
+    
+    target_file = os.path.join(workspace, "hotfix", "version_pin.json")
+    
+    # Check 1: File Existence (10 points)
+    file_exists = os.path.exists(target_file)
+    if file_exists:
+        score_details.append({"item": "检查热更配置文件是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "文件 hotfix/version_pin.json 存在"})
+        total_score += 10
+    else:
+        score_details.append({"item": "检查热更配置文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "文件 hotfix/version_pin.json 缺失"})
+        
+    data = None
+    if file_exists:
+        # Check 2: JSON format (10 points)
+        try:
+            with open(target_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            score_details.append({"item": "检查文件是否为合法 JSON", "score": 10, "max_score": 10, "passed": True, "reason": "成功解析 JSON 格式"})
+            total_score += 10
+        except Exception as e:
+            score_details.append({"item": "检查文件是否为合法 JSON", "score": 0, "max_score": 10, "passed": False, "reason": f"JSON 解析失败: {e}"})
+            
+    if data and isinstance(data, dict):
+        # Check 3: Required Fields Presence (10 points)
+        required_fields = {"conflict_pkg", "bad_version", "system_version"}
+        actual_fields = set(data.keys())
+        missing = required_fields - actual_fields
+        extra = actual_fields - required_fields
+        
+        if not missing:
+            score_details.append({"item": "检查是否包含全部必填字段", "score": 10, "max_score": 10, "passed": True, "reason": "需要的三个核心字段全部存在"})
+            total_score += 10
+        else:
+            score_details.append({"item": "检查是否包含全部必填字段", "score": 0, "max_score": 10, "passed": False, "reason": f"缺失必要字段: {missing}"})
+            
+        # Check 4: No Extra Fields (10 points)
+        if not extra:
+            score_details.append({"item": "检查是否捏造多余字段防幻觉", "score": 10, "max_score": 10, "passed": True, "reason": "未发现多余字段，输出符合最简结构要求"})
+            total_score += 10
+        else:
+            score_details.append({"item": "检查是否捏造多余字段防幻觉", "score": 0, "max_score": 10, "passed": False, "reason": f"包含不被允许的额外字段: {extra}"})
+            
+        # Check 5: conflict_pkg accuracy (20 points)
+        conflict_pkg = data.get("conflict_pkg", "")
+        if isinstance(conflict_pkg, str) and (conflict_pkg.strip() == "boost-python-deps" or conflict_pkg.strip() == "boost_python_deps"):
+            score_details.append({"item": "准确提取导致崩溃的冲突包名", "score": 20, "max_score": 20, "passed": True, "reason": f"正确识别引发崩溃的 Python 依赖库: {conflict_pkg}"})
+            total_score += 20
+        else:
+            score_details.append({"item": "准确提取导致崩溃的冲突包名", "score": 0, "max_score": 20, "passed": False, "reason": f"识别的冲突包错误或类型异常: {conflict_pkg}"})
+            
+        # Check 6: bad_version accuracy (20 points)
+        bad_version = data.get("bad_version", "")
+        if isinstance(bad_version, str) and bad_version.strip() == "1.81.0":
+            score_details.append({"item": "精确提取错误注入的库高版本号", "score": 20, "max_score": 20, "passed": True, "reason": "完美匹配错误的高版本 1.81.0"})
+            total_score += 20
+        else:
+            score_details.append({"item": "精确提取错误注入的库高版本号", "score": 0, "max_score": 20, "passed": False, "reason": f"版本号抽取错误: {bad_version}"})
+            
+        # Check 7: system_version accuracy (20 points)
+        system_version = data.get("system_version", "")
+        if isinstance(system_version, str) and system_version.strip() == "1.74.0":
+            score_details.append({"item": "精确探测系统底层所需底座版本号", "score": 20, "max_score": 20, "passed": True, "reason": "成功反查到系统真实预期的 C++ 底座版本 1.74.0"})
+            total_score += 20
+        else:
+            score_details.append({"item": "精确探测系统底层所需底座版本号", "score": 0, "max_score": 20, "passed": False, "reason": f"提取系统底座版本号错误: {system_version}"})
+    else:
+        # Fallback for failing condition 3-7 when dict parsing fails
+        score_details.append({"item": "检查是否包含全部必填字段", "score": 0, "max_score": 10, "passed": False, "reason": "非有效 JSON 字典"})
+        score_details.append({"item": "检查是否捏造多余字段防幻觉", "score": 0, "max_score": 10, "passed": False, "reason": "非有效 JSON 字典"})
+        score_details.append({"item": "准确提取导致崩溃的冲突包名", "score": 0, "max_score": 20, "passed": False, "reason": "无法读取字段"})
+        score_details.append({"item": "精确提取错误注入的库高版本号", "score": 0, "max_score": 20, "passed": False, "reason": "无法读取字段"})
+        score_details.append({"item": "精确探测系统底层所需底座版本号", "score": 0, "max_score": 20, "passed": False, "reason": "无法读取字段"})
+        
+    result = {
+        "total_score": total_score,
+        "details": score_details
+    }
+    
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=4, ensure_ascii=False)
+
+if __name__ == "__main__":
+    main()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0025/verify_workplace.py

@@ -0,0 +1,129 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    target_file = os.path.join(workspace, "risk_control", "blacklist.json")
+    
+    score = 0
+    details = []
+    
+    # 1. 检查目标目录及文件是否存在 (10 分)
+    if os.path.exists(target_file):
+        score += 10
+        details.append({"item": "检查目标文件是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "risk_control/blacklist.json 存在"})
+    else:
+        details.append({"item": "检查目标文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "未找到 risk_control/blacklist.json"})
+        with open("workplace_score.json", "w", encoding="utf-8") as f:
+            json.dump({"total_score": score, "details": details}, f, ensure_ascii=False, indent=2)
+        return
+
+    # 2. 检查 JSON 格式合法性 (15 分)
+    try:
+        with open(target_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        score += 15
+        details.append({"item": "检查 JSON 格式合法性", "score": 15, "max_score": 15, "passed": True, "reason": "成功解析为合法 JSON 格式"})
+    except Exception as e:
+        details.append({"item": "检查 JSON 格式合法性", "score": 0, "max_score": 15, "passed": False, "reason": f"JSON 解析失败: {e}"})
+        with open("workplace_score.json", "w", encoding="utf-8") as f:
+            json.dump({"total_score": score, "details": details}, f, ensure_ascii=False, indent=2)
+        return
+
+    # 确保根节点是字典
+    if not isinstance(data, dict):
+        details.append({"item": "检查 JSON 根节点类型", "score": 0, "max_score": 75, "passed": False, "reason": "JSON 根节点必须是对象(字典)"})
+        with open("workplace_score.json", "w", encoding="utf-8") as f:
+            json.dump({"total_score": score, "details": details}, f, ensure_ascii=False, indent=2)
+        return
+        
+    # 定位并验证键名 (大小写不敏感，但必须是正确的 FIX 字段)
+    clordid_key = None
+    sender_key = None
+    for k in data.keys():
+        kl = k.lower()
+        if kl == "clordid":
+            clordid_key = k
+        elif kl == "sendercompid":
+            sender_key = k
+
+    # 3. 验证 ClOrdID 键 (10 分)
+    if clordid_key:
+        score += 10
+        details.append({"item": "验证 ClOrdID 键是否存在", "score": 10, "max_score": 10, "passed": True, "reason": f"找到规范键名: {clordid_key}"})
+    else:
+        details.append({"item": "验证 ClOrdID 键是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "未找到符合 ClOrdID 的键名"})
+
+    # 4. 验证 SenderCompID 键 (10 分)
+    if sender_key:
+        score += 10
+        details.append({"item": "验证 SenderCompID 键是否存在", "score": 10, "max_score": 10, "passed": True, "reason": f"找到规范键名: {sender_key}"})
+    else:
+        details.append({"item": "验证 SenderCompID 键是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "未找到符合 SenderCompID 的键名"})
+
+    # 5. 结构与幻觉检查 (10 分)
+    if len(data.keys()) == 2 and clordid_key and sender_key:
+        score += 10
+        details.append({"item": "验证是否无多余字段 (防幻觉)", "score": 10, "max_score": 10, "passed": True, "reason": "字段数量严格为 2，未捏造多余信息"})
+    else:
+        details.append({"item": "验证是否无多余字段 (防幻觉)", "score": 0, "max_score": 10, "passed": False, "reason": f"存在多余字段或结构错误，当前包含的键: {list(data.keys())}"})
+
+    # 6. 验证 ClOrdID 数值准确性 (20 分)
+    if clordid_key:
+        val = str(data[clordid_key]).strip()
+        if val == "POISON_HFT_0x9A":
+            score += 20
+            details.append({"item": "验证 ClOrdID 提取准确性", "score": 20, "max_score": 20, "passed": True, "reason": "ClOrdID 提取准确无误"})
+        else:
+            details.append({"item": "验证 ClOrdID 提取准确性", "score": 0, "max_score": 20, "passed": False, "reason": f"目标数据提取错误，当前值: {val}"})
+    else:
+        details.append({"item": "验证 ClOrdID 提取准确性", "score": 0, "max_score": 20, "passed": False, "reason": "因缺少对应键名而跳过判定"})
+
+    # 7. 验证 SenderCompID 数值准确性 (25 分)
+    if sender_key:
+        val = str(data[sender_key]).strip()
+        if val == "MALICIOUS_VIP_88":
+            score += 25
+            details.append({"item": "验证 SenderCompID 提取准确性", "score": 25, "max_score": 25, "passed": True, "reason": "SenderCompID 提取准确无误"})
+        else:
+            details.append({"item": "验证 SenderCompID 提取准确性", "score": 0, "max_score": 25, "passed": False, "reason": f"目标数据提取错误，当前值: {val}"})
+    else:
+        details.append({"item": "验证 SenderCompID 提取准确性", "score": 0, "max_score": 25, "passed": False, "reason": "因缺少对应键名而跳过判定"})
+
+    # 输出最终成绩报告
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump({"total_score": score, "details": details}, f, ensure_ascii=False, indent=2)
+
+if __name__ == "__main__":
+    main()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0026/verify_workplace.py

@@ -0,0 +1,170 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+# ==========================================
+# 强制 API 规范：大模型初始化
+# ==========================================
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    """
+    此函数为检测非结构化文本的统一接口。
+    针对 data_persona_aligned_base_50_0026 任务由于要求生成纯 JSON 结果，代码可以直接完成确定性验证，
+    本函数作为规范预留，在有任何自然语言生成时调用。
+    """
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    results = []
+    total_score = 0
+
+    # 1. 动态计算 Ground Truth (由于 env_builder 中数据和 hex 值是随机生成的)
+    ground_truth = None
+    traces_dir = os.path.join(workspace, "traces")
+    if os.path.isdir(traces_dir):
+        for file_name in os.listdir(traces_dir):
+            if not file_name.endswith(".json"):
+                continue
+            file_path = os.path.join(traces_dir, file_name)
+            try:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    for trace in data.get("data", []):
+                        spans = trace.get("spans", [])
+                        is_target = False
+                        
+                        # 找到持续时间 > 5s (5,000,000 微秒) 的目标 Trace
+                        for span in spans:
+                            if span.get("duration", 0) > 5000000:
+                                is_target = True
+                                break
+                        
+                        if is_target:
+                            trace_id = trace.get("traceID")
+                            operation = None
+                            payload = None
+                            # 深度遍历锁定底层报错 Span
+                            for span in spans:
+                                if span.get("operationName") == "grpc.inventory.ReserveStock":
+                                    operation = span.get("operationName")
+                                    for log in span.get("logs", []):
+                                        for field in log.get("fields", []):
+                                            if field.get("key") == "corrupted_payload":
+                                                payload = field.get("value")
+                            
+                            if trace_id and operation and payload:
+                                ground_truth = {
+                                    "trace_id": trace_id,
+                                    "operation": operation,
+                                    "payload": payload
+                                }
+                                break
+            except Exception:
+                pass
+            
+            if ground_truth:
+                break
+
+    if not ground_truth:
+        results.append({"item": "沙盒异常监控", "score": 0, "max_score": 0, "passed": False, "reason": "无法计算 Ground Truth，Trace 原始文件可能遭到破坏或未生成。"})
+        with open(os.path.join(workspace, "workplace_score.json"), "w", encoding='utf-8') as f:
+            json.dump({"total_score": 0, "details": results}, f, indent=2, ensure_ascii=False)
+        return
+
+    # 2. 检查结果文件是否存在 (权重: 20分)
+    target_file = os.path.join(workspace, "ops", "root_cause.json")
+    if not os.path.exists(target_file):
+        results.append({"item": "检查目标文件是否存在", "score": 0, "max_score": 20, "passed": False, "reason": "文件 ops/root_cause.json 不存在"})
+        with open(os.path.join(workspace, "workplace_score.json"), "w", encoding='utf-8') as f:
+            json.dump({"total_score": 0, "details": results}, f, indent=2, ensure_ascii=False)
+        return
+
+    results.append({"item": "检查目标文件是否存在", "score": 20, "max_score": 20, "passed": True, "reason": "文件 ops/root_cause.json 存在"})
+    total_score += 20
+
+    # 3. 检查文件是否为合法 JSON 且结构正常 (权重: 20分)
+    try:
+        with open(target_file, 'r', encoding='utf-8') as f:
+            ans_data = json.load(f)
+        results.append({"item": "检查文件是否为合法 JSON 解析", "score": 20, "max_score": 20, "passed": True, "reason": "标准 JSON 格式合法"})
+        total_score += 20
+    except json.JSONDecodeError:
+        results.append({"item": "检查文件是否为合法 JSON 解析", "score": 0, "max_score": 20, "passed": False, "reason": "无法被原生 json.load 解析"})
+        with open(os.path.join(workspace, "workplace_score.json"), "w", encoding='utf-8') as f:
+            json.dump({"total_score": total_score, "details": results}, f, indent=2, ensure_ascii=False)
+        return
+    except Exception as e:
+        results.append({"item": "检查文件是否为合法 JSON 解析", "score": 0, "max_score": 20, "passed": False, "reason": f"文件读取发生未知错误: {str(e)}"})
+        with open(os.path.join(workspace, "workplace_score.json"), "w", encoding='utf-8') as f:
+            json.dump({"total_score": total_score, "details": results}, f, indent=2, ensure_ascii=False)
+        return
+
+    # 4. 提取核心指标：严格比对 (每项 20 分，共 60 分)
+    
+    # 4.1 Trace ID 校验
+    agent_trace_id = ans_data.get("trace_id")
+    if agent_trace_id == ground_truth["trace_id"]:
+        results.append({"item": "检查 Trace ID 提取是否正确", "score": 20, "max_score": 20, "passed": True, "reason": "Trace ID 精准匹配"})
+        total_score += 20
+    else:
+        results.append({"item": "检查 Trace ID 提取是否正确", "score": 0, "max_score": 20, "passed": False, "reason": f"匹配失败, 期待 {ground_truth['trace_id']}, 实际得到 {agent_trace_id}"})
+
+    # 4.2 底层 Operation 校验
+    agent_operation = ans_data.get("operation")
+    if agent_operation == ground_truth["operation"]:
+        results.append({"item": "检查底层报错 Operation 提取是否正确", "score": 20, "max_score": 20, "passed": True, "reason": "Operation 提取正确"})
+        total_score += 20
+    else:
+        results.append({"item": "检查底层报错 Operation 提取是否正确", "score": 0, "max_score": 20, "passed": False, "reason": f"匹配失败, 实际得到 {agent_operation}"})
+
+    # 4.3 Corrupted Payload 内存地址校验
+    agent_payload = ans_data.get("payload")
+    if agent_payload == ground_truth["payload"]:
+        results.append({"item": "检查 Corrupted Payload 提取是否正确", "score": 20, "max_score": 20, "passed": True, "reason": "Payload 提取正确"})
+        total_score += 20
+    else:
+        results.append({"item": "检查 Corrupted Payload 提取是否正确", "score": 0, "max_score": 20, "passed": False, "reason": f"匹配失败, 实际得到 {agent_payload}"})
+
+    # 5. 扣分项：极其严格地验证废话与多余字段 (题目要求："其他废话和分析过程一句都别留")
+    allowed_keys = {"trace_id", "operation", "payload"}
+    actual_keys = set(ans_data.keys())
+    extra_keys = actual_keys - allowed_keys
+    if extra_keys:
+        deduct = 20
+        total_score = max(0, total_score - deduct)
+        results.append({"item": "多余废话字段检测", "score": -deduct, "max_score": 0, "passed": False, "reason": f"存在不允许的额外字段: {extra_keys}，违背强制不罗嗦指令，扣除 {deduct} 分"})
+    else:
+        results.append({"item": "多余废话字段检测", "score": 0, "max_score": 0, "passed": True, "reason": "未包含多余字段，严格遵守了输出格式指令"})
+
+    # 最终输出 workplace_score.json
+    with open(os.path.join(workspace, "workplace_score.json"), "w", encoding='utf-8') as f:
+        json.dump({"total_score": total_score, "details": results}, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0027/verify_workplace.py

@@ -0,0 +1,193 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，强制关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    target_path = os.path.join(workspace, "recovery", "target.json")
+    
+    total_score = 0
+    details = []
+    
+    # 1. 结构与文件存在性检查 (10分)
+    if os.path.exists(target_path):
+        details.append({
+            "item": "检查目标文件是否存在", 
+            "score": 10, 
+            "max_score": 10, 
+            "passed": True, 
+            "reason": "文件 recovery/target.json 存在"
+        })
+        total_score += 10
+        
+        # 2. 纯代码 JSON 结构解析 (20分)
+        try:
+            with open(target_path, "r", encoding="utf-8") as f:
+                raw_content = f.read()
+            
+            # 清理可能的 Markdown 代码块标记以增强健壮性
+            clean_content = raw_content.strip()
+            if clean_content.startswith("
+```
+
+```python
+if lines and lines[-1].startswith("```"): lines = lines[:-1]
+clean_content = "\n".join(lines).strip()
+                
+            data = json.loads(clean_content)
+            
+            has_rank = "rank_id" in data
+            has_coord = "coordinates" in data
+            
+            if has_rank and has_coord:
+                details.append({
+                    "item": "JSON结构合法性", 
+                    "score": 20, 
+                    "max_score": 20, 
+                    "passed": True, 
+                    "reason": "格式合法且正确包含了 rank_id 和 coordinates 必需字段"
+                })
+                total_score += 20
+                
+                # 3. 精准校验 rank_id 准确性 (30分)
+                if data.get("rank_id") == 1495:
+                    details.append({
+                        "item": "精准验证 rank_id", 
+                        "score": 30, 
+                        "max_score": 30, 
+                        "passed": True, 
+                        "reason": "识别到了正确的崩溃 Rank ID (1495)"
+                    })
+                    total_score += 30
+                else:
+                    details.append({
+                        "item": "精准验证 rank_id", 
+                        "score": 0, 
+                        "max_score": 30, 
+                        "passed": False, 
+                        "reason": f"Rank ID 提取错误，得到 {data.get('rank_id')}，预期为 1495"
+                    })
+                
+                # 4. 精准校验 coordinates (30分)
+                expected_coords = [24, 39, 180, 720]
+                if data.get("coordinates") == expected_coords:
+                    details.append({
+                        "item": "精准验证 coordinates", 
+                        "score": 30, 
+                        "max_score": 30, 
+                        "passed": True, 
+                        "reason": "准确提取出了溢出变量的多维坐标矩阵"
+                    })
+                    total_score += 30
+                else:
+                    details.append({
+                        "item": "精准验证 coordinates", 
+                        "score": 0, 
+                        "max_score": 30, 
+                        "passed": False, 
+                        "reason": f"溢出坐标提取错误，得到 {data.get('coordinates')}，预期为 {expected_coords}"
+                    })
+                    
+            else:
+                details.append({
+                    "item": "JSON结构合法性", 
+                    "score": 0, 
+                    "max_score": 20, 
+                    "passed": False, 
+                    "reason": "JSON解析成功，但缺失关键字典键 rank_id 或 coordinates"
+                })
+                details.append({"item": "精准验证 rank_id", "score": 0, "max_score": 30, "passed": False, "reason": "缺失对应字段"})
+                details.append({"item": "精准验证 coordinates", "score": 0, "max_score": 30, "passed": False, "reason": "缺失对应字段"})
+                
+        except json.JSONDecodeError as e:
+            details.append({"item": "JSON结构合法性", "score": 0, "max_score": 20, "passed": False, "reason": f"JSON解析致命失败，结构异常: {e}"})
+            details.append({"item": "精准验证 rank_id", "score": 0, "max_score": 30, "passed": False, "reason": "前置校验失败"})
+            details.append({"item": "精准验证 coordinates", "score": 0, "max_score": 30, "passed": False, "reason": "前置校验失败"})
+    else:
+        details.append({"item": "检查目标文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "完全未找到目标文件 recovery/target.json"})
+        details.append({"item": "JSON结构合法性", "score": 0, "max_score": 20, "passed": False, "reason": "文件缺失"})
+        details.append({"item": "精准验证 rank_id", "score": 0, "max_score": 30, "passed": False, "reason": "文件缺失"})
+        details.append({"item": "精准验证 coordinates", "score": 0, "max_score": 30, "passed": False, "reason": "文件缺失"})
+
+    # 5. LLM 检测行为服从度 —— 极简主义检查 (10分)
+    # 根据提示词，客户严重厌恶“一二三四的分析和废话安慰”
+    recovery_dir = os.path.join(workspace, "recovery")
+    all_files_content = ""
+    if os.path.exists(recovery_dir):
+        for f_name in os.listdir(recovery_dir):
+            file_p = os.path.join(recovery_dir, f_name)
+            if os.path.isfile(file_p):
+                try:
+                    with open(file_p, "r", encoding="utf-8") as rf:
+                        all_files_content += f"\n--- {f_name} ---\n{rf.read()[:1500]}"
+                except:
+                    pass
+
+    if all_files_content.strip():
+        llm_prompt = (
+            "检查以下系统恢复目录的内容提取。任务背景中，暴躁的超算工程师强调："
+            "【别跟我写什么一二三四的分析步骤，也别用教科书式的废话安慰我，我只要准确的 ID 和坐标！】"
+            "判断该内容中是否严格遵守了这一原则。如果该内容中包含解释性语句、大段闲聊、多余的分析或Markdown文字废话，请输出 NO。"
+            "如果内容里完全是纯净的格式化数据（比如只有干瘪干净的JSON数据），无半句废话，请输出 YES。"
+        )
+        passed_llm = llm_judge_content(llm_prompt, all_files_content)
+        if passed_llm:
+            details.append({
+                "item": "大模型语义判别：废话排查", 
+                "score": 10, 
+                "max_score": 10, 
+                "passed": True, 
+                "reason": "大模型判定输出目录干净清爽，没有任何教科书式的废话，高度符合工程师 Persona 要求"
+            })
+            total_score += 10
+        else:
+            details.append({
+                "item": "大模型语义判别：废话排查", 
+                "score": 0, 
+                "max_score": 10, 
+                "passed": False, 
+                "reason": "大模型判定内容包含了冗余的分析过程、说明文或闲聊语句，违背了业务紧急场景的指令"
+            })
+    else:
+        details.append({"item": "大模型语义判别：废话排查", "score": 0, "max_score": 10, "passed": False, "reason": "没有任何文件内容可供大模型评估"})
+
+    # 统一输出标准评测结果文件
+    result_output = {
+        "total_score": total_score,
+        "details": details
+    }
+    
+    with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+        json.dump(result_output, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0028/verify_workplace.py

@@ -0,0 +1,136 @@
+import os
+import sys
+import json
+import httpx
+import re
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    target_file = os.path.join(workspace, "ops_action", "kill_list.json")
+    
+    total_score = 0
+    details = []
+
+    # 1. 检查目录和文件是否存在 (10分)
+    file_exists = os.path.exists(target_file)
+    if file_exists:
+        total_score += 10
+        details.append({"item": "检查目标文件是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "文件 ops_action/kill_list.json 存在"})
+    else:
+        details.append({"item": "检查目标文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "文件 ops_action/kill_list.json 不存在"})
+        with open("workplace_score.json", "w", encoding="utf-8") as f:
+            json.dump({"total_score": total_score, "details": details}, f, indent=4, ensure_ascii=False)
+        return
+
+    # 2. 读取并解析JSON格式 (10分)
+    try:
+        with open(target_file, "r", encoding="utf-8") as f:
+            content = f.read()
+    except Exception as e:
+        details.append({"item": "文件是否可读", "score": 0, "max_score": 0, "passed": False, "reason": f"读取失败: {e}"})
+        with open("workplace_score.json", "w", encoding="utf-8") as f:
+            json.dump({"total_score": total_score, "details": details}, f, indent=4, ensure_ascii=False)
+        return
+
+    parsed_list = None
+    try:
+        parsed_list = json.loads(content)
+    except json.JSONDecodeError:
+        # 尝试剥离可能的 markdown 代码块再解析
+        match = re.search(r"
+```
+
+```python
+if match:
+try:
+                parsed_list = json.loads(match.group(1))
+            except:
+                pass
+
+    if isinstance(parsed_list, list):
+        total_score += 10
+        details.append({"item": "格式合法性", "score": 10, "max_score": 10, "passed": True, "reason": "成功通过代码精确解析出 JSON 数组"})
+    else:
+        details.append({"item": "格式合法性", "score": 0, "max_score": 10, "passed": False, "reason": "文件内容不是合法的 JSON 数组，解析失败"})
+        parsed_list = [] # 初始化空数组防止后续逻辑崩溃
+
+    # 3. 检查是否准确找到僵尸机1 (20分)
+    if "i-0abcd1234efgh5678" in parsed_list:
+        total_score += 20
+        details.append({"item": "命中僵尸实例 1", "score": 20, "max_score": 20, "passed": True, "reason": "成功找出无 CostCenter 标签且无活跃日志的 GPU 实例 i-0abcd1234efgh5678"})
+    else:
+        details.append({"item": "命中僵尸实例 1", "score": 0, "max_score": 20, "passed": False, "reason": "遗漏了真实的闲置僵尸实例 i-0abcd1234efgh5678"})
+
+    # 4. 检查是否准确找到僵尸机2 (20分)
+    if "i-01112223334445556" in parsed_list:
+        total_score += 20
+        details.append({"item": "命中僵尸实例 2", "score": 20, "max_score": 20, "passed": True, "reason": "成功找出无 CostCenter 标签且无活跃日志的 GPU 实例 i-01112223334445556"})
+    else:
+        details.append({"item": "命中僵尸实例 2", "score": 0, "max_score": 20, "passed": False, "reason": "遗漏了真实的闲置僵尸实例 i-01112223334445556"})
+
+    # 5. 检查是否误杀正在运行业务的活跃机器 (20分)
+    if "i-0deadbeefdeadbeef" not in parsed_list:
+        total_score += 20
+        details.append({"item": "排除活跃实例", "score": 20, "max_score": 20, "passed": True, "reason": "成功排除了 CloudTrail 中有 SubmitTrainingJob 等业务级操作的活跃机器 i-0deadbeefdeadbeef"})
+    else:
+        details.append({"item": "排除活跃实例", "score": 0, "max_score": 20, "passed": False, "reason": "致命错误！误杀了在日志中有模型训练和更新等活跃业务的实例 i-0deadbeefdeadbeef"})
+
+    # 6. 检查是否有误杀正常机器或捏造不存在的 ID (10分)
+    false_positives = [
+        "i-0987654321fedcba0", # t3.micro (非 GPU)
+        "i-0aaabbbcccdddeee1", # p4d (有 CostCenter 标签)
+        "i-02222222222222222"  # g4dn (已停止，状态不符合)
+    ]
+    
+    found_fp = [i for i in parsed_list if i in false_positives]
+    hallucinated = [i for i in parsed_list if i not in false_positives and i not in ["i-0abcd1234efgh5678", "i-01112223334445556", "i-0deadbeefdeadbeef"]]
+    
+    if len(found_fp) == 0 and len(hallucinated) == 0:
+        total_score += 10
+        details.append({"item": "排除干扰项与零幻觉验证", "score": 10, "max_score": 10, "passed": True, "reason": "未包含任何不符合条件的机器，也未捏造虚假的实例 ID"})
+    else:
+        details.append({"item": "排除干扰项与零幻觉验证", "score": 0, "max_score": 10, "passed": False, "reason": f"名单中包含了错误的干扰机器或幻觉捏造的数据: {found_fp + hallucinated}"})
+
+    # 7. LLM 语义检测：检查是否严格遵守“不要长篇大论”的无废话原则 (10分)
+    prompt_text = "Does the following file content consist strictly and ONLY of a JSON data structure (e.g., an array of strings), without ANY human-like conversational text, greetings, apologies, or long analytical explanations? Answer 'YES' if it is perfectly pure data. Answer 'NO' if it contains conversational text like 'Here is the list of zombie instances', 'I found these', etc."
+    is_pure = llm_judge_content(prompt_text, content)
+    if is_pure:
+        total_score += 10
+        details.append({"item": "大模型内容纯净度验证", "score": 10, "max_score": 10, "passed": True, "reason": "文件内容纯净，无冗余对话，符合脚本自动化挂载的需求"})
+    else:
+        details.append({"item": "大模型内容纯净度验证", "score": 0, "max_score": 10, "passed": False, "reason": "大模型判定文件中包含了冗余的交互对话或分析报告，违反了纯粹输出的要求"})
+
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump({"total_score": total_score, "details": details}, f, indent=4, ensure_ascii=False)
+
+if __name__ == "__main__":
+    main()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0029/verify_workplace.py

@@ -0,0 +1,172 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    total_score = 0
+    details = []
+
+    target_file = os.path.join(workspace, "action_items", "kill_list.json")
+
+    # 1. 检查目标文件是否存在 (10 分)
+    if os.path.exists(target_file):
+        details.append({
+            "item": "检查结果文件是否存在",
+            "score": 10,
+            "max_score": 10,
+            "passed": True,
+            "reason": "目标文件 action_items/kill_list.json 已创建"
+        })
+        total_score += 10
+    else:
+        details.append({
+            "item": "检查结果文件是否存在",
+            "score": 0,
+            "max_score": 10,
+            "passed": False,
+            "reason": "目标文件 action_items/kill_list.json 未找到"
+        })
+        # 文件不存在直接输出结果
+        with open("workplace_score.json", "w", encoding="utf-8") as f:
+            json.dump({"total_score": total_score, "details": details}, f, ensure_ascii=False, indent=2)
+        return
+
+    # 2. 检查 JSON 格式合法性与 Schema (20 分)
+    # 利用原生的 json.load 严查 Markdown 包裹、废话及格式错误
+    data = None
+    try:
+        with open(target_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            
+        if isinstance(data, dict) and "idle_ebs" in data and "zombie_gpu" in data:
+            if isinstance(data["idle_ebs"], list) and isinstance(data["zombie_gpu"], list):
+                details.append({
+                    "item": "检查 JSON 格式与 Schema 合法性",
+                    "score": 20,
+                    "max_score": 20,
+                    "passed": True,
+                    "reason": "JSON 文件可以被原生解析器成功加载，没有包含多余的废话和 Markdown 代码块，且 Schema 正确"
+                })
+                total_score += 20
+            else:
+                details.append({
+                    "item": "检查 JSON 格式与 Schema 合法性",
+                    "score": 0,
+                    "max_score": 20,
+                    "passed": False,
+                    "reason": "JSON 格式有效，但 idle_ebs 或 zombie_gpu 不是列表"
+                })
+                data = None
+        else:
+            details.append({
+                "item": "检查 JSON 格式与 Schema 合法性",
+                "score": 0,
+                "max_score": 20,
+                "passed": False,
+                "reason": "JSON 格式有效，但缺少要求的 idle_ebs 或 zombie_gpu 字段"
+            })
+            data = None
+    except json.JSONDecodeError as e:
+        details.append({
+            "item": "检查 JSON 格式与 Schema 合法性",
+            "score": 0,
+            "max_score": 20,
+            "passed": False,
+            "reason": f"JSON 解析失败（Agent 未遵循要求，可能包裹了 Markdown、包含了废话说明或语法错误）：{str(e)}"
+        })
+
+    # 如果无法解析，后续计分均跳过
+    if data:
+        # 定义期望的答案集
+        expected_ebs = {"vol-09a8b7c6d5e4f3a21", "vol-00001111222233334", "vol-0ffeeddccbbaa9988"}
+        # 定义一定存在于文件中但不应该被提取的干扰项（用于校验是否存在提取条件过滤错误）
+        invalid_ebs = {"vol-01122334455667788", "vol-0a1b2c3d4e5f60708"}
+        
+        expected_gpu = {"i-0987654321abcdef0", "i-55556666777788889", "i-deadbeefdeadbeef0", "i-9876543210fedcba9"}
+        invalid_gpu = {"i-11112222333344445", "i-99990000aaaaabbbb", "i-abcdef12345678900"}
+
+        actual_ebs_set = set(data.get("idle_ebs", []))
+        actual_gpu_set = set(data.get("zombie_gpu", []))
+
+        # 3. 检查 idle_ebs 提取准确度 (满分 35 分)
+        ebs_score = 0
+        ebs_reason = ""
+        
+        # 严查作弊与逻辑错误：一旦包���了不符合条件的数据或幻觉伪造数据，一票否决
+        if any(x in invalid_ebs for x in actual_ebs_set) or not actual_ebs_set.issubset(expected_ebs | invalid_ebs):
+            ebs_reason = "在 idle_ebs 结果中混入了 in-use 的 EBS 或无中生有的幻觉 ID，触发强杀脚本报警规则，该项得分清零。"
+        else:
+            if "vol-09a8b7c6d5e4f3a21" in actual_ebs_set: ebs_score += 10
+            if "vol-00001111222233334" in actual_ebs_set: ebs_score += 10
+            if "vol-0ffeeddccbbaa9988" in actual_ebs_set: ebs_score += 15 # 提取单引号伪 JSON 数据的难度稍高
+            ebs_reason = f"成功提取了 {len(actual_ebs_set)} 个符合要求的可用 EBS 卷。"
+
+        details.append({
+            "item": "检查 idle_ebs 数据准确性",
+            "score": ebs_score,
+            "max_score": 35,
+            "passed": ebs_score == 35,
+            "reason": ebs_reason
+        })
+        total_score += ebs_score
+
+        # 4. 检查 zombie_gpu 提取准确度 (满分 35 分)
+        gpu_score = 0
+        gpu_reason = ""
+
+        # 同样严查：如果提取出利用率大于2%的节点，或者把非GPU实例拿进来，一票否决
+        if any(x in invalid_gpu for x in actual_gpu_set) or not actual_gpu_set.issubset(expected_gpu | invalid_gpu):
+            gpu_reason = "在 zombie_gpu 中包含了利用率大于2%的实例、非 GPU 实例(如t3)或幻觉 ID，触发报警，该项得分清零。"
+        else:
+            if "i-0987654321abcdef0" in actual_gpu_set: gpu_score += 8
+            if "i-55556666777788889" in actual_gpu_set: gpu_score += 9
+            if "i-deadbeefdeadbeef0" in actual_gpu_set: gpu_score += 9
+            if "i-9876543210fedcba9" in actual_gpu_set: gpu_score += 9
+            gpu_reason = f"成功提取了 {len(actual_gpu_set)} 个符合要求的僵尸 GPU 实例。"
+
+        details.append({
+            "item": "检查 zombie_gpu 数据准确性",
+            "score": gpu_score,
+            "max_score": 35,
+            "passed": gpu_score == 35,
+            "reason": gpu_reason
+        })
+        total_score += gpu_score
+
+    # 输出结果
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump({"total_score": total_score, "details": details}, f, ensure_ascii=False, indent=2)
+
+if __name__ == "__main__":
+    main()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0030/verify_workplace.py

@@ -0,0 +1,159 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+# ==========================================
+# 强制环境与 LLM 初始化规范
+# ==========================================
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    """大模型语义检测统一接口"""
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+# ==========================================
+# 辅助函数：深度遍历 JSON 数据
+# ==========================================
+def find_in_json(obj, target):
+    """在 JSON 反序列化后的结构中，纯代码方式确切查找键或值中是否包含目标字符串"""
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            if target in str(k) or find_in_json(v, target):
+                return True
+    elif isinstance(obj, list):
+        for item in obj:
+            if find_in_json(item, target):
+                return True
+    else:
+        if target in str(obj):
+            return True
+    return False
+
+# ==========================================
+# 核心验证逻辑
+# ==========================================
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    report_path = os.path.join(workspace, "dv_reports", "culprit_signal.json")
+    score_file = os.path.join(workspace, "workplace_score.json")
+    
+    total_score = 0
+    details = []
+    
+    def write_score_and_exit():
+        with open(score_file, "w", encoding="utf-8") as f:
+            json.Tape_out_reports = {"total_score": total_score, "details": details}
+            json.dump(json.Tape_out_reports, f, indent=2, ensure_ascii=False)
+        sys.exit(0)
+
+    # 【检测项 1】检查结果文件及其所在目录是否存在 (10分)
+    if os.path.exists(report_path):
+        details.append({"item": "检查目标文件 culprit_signal.json 是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "结果文件存在"})
+        total_score += 10
+    else:
+        details.append({"item": "检查目标文件 culprit_signal.json 是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "结果文件不存在"})
+        write_score_and_exit()
+        
+    # 【检测项 2】结构化文件格式强制验证 (10分)
+    with open(report_path, "r", encoding="utf-8") as f:
+        content = f.read().strip()
+        
+    try:
+        data = json.loads(content)
+        details.append({"item": "检查文件是否为合法规范的 JSON", "score": 10, "max_score": 10, "passed": True, "reason": "JSON 格式合法且可解析"})
+        total_score += 10
+    except json.JSONDecodeError:
+        details.append({"item": "检查文件是否为合法规范的 JSON", "score": 0, "max_score": 10, "passed": False, "reason": "并非合法的 JSON 格式，存在语法错误或包含混杂文本"})
+        write_score_and_exit()
+
+    # 【检测项 3】真实信号名的原生代码提取 (30分)
+    # 严格杜绝正则模糊匹配，直接从 dict 的层级数据结构中寻找信号数据
+    has_real_name = find_in_json(data, "axi_wdata")
+    has_raw_symbol = find_in_json(data, "$")
+    has_wrong_signal = find_in_json(data, "axi_wstrb")
+
+    score_3 = 0
+    reason_3 = ""
+    if has_real_name and not has_raw_symbol and not has_wrong_signal:
+        score_3 = 30
+        reason_3 = "成功定位真实信号名 axi_wdata，且剔除了 VCD 原始 ASCII 代号，没有包含其他干扰信号"
+    elif has_real_name and (has_raw_symbol or has_wrong_signal):
+        score_3 = 10
+        reason_3 = "包含了真实信号名，但未清洗干净（带入 VCD 代号 $ 或误抓取了干扰信号 axi_wstrb），视为不严谨"
+    else:
+        score_3 = 0
+        reason_3 = "在 JSON 数据结构中未找到引发异常的确切真实信号名 'axi_wdata'"
+        
+    details.append({"item": "利用原生解析器验证真实信号名的提取纯度", "score": score_3, "max_score": 30, "passed": score_3 == 30, "reason": reason_3})
+    total_score += score_3
+
+    # 【检测项 4】时钟周期与异常注入点的时间戳判定 (30分)
+    has_exact_time = find_in_json(data, "1424500")
+    has_fatal_time = find_in_json(data, "1425000")
+    has_z_time = find_in_json(data, "1385000")
+
+    score_4 = 0
+    reason_4 = ""
+    if has_exact_time and not has_fatal_time and not has_z_time:
+        score_4 = 30
+        reason_4 = "成功追溯并提取了确切的异常灌入时间点 1424500 ps，完美避开后续 Fatal 点与其他高阻态跳变点"
+    elif has_exact_time:
+        score_4 = 15
+        reason_4 = "找到了确切时间戳 1424500，但数据中存在 Fatal 时间等混淆项，未剔除干净"
+    elif has_fatal_time:
+        score_4 = 0
+        reason_4 = "严重误判：将 UVM_FATAL 的断言时刻 1425000 当成了引发问题的原始时间点"
+    elif has_z_time:
+        score_4 = 0
+        reason_4 = "被干扰波形误导：错误锁定了与此 Fatal 无关的高阻态跳变时间点 1385000"
+    else:
+        score_4 = 0
+        reason_4 = "在 JSON 数据中完全没有找到正确的异常时间戳"
+
+    details.append({"item": "验证波形逆推导致的源头异常时间戳", "score": score_4, "max_score": 30, "passed": score_4 == 30, "reason": reason_4})
+    total_score += score_4
+
+    # 【检测项 5】基于 LLM 的非结构化/语义职业素养检测 (20分)
+    # 场景剧本提示"铁证直接去敲主管的门"，意味着需要极其简练，纯粹的键值对，杜绝大段无意义解释
+    llm_prompt = (
+        "The user provided a JSON output to act as hard evidence for a critical chip tape-out error. "
+        "The instructions demanded a JSON output containing ONLY the culprit signal and its timestamp. "
+        "Does the provided JSON file text contain ONLY technical data (keys and numbers), WITHOUT any redundant "
+        "conversational text, verbose explanations, or excuses? "
+        "(Answer 'YES' if it is purely an extremely concise technical JSON, 'NO' if it contains conversational words or verbose string explanations)."
+    )
+    
+    is_concise = llm_judge_content(llm_prompt, content)
+    if is_concise:
+        details.append({"item": "大模型验证：报告是否足够干净利落，符合流片紧急事件的铁证要求", "score": 20, "max_score": 20, "passed": True, "reason": "大模型判定 JSON 极其精炼，只包含信号数据，没有多余的废话和推脱解释"})
+        total_score += 20
+    else:
+        details.append({"item": "大模型验证：报告是否足够干净利落，符合流片紧急事件的铁证要求", "score": 0, "max_score": 20, "passed": False, "reason": "大模型判定文件中包含了冗余的解释文本或推诿语句，不够专业与精炼"})
+
+    write_score_and_exit()
+
+if __name__ == "__main__":
+    main()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0031/verify_workplace.py

@@ -0,0 +1,138 @@
+import os
+import sys
+import json
+import re
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 强制关闭 SSL 验证并初始化客户端
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    """大模型语义检查接口，确保无废话和自然语言包装"""
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    config_dir = os.path.join(workspace, "config")
+    blacklist_file = os.path.join(config_dir, "blacklist.json")
+
+    score_details = []
+    total_score = 0
+
+    # 1. 检查目录 (10分)
+    if os.path.exists(config_dir) and os.path.isdir(config_dir):
+        score_details.append({"item": "检查 config 目录是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "目录 config 存在"})
+        total_score += 10
+    else:
+        score_details.append({"item": "检查 config 目录是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "目录 config 不存在"})
+
+    # 2. 检查文件 (10分)
+    if os.path.exists(blacklist_file) and os.path.isfile(blacklist_file):
+        score_details.append({"item": "检查 blacklist.json 是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "文件 blacklist.json 存在"})
+        total_score += 10
+        
+        with open(blacklist_file, "r", encoding="utf-8") as f:
+            content = f.read().strip()
+            
+        # 3. 解析与格式纯粹度 (20分)
+        parsed_data = None
+        is_pure_json = True
+        
+        try:
+            parsed_data = json.loads(content)
+        except json.JSONDecodeError:
+            # 尝试做梯度容错：去掉 Agent 可能会写错的 Markdown 包装
+            stripped = re.sub(r"^
+```
+
+```python
+try:
+parsed_data = json.loads(stripped)
+                is_pure_json = False # 触发容错说明格式不纯粹
+            except json.JSONDecodeError:
+                pass
+
+        if parsed_data is not None and isinstance(parsed_data, list):
+            if is_pure_json:
+                score_details.append({"item": "检查文件是否为纯粹合法的 JSON 数组", "score": 20, "max_score": 20, "passed": True, "reason": "文件是原生、无冗余的合法 JSON 列表结构"})
+                total_score += 20
+            else:
+                score_details.append({"item": "检查文件是否为纯粹合法的 JSON 数组", "score": 10, "max_score": 20, "passed": False, "reason": "内容需剥离 Markdown 代码块包装后才能解析为 JSON，格式不纯粹，扣除部分分数"})
+                total_score += 10
+        else:
+            score_details.append({"item": "检查文件是否为纯粹合法的 JSON 数组", "score": 0, "max_score": 20, "passed": False, "reason": "文件无法被解析为 JSON 数组（尝试容错后依然失败，或非列表结构）"})
+
+        # 4. 数据准确度与无幻觉测试 (50分)
+        expected_ips = {"120.44.55.66", "45.33.22.11", "10.0.5.200"}
+        if parsed_data is not None and isinstance(parsed_data, list):
+            extracted_ips = set(str(item).strip() for item in parsed_data)
+            missing_ips = expected_ips - extracted_ips
+            extra_ips = extracted_ips - expected_ips
+            
+            content_score = 50
+            passed_content = True
+            
+            if missing_ips:
+                content_score -= len(missing_ips) * 15
+                passed_content = False
+            if extra_ips:
+                # 严惩冗余幻觉（可能包含了正常包或 RateLimit包）
+                content_score -= len(extra_ips) * 15 
+                passed_content = False
+                
+            if content_score < 0:
+                content_score = 0
+                
+            reason_content = "精确提取出所有恶毒 IP，无幻觉、无冗余数据" if passed_content else f"提取数据有误。缺失: {missing_ips}, 冗余(幻觉): {extra_ips}"
+            score_details.append({"item": "检查提取的恶意源 IP 是否精准完整", "score": content_score, "max_score": 50, "passed": passed_content, "reason": reason_content})
+            total_score += content_score
+        else:
+            score_details.append({"item": "检查提取的恶意源 IP 是否精准完整", "score": 0, "max_score": 50, "passed": False, "reason": "因结构解析彻底失败，跳过内容比对环节"})
+
+        # 5. LLM 把控自然语言纯粹性 (10分)
+        if content:
+            prompt_text = "Does the following file content contain ONLY computer-readable code/JSON/data, completely FREE OF ANY natural language explanations, pleasantries (like 'Here is the result'), or conversational text? Answer YES if it is strictly pure data/code, NO if there is any conversational text."
+            is_pure_llm = llm_judge_content(prompt_text, content)
+            
+            if is_pure_llm and is_pure_json:
+                score_details.append({"item": "利用大模型检查文件自然语言污染", "score": 10, "max_score": 10, "passed": True, "reason": "大模型及原生代码双重判定文件无任何人类对话式废话或外部包装"})
+                total_score += 10
+            else:
+                score_details.append({"item": "利用大模型检查文件自然语言污染", "score": 0, "max_score": 10, "passed": False, "reason": "大模型判定文件中包含多余的自然语言解释或被前置步骤发现存在格式污染"})
+        else:
+            score_details.append({"item": "利用大模型检查文件自然语言污染", "score": 0, "max_score": 10, "passed": False, "reason": "文件内容为空"})
+
+    else:
+        score_details.append({"item": "检查 blacklist.json 是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "文件 blacklist.json 不存在"})
+        score_details.append({"item": "检查文件是否为纯粹合法的 JSON 数组", "score": 0, "max_score": 20, "passed": False, "reason": "文件不存在"})
+        score_details.append({"item": "检查提取的恶意源 IP 是否精准完整", "score": 0, "max_score": 50, "passed": False, "reason": "文件不存在"})
+        score_details.append({"item": "利用大模型检查文件自然语言污染", "score": 0, "max_score": 10, "passed": False, "reason": "文件不存在"})
+
+    # 输出标准评测记录
+    with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+        json.dump({"total_score": total_score, "details": score_details}, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    main()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0032/verify_workplace.py

@@ -0,0 +1,226 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def get_ground_truth(outcar_path):
+    steps_data = [] 
+    current_step = None
+    current_energy = None
+    current_max_force = 0.0
+    in_force_block = False
+    
+    with open(outcar_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            # 提取 ionic step 步数
+            if "Iteration" in line and "(" in line:
+                parts = line.split()
+                if len(parts) >= 2 and parts[0] == "Iteration":
+                    s_str = parts[1].split('(')[0]
+                    if s_str.isdigit():
+                        s = int(s_str)
+                        if current_step is not None and current_energy is not None:
+                            steps_data.append({
+                                'step': current_step,
+                                'energy': current_energy,
+                                'max_force': current_max_force
+                            })
+                        current_step = s
+                        current_energy = None
+                        current_max_force = 0.0
+                        in_force_block = False
+                    
+            # 提取 TOTEN 能量
+            if "free  energy   TOTEN" in line:
+                parts = line.split('=')
+                if len(parts) == 2:
+                    val_str = parts[1].replace('eV', '').strip()
+                    try:
+                        current_energy = float(val_str)
+                    except ValueError:
+                        pass
+                    
+            # 提取 受力
+            if "TOTAL-FORCE (eV/Angst)" in line:
+                in_force_block = True
+                continue
+            
+            if in_force_block:
+                if "---" in line:
+                    continue
+                elif "timing for ionic step" in line or "BRION:" in line:
+                    in_force_block = False
+                else:
+                    parts = line.split()
+                    if len(parts) == 6:
+                        try:
+                            fx, fy, fz = float(parts[3]), float(parts[4]), float(parts[5])
+                            max_f = max(abs(fx), abs(fy), abs(fz))
+                            if max_f > current_max_force:
+                                current_max_force = max_f
+                        except ValueError:
+                            pass
+    
+    # 扫尾
+    if current_step is not None and current_energy is not None:
+        steps_data.append({
+            'step': current_step,
+            'energy': current_energy,
+            'max_force': current_max_force
+        })
+        
+    # 计算滑动窗口 (5步)
+    trap_step = -1
+    for i in range(4, len(steps_data)):
+        window = steps_data[i-4:i+1]
+        energies = [x['energy'] for x in window]
+        diff = max(energies) - min(energies)
+        last_max_force = window[-1]['max_force']
+        
+        if diff < 0.05 and last_max_force > 0.05:
+            trap_step = window[-1]['step']
+            break
+            
+    if trap_step == -1:
+        return None, None
+        
+    energies_up_to_trap = [x['energy'] for x in steps_data if x['step'] <= trap_step]
+    return trap_step, energies_up_to_trap
+
+def evaluate(workspace):
+    total_score = 0
+    details = []
+
+    result_dir = os.path.join(workspace, "result")
+    json_path = os.path.join(result_dir, "trap_report.json")
+    outcar_path = os.path.join(workspace, "sim_data", "OUTCAR_fragment.log")
+
+    # [1] 检查文件存在及合法性 (20分)
+    file_exists = os.path.exists(json_path)
+    if not file_exists:
+        details.append({"item": "检查目标文件 trap_report.json 是否存在并合法", "score": 0, "max_score": 20, "passed": False, "reason": "文件不存在"})
+        return 0, details
+        
+    try:
+        with open(json_path, 'r', encoding='utf-8') as f:
+            agent_data = json.load(f)
+        total_score += 20
+        details.append({"item": "检查目标文件 trap_report.json 是否存在并合法", "score": 20, "max_score": 20, "passed": True, "reason": "文件存在且为合法JSON"})
+    except Exception as e:
+        details.append({"item": "检查目标文件 trap_report.json 是否存在并合法", "score": 0, "max_score": 20, "passed": False, "reason": f"文件解析为JSON失败: {e}"})
+        return total_score, details
+
+    # [2] JSON 键名合理性检测 (10分，大模型兜底)
+    keys_str = ", ".join(agent_data.keys()) if isinstance(agent_data, dict) else ""
+    prompt = (
+        "Are the following JSON keys intuitively clear to distinguish which key represents a single 'step number' "
+        "(e.g. trap_step, trapped_iteration, step, etc.) and which key represents a sequence/list of 'energies' "
+        "(e.g. energies, energy_list, sequence, etc.)? "
+        "Any reasonable names that separate a singular concept and a plural/list concept are perfectly acceptable. "
+        "Only answer 'NO' if they are extremely confusing, completely irrelevant, or identical."
+    )
+    is_keys_good = llm_judge_content(prompt, keys_str)
+    if is_keys_good:
+        total_score += 10
+        details.append({"item": "利用大模型检查JSON键名是否具有可读性", "score": 10, "max_score": 10, "passed": True, "reason": "键名清晰易懂"})
+    else:
+        details.append({"item": "利用大模型检查JSON键名是否具有可读性", "score": 0, "max_score": 10, "passed": False, "reason": f"键名难以辨别: {keys_str}"})
+
+    # [3] 从Agent的JSON提取核心内容 (5分)
+    agent_step = None
+    agent_energies = None
+    if isinstance(agent_data, dict):
+        for k, v in agent_data.items():
+            if isinstance(v, (int, float)):
+                agent_step = int(v)
+            elif isinstance(v, str) and v.isdigit():
+                agent_step = int(v)
+            elif isinstance(v, list) and all(isinstance(x, (int, float)) for x in v):
+                agent_energies = v
+
+    if agent_step is not None and agent_energies is not None:
+        total_score += 5
+        details.append({"item": "结构解析识别成功", "score": 5, "max_score": 5, "passed": True, "reason": "成功提取出步数标量和能量数组"})
+    else:
+        details.append({"item": "结构解析识别成功", "score": 0, "max_score": 5, "passed": False, "reason": "无法通过类型映射出核心字段"})
+        return total_score, details
+
+    # 获取 GT
+    gt_step, gt_energies = get_ground_truth(outcar_path)
+    if gt_step is None:
+        details.append({"item": "环境GT自检", "score": 0, "max_score": 0, "passed": False, "reason": "沙盒异常，未解析出预期卡死现象"})
+        return total_score, details
+
+    # [4] 对比卡死步数 (30分)
+    if agent_step == gt_step:
+        total_score += 30
+        details.append({"item": "陷阱节点(卡死步数)的精确匹配", "score": 30, "max_score": 30, "passed": True, "reason": f"成功匹配真实陷阱节点: {gt_step}"})
+    else:
+        details.append({"item": "陷阱节点(卡死步数)的精确匹配", "score": 0, "max_score": 30, "passed": False, "reason": f"Agent提取节点为 {agent_step}, 但正确答案应为 {gt_step}"})
+
+    # [5] 检查能量序列长度 (10分)
+    if len(agent_energies) == len(gt_energies):
+        total_score += 10
+        details.append({"item": "检查能量序列的长度是否匹配", "score": 10, "max_score": 10, "passed": True, "reason": f"序列长度完全一致 ({len(gt_energies)} 步)"})
+    else:
+        details.append({"item": "检查能量序列的长度是否匹配", "score": 0, "max_score": 10, "passed": False, "reason": f"长度不匹配，Agent包含 {len(agent_energies)} 步，应为 {len(gt_energies)} 步"})
+        # 长度不对后续全错直接返回
+        return total_score, details
+
+    # [6] 检查能量序列具体数值的正确性 (25分)
+    error_count = 0
+    for a, g in zip(agent_energies, gt_energies):
+        if abs(a - g) > 1e-4:
+            error_count += 1
+            
+    if error_count == 0:
+        total_score += 25
+        details.append({"item": "能量序列数值精确度校验", "score": 25, "max_score": 25, "passed": True, "reason": "所有能量数据提取均无误"})
+    else:
+        penalty = min(25, error_count * 5)
+        earned = 25 - penalty
+        total_score += earned
+        details.append({"item": "能量序列数值精确度校验", "score": earned, "max_score": 25, "passed": False, "reason": f"存在 {error_count} 处数值与源文件不符（允许绝对误差 1e-4），扣除 {penalty} 分"})
+
+    return total_score, details
+
+if __name__ == "__main__":
+    workspace_path = sys.argv[1] if len(sys.argv) > 1 else "."
+    final_score, report_details = evaluate(workspace_path)
+    
+    result_json = {
+        "total_score": final_score,
+        "details": report_details
+    }
+    
+    with open(os.path.join(workspace_path, "workplace_score.json"), 'w', encoding='utf-8') as f:
+        json.dump(result_json, f, ensure_ascii=False, indent=2)

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0033/verify_workplace.py

@@ -0,0 +1,174 @@
+import os
+import sys
+import json
+import math
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def extract_quaternions(json_obj):
+    """
+    通过结构遍历，严格从任意层级的嵌套 JSON 中提取出类似 [float, float, float, float] 的记录，
+    规避纯正则表达式可能引发的假阳性匹配。
+    """
+    extracted = []
+    
+    def traverse(obj):
+        if isinstance(obj, dict):
+            nums = [v for v in obj.values() if isinstance(v, (int, float))]
+            if len(nums) == 4:
+                # 优先尝试根据 w, x, y, z 键名提取
+                keys = list(obj.keys())
+                w_v = next((obj[k] for k in keys if 'w' in k.lower()), None)
+                x_v = next((obj[k] for k in keys if 'x' in k.lower()), None)
+                y_v = next((obj[k] for k in keys if 'y' in k.lower()), None)
+                z_v = next((obj[k] for k in keys if 'z' in k.lower()), None)
+                if all(v is not None for v in [w_v, x_v, y_v, z_v]):
+                    extracted.append((float(w_v), float(x_v), float(y_v), float(z_v)))
+                else:
+                    # 降级：按数值顺序提取
+                    extracted.append(tuple(float(n) for n in nums[:4]))
+            else:
+                for v in obj.values():
+                    traverse(v)
+        elif isinstance(obj, list):
+            # 检查当前列表是否恰好为一组四元数
+            nums = [x for x in obj if isinstance(x, (int, float))]
+            if len(nums) == 4 and len(obj) == 4:
+                extracted.append(tuple(float(n) for n in nums))
+            else:
+                for v in obj:
+                    traverse(v)
+
+    traverse(json_obj)
+    return extracted
+
+def match_quaternions(extracted, expected):
+    matched_flags = [False] * len(expected)
+    score = 0
+    for ex in extracted:
+        best_match_idx = -1
+        for i, exp in enumerate(expected):
+            if not matched_flags[i]:
+                # 允许极小的浮点数误差
+                if all(math.isclose(a, b, abs_tol=1e-3) for a, b in zip(ex, exp)):
+                    best_match_idx = i
+                    break
+        if best_match_idx != -1:
+            matched_flags[best_match_idx] = True
+            score += 10
+            
+    return score, matched_flags
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    target_file = os.path.join(workspace, "flight_dynamics", "quaternions.json")
+    
+    score_details = []
+    total_score = 0
+    
+    # 1. 物理探针：检查文件是否存在
+    if os.path.exists(target_file):
+        score_details.append({"item": "检查目标结果文件是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "文件 flight_dynamics/quaternions.json 存在"})
+        total_score += 10
+    else:
+        score_details.append({"item": "检查目标结果文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "文件 flight_dynamics/quaternions.json 不存在"})
+        result = {"total_score": 0, "details": score_details}
+        with open("workplace_score.json", "w") as f:
+            json.dump(result, f, indent=2, ensure_ascii=False)
+        return
+
+    # 2. 结构探针：检查 JSON 合法性
+    with open(target_file, "r") as f:
+        content = f.read()
+        
+    json_data = None
+    try:
+        json_data = json.loads(content)
+        score_details.append({"item": "验证 JSON 语法格式", "score": 10, "max_score": 10, "passed": True, "reason": "文件是合法的 JSON"})
+        total_score += 10
+    except Exception as e:
+        score_details.append({"item": "验证 JSON 语法格式", "score": 0, "max_score": 10, "passed": False, "reason": f"解析 JSON 失败: {e}"})
+
+    # 3. LLM 语义探针：判断 Key 命名是否具可读性
+    if json_data is not None:
+        prompt = "Does the following JSON content clearly express quaternion components using explicit keys like q_w, q_x, q_y, q_z, or have an extremely clear and unambiguous array structure for quaternions?"
+        is_clear = llm_judge_content(prompt, content)
+        if is_clear:
+            score_details.append({"item": "利用大模型检查数据字段表达是否清晰", "score": 10, "max_score": 10, "passed": True, "reason": "大模型判定 JSON 结构中包含清晰的四元数表达或键名"})
+            total_score += 10
+        else:
+            score_details.append({"item": "利用大模型检查数据字段表达是否清晰", "score": 0, "max_score": 10, "passed": False, "reason": "大模型认为数据字段不够直观或缺失相关标记"})
+    else:
+        score_details.append({"item": "利用大模型检查数据字段表达是否清晰", "score": 0, "max_score": 10, "passed": False, "reason": "JSON无法解析，跳过大模型检测"})
+
+    # 4 & 5. 核心计算探针：防幻觉与精度验证
+    expected_data = [
+        (0.9990, 0.0100, 0.0200, -0.0400),
+        (0.9950, 0.0250, 0.0350, -0.0890),
+        (0.9800, 0.0500, 0.0700, -0.1790),
+        (0.9500, 0.0900, 0.1200, -0.2700),
+        (0.9000, 0.1500, 0.1800, -0.3700)
+    ]
+    
+    if json_data is not None:
+        extracted = extract_quaternions(json_data)
+        if len(extracted) == 0:
+            score_details.append({"item": "防幻觉及数据完整性检测", "score": 0, "max_score": 20, "passed": False, "reason": "未能在 JSON 中找到四元数数据组"})
+            score_details.append({"item": "验证四元数数值提取精度", "score": 0, "max_score": 50, "passed": False, "reason": "无数据可校验"})
+        else:
+            acc_score, matched_flags = match_quaternions(extracted, expected_data)
+            
+            # 计算幻觉与遗漏扣分
+            extra_items = len(extracted) - sum(matched_flags) # 找到了但无法匹配上的伪造数据
+            missing_items = len(expected_data) - sum(matched_flags) # 漏找的数据
+            
+            penalty = min(extra_items * 5, 20)
+            hal_score = 20 - penalty - (missing_items * 4)
+            hal_score = max(0, hal_score)
+            
+            if hal_score == 20:
+                score_details.append({"item": "防幻觉及数据完整性检测", "score": 20, "max_score": 20, "passed": True, "reason": "精准提取了所有5组数据，且无任何冗余错漏数据"})
+                total_score += 20
+            else:
+                score_details.append({"item": "防幻觉及数据完整性检测", "score": hal_score, "max_score": 20, "passed": False, "reason": f"提取存在漏掉或冗余: 漏掉 {missing_items} 组，多出 {extra_items} 组无法对齐的数据"})
+                total_score += hal_score
+                
+            # 精度分
+            score_details.append({"item": "验证四元数数值提取精度", "score": acc_score, "max_score": 50, "passed": acc_score == 50, "reason": f"成功匹配 {sum(matched_flags)}/5 组四元数，每组 10 分"})
+            total_score += acc_score
+    else:
+        score_details.append({"item": "防幻觉及数据完整性检测", "score": 0, "max_score": 20, "passed": False, "reason": "无有效 JSON 供检查"})
+        score_details.append({"item": "验证四元数数值提取精度", "score": 0, "max_score": 50, "passed": False, "reason": "无有效 JSON 供检查"})
+
+    result = {"total_score": total_score, "details": score_details}
+    with open("workplace_score.json", "w") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    main()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0034/verify_workplace.py

@@ -0,0 +1,132 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+# 强制 API 规范：从环境变量读取配置，关闭 SSL 验证
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    """
+    统一的非结构化文本大模型验证接口。
+    用于验证 Agent 生成的结构化数据的键名是否符合自然语言描述的“清晰直观”。
+    """
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify_workplace(workspace):
+    score_details = []
+    total_score = 0
+    
+    file_path = os.path.join(workspace, "analysis", "culprit.json")
+    
+    # 1. 检查目标文件及其目录结构的存在性
+    exists = os.path.isfile(file_path)
+    if exists:
+        score_details.append({"item": "检查目标分析文件是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "文件 analysis/culprit.json 存在"})
+        total_score += 10
+    else:
+        score_details.append({"item": "检查目标分析文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "未找到 analysis/culprit.json，目录或文件未建立"})
+        
+    # 如果文件不存在，后续所有基于文件内容的验证均得0分
+    if not exists:
+        for item in ["JSON格式合法性验证", "防作弊与幻觉检查(字段数<=5)", "精确提取源码位置", "精确提取受害者符号名", "精确提取去优化核心原因", "LLM评估数据字段命名语义"]:
+            score_details.append({"item": item, "score": 0, "max_score": 15, "passed": False, "reason": "依赖的分析文件不存在"})
+        return score_details, total_score
+
+    # 2. 原生代码验证：JSON 格式绝对合法性
+    data = None
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        if isinstance(data, dict):
+            score_details.append({"item": "JSON格式合法性验证", "score": 15, "max_score": 15, "passed": True, "reason": "文件解析成功，且最外层为标准的 JSON Object (字典) 结构"})
+            total_score += 15
+        else:
+            score_details.append({"item": "JSON格式合法性验证", "score": 0, "max_score": 15, "passed": False, "reason": "最外层格式非 JSON Object (可能为 Array 或裸字串)"})
+            data = None
+    except Exception as e:
+        score_details.append({"item": "JSON格式合法性验证", "score": 0, "max_score": 15, "passed": False, "reason": f"结构化解析失败，不符合 JSON Schema：{str(e)}"})
+
+    if data is None:
+        for item in ["防作弊与幻觉检查(字段数<=5)", "精确提取源码位置", "精确提取受害者符号名", "精确提取去优化核心原因", "LLM评估数据字段命名语义"]:
+            score_details.append({"item": item, "score": 0, "max_score": 15, "passed": False, "reason": "非法的 JSON 数据导致无法检测值"})
+        return score_details, total_score
+        
+    # 3. 防作弊与幻觉检查 (严格限制 Agent 捏造冗余节点或全量 Dump)
+    if len(data.keys()) <= 5:
+        score_details.append({"item": "防作弊与幻觉检查(字段数<=5)", "score": 15, "max_score": 15, "passed": True, "reason": f"当前键值对数量为 {len(data.keys())}，符合针对性提取特征，未触发暴力 Dump 防御"})
+        total_score += 15
+    else:
+        score_details.append({"item": "防作弊与幻觉检查(字段数<=5)", "score": 0, "max_score": 15, "passed": False, "reason": f"当前键值对数量 {len(data.keys())} 超过阈值，疑似暴力写入全部信息而非特定提炼"})
+        
+    # 将所有的 Value 转化为字符串，去除非结构化空格，执行原生代码全等严密对比
+    values_str = [str(v).strip() for v in data.values()]
+    
+    # 4. 精确提取：源码物理位置
+    if any(v == "/app/src/core/hot_path_router.js" for v in values_str):
+        score_details.append({"item": "精确提取源码位置", "score": 15, "max_score": 15, "passed": True, "reason": "准确地映射出了反人类 JSON 下的 source_loc"})
+        total_score += 15
+    else:
+        score_details.append({"item": "精确提取源码位置", "score": 0, "max_score": 15, "passed": False, "reason": "未能精准提取到正确的文件路径 /app/src/core/hot_path_router.js，存在幻觉或混淆"})
+
+    # 5. 精确提取：函数符号名
+    if any(v == "processRequestFastPath" for v in values_str):
+        score_details.append({"item": "精确提取受害者符号名", "score": 15, "max_score": 15, "passed": True, "reason": "准确地锁定了触发 deoptimization 的热点函数名"})
+        total_score += 15
+    else:
+        score_details.append({"item": "精确提取受害者符号名", "score": 0, "max_score": 15, "passed": False, "reason": "未能精准提取到目标 symbol_name：processRequestFastPath"})
+
+    # 6. 精确提取：Bailout (去优化) 原因
+    if any(v == "wrong map" for v in values_str):
+        score_details.append({"item": "精确提取去优化核心原因", "score": 15, "max_score": 15, "passed": True, "reason": "成功从十六进制与噪音中提取了 bailout reason"})
+        total_score += 15
+    else:
+        score_details.append({"item": "精确提取去优化核心原因", "score": 0, "max_score": 15, "passed": False, "reason": "未能精准匹配原因 'wrong map'，或是带入了额外干扰文本"})
+        
+    # 7. LLM 非结构化检测：由于 Prompt 允许 Agent 自由决定字段名，故调用 LLM 查验字段命名是否直观清晰
+    keys_str = ", ".join(data.keys())
+    prompt_text = "The user dynamically generated JSON keys to identify the following three variables for an automated script: 'source code file path', 'function symbol name', and 'deoptimization bailout reason'. Are these provided key names intuitively descriptive, reasonable and free of random gibberish? Return YES if they make sense, or NO if they are vague or meaningless."
+    
+    llm_result = llm_judge_content(prompt_text, keys_str)
+    if llm_result:
+        score_details.append({"item": "LLM评估数据字段命名语义", "score": 15, "max_score": 15, "passed": True, "reason": f"Agent 创建的键名 [{keys_str}] 被判定为具备清晰语义，有利于下游自动化修复脚本接入"})
+        total_score += 15
+    else:
+        score_details.append({"item": "LLM评估数据字段命名语义", "score": 0, "max_score": 15, "passed": False, "reason": f"Agent 创建的键名 [{keys_str}] 缺乏合理描述性，下游脚本难以识别"})
+
+    return score_details, total_score
+
+if __name__ == "__main__":
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    details, score = verify_workplace(workspace)
+    
+    result = {
+        "total_score": score,
+        "details": details
+    }
+    
+    out_path = os.path.join(workspace, "workplace_score.json")
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0035/verify_workplace.py

@@ -0,0 +1,185 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    """大模型用于判断非结构化文本的语义或风格属性，严查啰嗦的分析报告"""
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def get_ground_truth(workspace):
+    """严格使用原生代码从沙盒生成的环境文件中提取事实真值，拒绝模糊匹配"""
+    gt_supernode_id = None
+    gt_leak_address = None
+    
+    # 提取 Supernode ID
+    try:
+        coordinator_dir = os.path.join(workspace, "coordinator")
+        if os.path.exists(coordinator_dir):
+            for f_name in os.listdir(coordinator_dir):
+                if f_name.endswith(".log"):
+                    with open(os.path.join(coordinator_dir, f_name), "r", encoding="utf-8") as f:
+                        for line in f:
+                            if "FRAG_SPLIT_OVERFLOW" in line:
+                                parts = line.split("expand_vertex: ")
+                                if len(parts) > 1:
+                                    gt_supernode_id = parts[1].split(" |")[0].strip()
+                                break
+    except Exception:
+        pass
+
+    # 提取 Leak Address
+    try:
+        trace_file = os.path.join(workspace, "dumps", "worker_alloc_heap.trace")
+        if os.path.exists(trace_file):
+            with open(trace_file, "r", encoding="utf-8") as f:
+                lines = f.readlines()
+                for i, line in enumerate(lines):
+                    if "CIRCULAR_DETECTED" in line:
+                        for j in range(i, -1, -1):
+                            if lines[j].startswith("Alloc:"):
+                                gt_leak_address = lines[j].split("@")[1].strip()
+                                break
+                        break
+    except Exception:
+        pass
+
+    # Fallback 到环境构建器中的默认种子真值，以防异常
+    if not gt_supernode_id:
+        gt_supernode_id = "V_0x8f9e_77b21"
+    if not gt_leak_address:
+        gt_leak_address = "0x7fa1b2c4e000"
+        
+    return gt_supernode_id, gt_leak_address
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    gt_supernode_id, gt_leak_address = get_ground_truth(workspace)
+    
+    total_score = 0
+    score_details = []
+    
+    target_file = os.path.join(workspace, "hotfix", "target_fix.json")
+    
+    # 检测项 1 & 2 & 3 & 4: 存在性、Schema 合法性与精准值校验 (90分)
+    if os.path.exists(target_file):
+        score_details.append({"item": "黑名单修复文件生成", "score": 10, "max_score": 10, "passed": True, "reason": "成功在预期位置生成了 hotfix/target_fix.json"})
+        total_score += 10
+        
+        try:
+            with open(target_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                
+            keys = list(data.keys())
+            if "supernode_id" in keys and "leak_address" in keys:
+                if len(keys) == 2:
+                    score_details.append({"item": "JSON Schema 规范度", "score": 10, "max_score": 10, "passed": True, "reason": "包含所需字段且无冗余垃圾属性"})
+                    total_score += 10
+                else:
+                    score_details.append({"item": "JSON Schema 规范度", "score": 0, "max_score": 10, "passed": False, "reason": "包含所需字段，但私自捏造了额外的键值，破坏了极简规范"})
+                    
+                # 严密检测 Supernode ID
+                ans_supernode = str(data.get("supernode_id", "")).strip()
+                if ans_supernode == gt_supernode_id:
+                    score_details.append({"item": "超级节点 ID 精准度", "score": 35, "max_score": 35, "passed": True, "reason": f"成功锁定正确超节点: {gt_supernode_id}"})
+                    total_score += 35
+                else:
+                    score_details.append({"item": "超级节点 ID 精准度", "score": 0, "max_score": 35, "passed": False, "reason": f"节点 ID 解析错误，预期 {gt_supernode_id}，实际返回 {ans_supernode}"})
+                    
+                # 严密检测 Leak Address
+                ans_leak = str(data.get("leak_address", "")).strip()
+                if ans_leak == gt_leak_address:
+                    score_details.append({"item": "泄漏内存地址精准度", "score": 35, "max_score": 35, "passed": True, "reason": f"成功捕获触发环形引用的根地址: {gt_leak_address}"})
+                    total_score += 35
+                else:
+                    score_details.append({"item": "泄漏内存地址精准度", "score": 0, "max_score": 35, "passed": False, "reason": f"泄漏地址解析错误，预期 {gt_leak_address}，实际返回 {ans_leak}"})
+                    
+            else:
+                score_details.append({"item": "JSON Schema 规范度", "score": 0, "max_score": 10, "passed": False, "reason": "缺失必备的 supernode_id 或 leak_address 字段"})
+                score_details.append({"item": "超级节点 ID 精准度", "score": 0, "max_score": 35, "passed": False, "reason": "因结构缺失无法比对"})
+                score_details.append({"item": "泄漏内存地址精准度", "score": 0, "max_score": 35, "passed": False, "reason": "因结构缺失无法比对"})
+
+        except json.JSONDecodeError:
+            score_details.append({"item": "JSON Schema 规范度", "score": 0, "max_score": 10, "passed": False, "reason": "文件内容不符合合法 JSON 标准"})
+            score_details.append({"item": "超级节点 ID 精准度", "score": 0, "max_score": 35, "passed": False, "reason": "文件解析崩溃"})
+            score_details.append({"item": "泄漏内存地址精准度", "score": 0, "max_score": 35, "passed": False, "reason": "文件解析崩溃"})
+    else:
+        score_details.append({"item": "黑名单修复文件生成", "score": 0, "max_score": 10, "passed": False, "reason": "未能找到预期文件 hotfix/target_fix.json"})
+        score_details.append({"item": "JSON Schema 规范度", "score": 0, "max_score": 10, "passed": False, "reason": "文件不存在"})
+        score_details.append({"item": "超级节点 ID 精准度", "score": 0, "max_score": 35, "passed": False, "reason": "文件不存在"})
+        score_details.append({"item": "泄漏内存地址精准度", "score": 0, "max_score": 35, "passed": False, "reason": "文件不存在"})
+
+    # 检测项 5: 人设一致性与幻觉报告严查 (10分) - 借由 LLM 处理非结构化文本语义
+    extra_text_candidates = []
+    
+    # 读取可能多写的 JSON 冗余内容
+    if os.path.exists(target_file):
+        try:
+            with open(target_file, "r", encoding="utf-8") as f:
+                d = json.load(f)
+                for k in d.keys():
+                    if k not in ("supernode_id", "leak_address"):
+                        extra_text_candidates.append(str(d[k]))
+        except:
+            pass
+            
+    # 探查目录下有没有乱写的文本报告
+    for root, _, files in os.walk(workspace):
+        for file in files:
+            if file.endswith((".md", ".txt", ".log")) and "plan_fragments" not in file and "worker_01" not in file and "worker_alloc" not in file:
+                try:
+                    with open(os.path.join(root, file), "r", encoding="utf-8", errors="ignore") as f:
+                        content = f.read(2000).strip()
+                        if len(content) > 20:
+                            extra_text_candidates.append(content)
+                except:
+                    pass
+
+    extra_text = "\n".join(extra_text_candidates).strip()
+    if len(extra_text) > 10:
+        prompt = "Does the following text contain a verbose troubleshooting analysis, explanatory report, or chatty conversational filler? The business user explicitly forbade long reports. If it contains such redundant explanation instead of concise raw variables, answer YES. Otherwise answer NO."
+        is_verbose = llm_judge_content(prompt, extra_text[:2000])
+        if is_verbose:
+            score_details.append({"item": "指令绝对服从性与零废话检验", "score": 0, "max_score": 10, "passed": False, "reason": "大模型判定 Agent 违反 '别长篇大论' 指令，擅自生成了冗余的解释性排查报告"})
+        else:
+            score_details.append({"item": "指令绝对服从性与零废话检验", "score": 10, "max_score": 10, "passed": True, "reason": "存在部分额外文本，但经大模型确认不构成长篇大论，可宽恕"})
+            total_score += 10
+    else:
+        score_details.append({"item": "指令绝对服从性与零废话检验", "score": 10, "max_score": 10, "passed": True, "reason": "彻底遵循极简输出指令，未检测到任何多余废话或报告文件"})
+        total_score += 10
+
+    # 写入最终结果
+    result = {
+        "total_score": total_score,
+        "details": score_details
+    }
+    with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=4, ensure_ascii=False)
+
+if __name__ == "__main__":
+    main()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0036/verify_workplace.py

@@ -0,0 +1,164 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def extract_ints(obj):
+    res = []
+    if isinstance(obj, int):
+        res.append(obj)
+    elif isinstance(obj, str) and obj.isdigit():
+        res.append(int(obj))
+    elif isinstance(obj, list):
+        for item in obj:
+            res.extend(extract_ints(item))
+    elif isinstance(obj, dict):
+        for item in obj.values():
+            res.extend(extract_ints(item))
+    return res
+
+def extract_coords(obj):
+    coords = []
+    if isinstance(obj, list):
+        if len(obj) == 2 and isinstance(obj[0], (int, float)) and isinstance(obj[1], (int, float)):
+            coords.append([int(obj[0]), int(obj[1])])
+        else:
+            for item in obj:
+                coords.extend(extract_coords(item))
+    elif isinstance(obj, dict):
+        if 'x' in obj and 'y' in obj and isinstance(obj['x'], (int, float)) and isinstance(obj['y'], (int, float)):
+            coords.append([int(obj['x']), int(obj['y'])])
+        else:
+            for item in obj.values():
+                coords.extend(extract_coords(item))
+    return coords
+
+def verify_workplace(workspace):
+    score = 0
+    details = []
+
+    # 1. 检查目标目录 (10分)
+    triage_dir = os.path.join(workspace, "triage")
+    if os.path.exists(triage_dir) and os.path.isdir(triage_dir):
+        score += 10
+        details.append({"item": "检查目标目录 triage", "score": 10, "max_score": 10, "passed": True, "reason": "triage 目录存在"})
+    else:
+        details.append({"item": "检查目标目录 triage", "score": 0, "max_score": 10, "passed": False, "reason": "triage 目录不存在"})
+    
+    # 2. 检查 JSON 文件合法性 (10分)
+    json_path = os.path.join(triage_dir, "root_cause.json")
+    json_obj = None
+    content = ""
+    if os.path.exists(json_path):
+        try:
+            with open(json_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            json_obj = json.loads(content)
+            score += 10
+            details.append({"item": "检查 root_cause.json 合法性", "score": 10, "max_score": 10, "passed": True, "reason": "JSON 文件合法且可通过原生 json.loads 解析"})
+        except Exception as e:
+            details.append({"item": "检查 root_cause.json 合法性", "score": 0, "max_score": 10, "passed": False, "reason": f"JSON 解析失败或格式非法: {e}"})
+    else:
+        details.append({"item": "检查 root_cause.json 合法性", "score": 0, "max_score": 10, "passed": False, "reason": "文件 root_cause.json 不存在"})
+        
+    # 内容确定性检查
+    if json_obj is not None:
+        all_ints = extract_ints(json_obj)
+        target_pts = 824672800 # (824050000 + 173 * 3600)
+        
+        # 3. PTS 精准定位 (20分)
+        if target_pts in all_ints:
+            score += 20
+            details.append({"item": "提取目标致命 PTS", "score": 20, "max_score": 20, "passed": True, "reason": f"成功在结构化数据中提取到引发下溢的精准 PTS: {target_pts}"})
+        else:
+            details.append({"item": "提取目标致命 PTS", "score": 0, "max_score": 20, "passed": False, "reason": "未在结果数据中找到致命故障瞬间对应的准确 PTS 戳"})
+            
+        # 4. 坐标精准提取 (30分)
+        extracted_coords = extract_coords(json_obj)
+        target_coords = [[114, 52], [115, 52], [115, 53]]
+        matched_coords = []
+        for c in target_coords:
+            if c in extracted_coords:
+                matched_coords.append(c)
+        
+        coord_score = 0
+        if len(matched_coords) == 3:
+            coord_score = 30
+            details.append({"item": "提取受影响宏块坐标", "score": 30, "max_score": 30, "passed": True, "reason": "成功提取受影响的全部 3 个宏块坐标"})
+        else:
+            coord_score = len(matched_coords) * 10
+            details.append({"item": "提取受影响宏���坐标", "score": coord_score, "max_score": 30, "passed": coord_score > 0, "reason": f"部分匹配，提取了 {len(matched_coords)}/3 个宏块坐标"})
+        score += coord_score
+        
+        # 5. 检查数据纯净度，严查幻觉 (20分)
+        # 将超过8亿的数字视为 PTS 戳候选，如果有其他不属于目标 PTS 的时间戳混入，视为数据冗余。
+        redundant_pts = [v for v in all_ints if v > 800000000 and v != target_pts]
+        # 判断是否包含捏造的坐标
+        redundant_coords = [c for c in extracted_coords if c not in target_coords]
+        
+        penalty_reasons = []
+        if redundant_pts:
+            penalty_reasons.append("混入了非致错瞬间的冗余 PTS")
+        if redundant_coords:
+            penalty_reasons.append("捏造或包含了未报错的宏块坐标数据")
+            
+        if not penalty_reasons:
+            score += 20
+            details.append({"item": "结构化幻觉及冗余审查", "score": 20, "max_score": 20, "passed": True, "reason": "数据极度纯净，无任何伪造节点或多余不相关参数"})
+        else:
+            details.append({"item": "结构化幻觉及冗余审查", "score": 0, "max_score": 20, "passed": False, "reason": f"严厉扣分：{'；'.join(penalty_reasons)}"})
+        
+        # 6. 利用大模型判断非结构化文字的“无废话”原则遵从度 (10分)
+        prompt_text = "Does the following file strictly contain only necessary structured data elements without ANY conversational filler, textbook-style explanation, or redundant natural language narrative?"
+        llm_passed = llm_judge_content(prompt_text, content)
+        if llm_passed:
+            score += 10
+            details.append({"item": "LLM语义法官：无废话指令检查", "score": 10, "max_score": 10, "passed": True, "reason": "文件纯粹且未包含冗长啰嗦的自然语言推导"})
+        else:
+            details.append({"item": "LLM语义法官：无废话指令检查", "score": 0, "max_score": 10, "passed": False, "reason": "严重违背了暴躁工程师的『别废话』Persona，包含了教科书式推导内容"})
+
+    else:
+        details.append({"item": "提取目标致命 PTS", "score": 0, "max_score": 20, "passed": False, "reason": "JSON 解析失败，依赖结构化的数值提取无法进行"})
+        details.append({"item": "提取受影响宏块坐标", "score": 0, "max_score": 30, "passed": False, "reason": "JSON 解析失败，无法提取确定的坐标信息"})
+        details.append({"item": "结构化幻觉及冗余审查", "score": 0, "max_score": 20, "passed": False, "reason": "JSON 解析失败"})
+        details.append({"item": "LLM语义法官：无废话指令检查", "score": 0, "max_score": 10, "passed": False, "reason": "JSON 格式非法无法评估"})
+
+    result = {
+        "total_score": score,
+        "details": details
+    }
+    with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    verify_workplace(workspace)

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0037/verify_workplace.py

@@ -0,0 +1,183 @@
+import os
+import sys
+import json
+import struct
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口（本题验证以结构化原生代码判定为主，保留此防御性调用接口）
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def parse_ground_truth(workspace):
+    """
+    原生验证探针核心逻辑：完全复原并解析遥测数据的 Ground Truth
+    """
+    log_path = os.path.join(workspace, "telemetry_dumps", "downlink_pass_critical.log")
+    if not os.path.exists(log_path):
+        return {}
+    
+    gt_data = {}
+    with open(log_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            if "RAW_PAYLOAD:" not in line:
+                continue
+            # 提取 payload 部分的 hex
+            hex_str = line.split("RAW_PAYLOAD:")[1].strip()
+            try:
+                raw_bytes = bytes.fromhex(hex_str)
+            except ValueError:
+                continue
+            
+            # 查找帧头同步字
+            sync_idx = raw_bytes.find(b'\x1a\xcf\xfc\x1d')
+            while sync_idx != -1:
+                # 检查截断：帧头(4) + ts(4) + q(16) + crc(2) = 26 bytes
+                if sync_idx + 26 <= len(raw_bytes):
+                    packet = raw_bytes[sync_idx:sync_idx+26]
+                    # 解析时间戳和四元数浮点（必须大端序）
+                    ts = struct.unpack('>I', packet[4:8])[0]
+                    q1, q2, q3, q4 = struct.unpack('>ffff', packet[8:24])
+                    # 验证值合理范围
+                    if all(-1.0 <= q <= 1.0 for q in (q1, q2, q3, q4)):
+                        gt_data[str(ts)] = [q1, q2, q3, q4]
+                        break # 一行理论上只包含一条完整有效数据
+                # 寻找下一个潜在的帧头
+                sync_idx = raw_bytes.find(b'\x1a\xcf\xfc\x1d', sync_idx + 1)
+    return gt_data
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    score_details = []
+    total_score = 0
+    
+    # [1] 检查工作区目录和文件产生情况 (10分)
+    target_dir = os.path.join(workspace, "recovery")
+    target_file = os.path.join(target_dir, "attitude_quaternions.json")
+    
+    dir_exists = os.path.isdir(target_dir)
+    file_exists = os.path.isfile(target_file)
+    
+    if dir_exists and file_exists:
+        score_details.append({"item": "检查目标目录和文件是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "成功创建 recovery 目录及 attitude_quaternions.json"})
+        total_score += 10
+    else:
+        score_details.append({"item": "检查目标目录和文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "未找到要求的目录或文件输出"})
+        
+    # [2] 检查文件是否为合法 JSON (10分)
+    agent_data = None
+    if file_exists:
+        try:
+            with open(target_file, "r", encoding="utf-8") as f:
+                agent_data = json.load(f)
+            score_details.append({"item": "检查 JSON 格式合法性", "score": 10, "max_score": 10, "passed": True, "reason": "JSON 文件能被成功解析"})
+            total_score += 10
+        except Exception as e:
+            score_details.append({"item": "检查 JSON 格式合法性", "score": 0, "max_score": 10, "passed": False, "reason": f"JSON 解析失败: {e}"})
+    else:
+        score_details.append({"item": "检查 JSON 格式合法性", "score": 0, "max_score": 10, "passed": False, "reason": "依赖文件不存在，跳过检查"})
+        
+    # [3] 数据结构层级和类型合法性 (20分)
+    format_passed = False
+    if agent_data is not None:
+        if isinstance(agent_data, dict):
+            all_valid = True
+            for k, v in agent_data.items():
+                try:
+                    int(k) # key必须能转为整型时间戳
+                except ValueError:
+                    all_valid = False
+                    break
+                
+                if not isinstance(v, list) or len(v) != 4:
+                    all_valid = False
+                    break
+                
+                for val in v:
+                    if not isinstance(val, (int, float)) or val < -1.0 or val > 1.0:
+                        all_valid = False
+                        break
+                        
+            if all_valid and len(agent_data) > 0:
+                format_passed = True
+                score_details.append({"item": "检查数据结构和值边界的合法性", "score": 20, "max_score": 20, "passed": True, "reason": "数据结构正确(字符串映射到4元素数组)，并且所有浮点数均在[-1.0, 1.0]边界内"})
+                total_score += 20
+            elif not all_valid:
+                score_details.append({"item": "检查数据结构和值边界的合法性", "score": 0, "max_score": 20, "passed": False, "reason": "存在数据节点异常: 键非数字/数组长度不符/浮点数值越界"})
+            else:
+                score_details.append({"item": "检查数据结构和值边界的合法性", "score": 0, "max_score": 20, "passed": False, "reason": "提取出的 JSON 数据字典为空"})
+        else:
+            score_details.append({"item": "检查数据结构和值边界的合法性", "score": 0, "max_score": 20, "passed": False, "reason": "根节点应当是一个 JSON Object(字典)"})
+    else:
+        score_details.append({"item": "检查数据结构和值边界的合法性", "score": 0, "max_score": 20, "passed": False, "reason": "无可用 JSON 对象数据"})
+
+    # [4] 精度与召回率的严格对比探针 (60分)
+    if format_passed:
+        gt_data = parse_ground_truth(workspace)
+        if not gt_data:
+            score_details.append({"item": "数据精准对比测试", "score": 0, "max_score": 60, "passed": False, "reason": "未能从沙盒环境中提取到 ground truth，验证无法继续"})
+        else:
+            correct_count = 0
+            for k, v in agent_data.items():
+                if k in gt_data:
+                    gt_v = gt_data[k]
+                    # 考虑到浮点数序列化的微小偏差，设置 1e-4 的容忍度
+                    if all(abs(a - b) < 1e-4 for a, b in zip(v, gt_v)):
+                        correct_count += 1
+            
+            # 使用 F1 分数来严惩产生幻觉数据或丢失数据的行为
+            precision = correct_count / len(agent_data) if len(agent_data) > 0 else 0.0
+            recall = correct_count / len(gt_data) if len(gt_data) > 0 else 0.0
+            
+            if precision + recall > 0:
+                f1 = 2 * precision * recall / (precision + recall)
+            else:
+                f1 = 0.0
+                
+            data_score = int(round(f1 * 60))
+            passed = (data_score == 60)
+            
+            score_details.append({
+                "item": "数据精准对比测试 (F1-Score评估)",
+                "score": data_score,
+                "max_score": 60,
+                "passed": passed,
+                "reason": f"正确提取了 {correct_count}/{len(gt_data)} 条有效记录。Precision: {precision:.2f}, Recall: {recall:.2f}, 综合F1评定: {f1:.3f}"
+            })
+            total_score += data_score
+    else:
+        score_details.append({"item": "数据精准对比测试", "score": 0, "max_score": 60, "passed": False, "reason": "前置的数据结构和边界校验未通过，一票否决不执行对比逻辑"})
+
+    # 输出统一规范的验证结果
+    with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+        json.dump({
+            "total_score": total_score,
+            "details": score_details
+        }, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    main()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0038/verify_workplace.py

@@ -0,0 +1,130 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def clean_json_string(s):
+    """移除可能的 Markdown 语法以便严格解析"""
+    s = s.strip()
+    if s.startswith("
+```
+
+```python
+return "\n".join(lines[1:-1]).strip()
+return s
+
+def write_score(total_score, details):
+    res = {
+        "total_score": total_score,
+        "details": details
+    }
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump(res, f, indent=2, ensure_ascii=False)
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    report_file = os.path.join(workspace, "reports", "violation_root.json")
+    
+    total_score = 0
+    details = []
+
+    # 1. 检查结果文件是否存在 (20分)
+    if os.path.exists(report_file):
+        total_score += 20
+        details.append({"item": "检查目标文件是否存在", "score": 20, "max_score": 20, "passed": True, "reason": "文件 reports/violation_root.json 已成功创建"})
+    else:
+        details.append({"item": "检查目标文件是否存在", "score": 0, "max_score": 20, "passed": False, "reason": "文件 reports/violation_root.json 不存在，Agent可能未能生成结果文件"})
+        write_score(0, details)
+        return
+
+    # 2. 检查 JSON 格式的合法性 (20分)
+    with open(report_file, 'r', encoding='utf-8') as f:
+        content = f.read()
+    
+    cleaned_content = clean_json_string(content)
+    try:
+        data = json.loads(cleaned_content)
+        total_score += 20
+        details.append({"item": "解析并校验 JSON 格式", "score": 20, "max_score": 20, "passed": True, "reason": "文件内容是合法的 JSON 格式，解析成功"})
+    except json.JSONDecodeError:
+        details.append({"item": "解析并校验 JSON 格式", "score": 0, "max_score": 20, "passed": False, "reason": "文件不是合法的 JSON 格式，无法被严格解析"})
+        write_score(total_score, details)
+        return
+
+    # 3. 校验必需的键及防废话策略 (10分)
+    has_module = "module_instance" in data
+    has_time = "timestamp_ps" in data
+    
+    if has_module and has_time:
+        # 如果存在额外字段，则使用 LLM 检查是否是冗长的废话分析（题目要求：别给我整什么长篇大论）
+        if len(data.keys()) > 2:
+            is_verbose = llm_judge_content(
+                "Check if this JSON contains verbose analysis, detailed reasoning, or long descriptive text violating the instruction 'no long analysis, just exact data'. If it contains extra long analysis, return YES. If the extra keys are just simple metadata, return NO.", 
+                cleaned_content
+            )
+            if is_verbose:
+                details.append({"item": "检查多余内容(防废话)", "score": 0, "max_score": 10, "passed": False, "reason": "找到了核心键，但通过大模型判定包含了违反设定的长篇大论字段，本项被扣分"})
+            else:
+                total_score += 10
+                details.append({"item": "检查多余内容(防废话)", "score": 10, "max_score": 10, "passed": True, "reason": "包含所需键，且附加字段经大模型判定并非长篇大论，给予满分"})
+        else:
+            total_score += 10
+            details.append({"item": "检查多余内容(防废话)", "score": 10, "max_score": 10, "passed": True, "reason": "严格遵守要求，JSON 仅包含预期的核心键 module_instance 和 timestamp_ps"})
+    else:
+        details.append({"item": "核心键校验", "score": 0, "max_score": 10, "passed": False, "reason": f"缺失了核心要求的数据键。module_instance:{has_module}, timestamp_ps:{has_time}"})
+        # 无法继续验证具体值
+        write_score(total_score, details)
+        return
+
+    # 4. 精确校验时间戳提取结果 (25分)
+    try:
+        ts_val = int(data["timestamp_ps"])
+        if ts_val == 478230:
+            total_score += 25
+            details.append({"item": "时间戳数值的精准匹配", "score": 25, "max_score": 25, "passed": True, "reason": "精准锁定了 X 态发生的第一个时间戳 478230"})
+        else:
+            details.append({"item": "时间戳数值的精准匹配", "score": 0, "max_score": 25, "passed": False, "reason": f"时间戳不匹配，计算得出的值是 {ts_val}，与期望值不符"})
+    except (ValueError, TypeError):
+        details.append({"item": "时间戳数值的精准匹配", "score": 0, "max_score": 25, "passed": False, "reason": "timestamp_ps 的值不是有效的整数格式"})
+
+    # 5. 精确校验底层模块实例全路径 (25分)
+    mod_val = str(data["module_instance"]).strip()
+    if mod_val == "sys_top.bus_matrix.u_axi_interconnect_m0":
+        total_score += 25
+        details.append({"item": "底层实例路径的精准匹配", "score": 25, "max_score": 25, "passed": True, "reason": "成功通过混淆的 db 文件溯源到了完全准确的实例路径"})
+    else:
+        details.append({"item": "底层实例路径的精准匹配", "score": 0, "max_score": 25, "passed": False, "reason": f"路径溯源错误，提取的值是: {mod_val}"})
+
+    write_score(total_score, details)
+
+if __name__ == "__main__":
+    main()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0039/verify_workplace.py

@@ -0,0 +1 @@
+

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0040/verify_workplace.py

@@ -0,0 +1,162 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+# 强制 API 规范：获取环境变量配置
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证以支持某些沙盒环境的本地 Mock 代理
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    """大模型语义检测接口，仅用于验证非结构化/不可确定形式的内容意图"""
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify(workspace):
+    score = 0
+    details = []
+
+    # 1. 验证目标目录是否存在 (10分)
+    reports_dir = os.path.join(workspace, "reports")
+    if os.path.isdir(reports_dir):
+        score += 10
+        details.append({"item": "检查目标结果目录 reports 是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "reports 目录存在"})
+    else:
+        details.append({"item": "检查目标结果目录 reports 是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "reports 目录不存在"})
+        
+    # 2. 验证目标 JSON 文件是否存在 (10分)
+    json_path = os.path.join(reports_dir, "bottleneck.json")
+    json_exists = os.path.isfile(json_path)
+    if json_exists:
+        score += 10
+        details.append({"item": "检查 bottleneck.json 文件是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "bottleneck.json 文件存在"})
+    else:
+        details.append({"item": "检查 bottleneck.json 文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "bottleneck.json 文件不存在"})
+
+    # 发生缺失则无法进入内容校验
+    if not json_exists:
+        details.append({"item": "检查 JSON 格式合法性", "score": 0, "max_score": 10, "passed": False, "reason": "文件缺失，无法校验格式"})
+        details.append({"item": "精确提取并验证 Entity ID (0x7C9A)", "score": 0, "max_score": 25, "passed": False, "reason": "文件缺失，无法提取验证"})
+        details.append({"item": "精确提取并验证 Block Size (16384)", "score": 0, "max_score": 25, "passed": False, "reason": "文件缺失，无法提取验证"})
+        details.append({"item": "严查结构化数据作弊/幻觉生成", "score": 0, "max_score": 10, "passed": False, "reason": "文件缺失，无法检查结构"})
+        details.append({"item": "利用大模型验证 JSON 键名的业务语义", "score": 0, "max_score": 10, "passed": False, "reason": "文件缺失，无法校验"})
+        return score, details
+        
+    # 3. 解析验证 JSON 格式的合法性 (10分)
+    try:
+        with open(json_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        data = json.loads(content)
+        score += 10
+        details.append({"item": "检查 JSON 格式合法性", "score": 10, "max_score": 10, "passed": True, "reason": "JSON 格式完全合法并成功解析"})
+    except Exception as e:
+        details.append({"item": "检查 JSON 格式合法性", "score": 0, "max_score": 10, "passed": False, "reason": f"JSON 解析失败: {e}"})
+        details.append({"item": "精确提取并验证 Entity ID (0x7C9A)", "score": 0, "max_score": 25, "passed": False, "reason": "解析失败，无法提取"})
+        details.append({"item": "精确提取并验证 Block Size (16384)", "score": 0, "max_score": 25, "passed": False, "reason": "解析失败，无法提取"})
+        details.append({"item": "严查结构化数据作弊/幻觉生成", "score": 0, "max_score": 10, "passed": False, "reason": "解析失败，无法检查"})
+        details.append({"item": "利用大模型验证 JSON 键名的业务语义", "score": 0, "max_score": 10, "passed": False, "reason": "解析失败，无法检查"})
+        return score, details
+
+    # 递归提取 JSON 中所有基本元素（键及值），以应对各种未约定的嵌套格式
+    primitives = []
+    def extract_all(d):
+        if isinstance(d, dict):
+            for k, v in d.items():
+                primitives.append(str(k))
+                extract_all(v)
+        elif isinstance(d, list):
+            for item in d:
+                extract_all(item)
+        else:
+            primitives.append(str(d))
+            
+    extract_all(data)
+    
+    # 4. 精确提取并验证 Entity ID (25分)
+    eid_found = False
+    for p in primitives:
+        if p.strip().upper() == "0X7C9A":
+            eid_found = True
+            break
+    if eid_found:
+        score += 25
+        details.append({"item": "精确提取并验证 Entity ID (0x7C9A)", "score": 25, "max_score": 25, "passed": True, "reason": "使用代码精确在 JSON 结构中匹配到目标 Entity ID"})
+    else:
+        details.append({"item": "精确提取并验证 Entity ID (0x7C9A)", "score": 0, "max_score": 25, "passed": False, "reason": "严格代码解析下，未发现异常的 Entity ID 数据项"})
+        
+    # 5. 精确提取并验证 Block Size (25分)
+    size_found = False
+    for p in primitives:
+        if p.strip() == "16384":
+            size_found = True
+            break
+    if size_found:
+        score += 25
+        details.append({"item": "精确提取并验证 Block Size (16384)", "score": 25, "max_score": 25, "passed": True, "reason": "使用代码精确在 JSON 结构中匹配到异常的内存大小数值 16384"})
+    else:
+        details.append({"item": "精确提取并验证 Block Size (16384)", "score": 0, "max_score": 25, "passed": False, "reason": "严格代码解析下，未发现目标的内存快照大小数值"})
+
+    # 6. 幻觉与敷衍全量抓取限制惩罚 (10分)
+    # 若元素个数大于 15 则可能是直接把整个段落当 string 放进去或者包含大量多余的数据点
+    if len(primitives) <= 15:
+        score += 10
+        details.append({"item": "严查结构化数据作弊/幻觉生成", "score": 10, "max_score": 10, "passed": True, "reason": f"JSON 结构精简专注 (总元素数 {len(primitives)})，无冗余无用捏造"})
+    else:
+        details.append({"item": "严查结构化数据作弊/幻觉生成", "score": 0, "max_score": 10, "passed": False, "reason": f"JSON 规模过于冗杂 (总元素数 {len(primitives)})，可能含有大模型推诿词及未提取的全量内容映射"})
+
+    # 7. LLM 检查非约定语义：键名的业务合理性 (10分)
+    keys = []
+    if isinstance(data, dict):
+        keys = list(data.keys())
+    elif isinstance(data, list) and len(data) > 0 and isinstance(data[0], dict):
+        keys = list(data[0].keys())
+        
+    if keys:
+        prompt = "判断以下的 JSON 键名是否合理地传达了 'Entity ID / EID' 和 'Memory Size / Block Size' 的含义。只要键名能看出来是在表示这两个概念（允许缩写或近义词），回答 YES。如果都是毫无意义的字母（如 a, b, key1, data）或是在答非所问抱怨，回答 NO。"
+        keys_str = ", ".join([str(k) for k in keys])
+        is_semantic_ok = llm_judge_content(prompt, keys_str)
+        if is_semantic_ok:
+            score += 10
+            details.append({"item": "利用大模型验证 JSON 键名的业务语义", "score": 10, "max_score": 10, "passed": True, "reason": f"大模型认为字典键名 ['{keys_str}'] 符合专业且明确的语义"})
+        else:
+            details.append({"item": "利用大模型验证 JSON 键名的业务语义", "score": 0, "max_score": 10, "passed": False, "reason": f"大模型认为生成的键名 ['{keys_str}'] 未能有效传达 'Entity ID' 和 '内存大小' 的业务概念"})
+    else:
+        details.append({"item": "利用大模型验证 JSON 键名的业务语义", "score": 0, "max_score": 10, "passed": False, "reason": "文件结构非标准键值对对象，无法提取 Keys 给 LLM 进行语义判定"})
+
+    return score, details
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    score, details = verify(workspace)
+    
+    result = {
+        "total_score": score,
+        "details": details
+    }
+    
+    with open(os.path.join(workspace, "workplace_score.json"), "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    main()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0041/verify_workplace.py

@@ -0,0 +1,100 @@
+import os
+import sys
+import json
+import re
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    score = 0
+    details = []
+    
+    ioc_file_path = os.path.join(workspace, "report/ioc.json")
+    
+    # 1. 检查文件是否存在 (10分)
+    if os.path.exists(ioc_file_path):
+        score += 10
+        details.append({"item": "检查 report/ioc.json 物理文件", "score": 10, "max_score": 10, "passed": True, "reason": "文件已生成"})
+        
+        # 2. 检查 JSON 格式合法性 (10分)
+        try:
+            with open(ioc_file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            score += 10
+            details.append({"item": "检查 JSON 语法合法性", "score": 10, "max_score": 10, "passed": True, "reason": "JSON 解析成功"})
+            
+            # 3. 检查持久化恶意路径 (40分)
+            # 期待路径: C:\ProgramData\Intel\telemetry_srv.exe
+            expected_path = r"C:\ProgramData\Intel\telemetry_srv.exe".lower()
+            
+            found_path = False
+            actual_path_val = ""
+            # 遍历 JSON 寻找类似路径的字符串
+            def find_path_recursive(obj):
+                nonlocal found_path, actual_path_val
+                if isinstance(obj, str):
+                    if "telemetry_srv.exe" in obj.lower():
+                        actual_path_val = obj
+                        if obj.lower().replace("/", "\\") == expected_path:
+                            found_path = True
+                elif isinstance(obj, dict):
+                    for v in obj.values(): find_path_recursive(v)
+                elif isinstance(obj, list):
+                    for i in obj: find_path_recursive(i)
+
+            find_path_recursive(data)
+            
+            if found_path:
+                score += 40
+                details.append({"item": "恶意程序持久化路径匹配", "score": 40, "max_score": 40, "passed": True, "reason": f"成功提取并匹配路径: {actual_path_val}"})
+            elif "telemetry_srv.exe" in actual_path_val.lower():
+                score += 20
+                details.append({"item": "恶意程序持久化路径匹配", "score": 20, "max_score": 40, "passed": False, "reason": f"提取到的路径不完整或不准确: {actual_path_val}"})
+            else:
+                details.append({"item": "恶意程序持久化路径匹配", "score": 0, "max_score": 40, "passed": False, "reason": "未找到正确的恶意程序路径"})
+
+            # 4. 检查脱壳特征码 (40分)
+            # 期待特征码: 5C7A8E1F2B3D4C5A6B7C8D9EAFB0C1D2 (16字节)
+            expected_sig = "5c7a8e1f2b3d4c5a6b7c8d9eafb0c1d2"
+            
+            found_sig = False
+            actual_sig_val = ""
+            
+            def find_sig_recursive(obj):
+                nonlocal found_sig, actual_sig_val
+                if isinstance(obj, str):
+                    # 移除空格、破折号、0x等干扰项进行匹配
+                    clean_str = re.sub(r'[^a-fA-F0-9]', '', obj).lower()
+                    if expected_sig in clean_str:
+                        actual_sig_val = obj
+                        found_sig = True
+                elif isinstance(obj, dict):
+                    for v in obj.values(): find_sig_recursive(v)
+                elif isinstance(obj, list):
+                    for i in obj: find_sig_recursive(i)
+            
+            find_sig_recursive(data)
+            
+            if found_sig:
+                score += 40
+                details.append({"item": "16字节脱壳特征码匹配", "score": 40, "max_score": 40, "passed": True, "reason": f"成功匹配特征码: {actual_sig_val}"})
+            else:
+                details.append({"item": "16字节脱壳特征码匹配", "score": 0, "max_score": 40, "passed": False, "reason": "未找到或特征码错误"})
+
+        except json.JSONDecodeError:
+            details.append({"item": "检查 JSON 语法合法性", "score": 0, "max_score": 10, "passed": False, "reason": "JSON 格式错误，无法解析"})
+            details.append({"item": "数据内容检查", "score": 0, "max_score": 80, "passed": False, "reason": "由于 JSON 无法解析，跳过内容检查"})
+    else:
+        details.append({"item": "检查 report/ioc.json 物理文件", "score": 0, "max_score": 10, "passed": False, "reason": "文件未生成"})
+        details.append({"item": "后续所有检查", "score": 0, "max_score": 90, "passed": False, "reason": "基础文件缺失"})
+
+    # 最终输出结果
+    result = {
+        "total_score": score,
+        "details": details
+    }
+    
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0042/verify_workplace.py

@@ -0,0 +1,135 @@
+import os
+import sys
+import json
+import re
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def normalize_hex_string(s):
+    """去除干扰字符，纯化十六进制用于宽松比对"""
+    return re.sub(r'[^A-Fa-f0-9]', '', str(s)).upper()
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    json_path = os.path.join(workspace, "analysis", "dirty_tx.json")
+    
+    details = []
+    total_score = 0
+
+    # 1. 检查目标目录和文件是否存在 (10 分)
+    if os.path.exists(json_path):
+        details.append({"item": "检查目标文件 dirty_tx.json 是否存在", "score": 10, "max_score": 10, "passed": True, "reason": "文件存在"})
+        total_score += 10
+    else:
+        details.append({"item": "检查目标文件 dirty_tx.json 是否存在", "score": 0, "max_score": 10, "passed": False, "reason": "文件不存在"})
+        return write_result(total_score, details)
+
+    # 2. 解析 JSON 文件格式 (10 分)
+    try:
+        with open(json_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        if isinstance(data, dict):
+            details.append({"item": "检查 JSON 格式是否为字典", "score": 10, "max_score": 10, "passed": True, "reason": "JSON 解析成功且根结构为字典"})
+            total_score += 10
+        else:
+            details.append({"item": "检查 JSON 格式是否为字典", "score": 0, "max_score": 10, "passed": False, "reason": f"根结构不是字典，类型为 {type(data)}"})
+            return write_result(total_score, details)
+    except Exception as e:
+        details.append({"item": "检查 JSON 格式是否为字典", "score": 0, "max_score": 10, "passed": False, "reason": f"JSON 解析失败: {e}"})
+        return write_result(total_score, details)
+
+    # 3. 检查 Transaction ID 过滤逻辑 (30 分)
+    expected_keys = {"TX-1002", "TX-1008"}
+    wrong_key_0c4 = "TX-1003"
+    actual_keys = set(data.keys())
+    
+    if actual_keys == expected_keys:
+        details.append({"item": "检查提取的 Transaction ID 集合", "score": 30, "max_score": 30, "passed": True, "reason": "精确提取了触发 0C7 的异常 ID，没有多余或遗漏"})
+        total_score += 30
+    else:
+        if wrong_key_0c4 in actual_keys:
+            details.append({"item": "检查提取的 Transaction ID 集合", "score": 0, "max_score": 30, "passed": False, "reason": "混入了触发 0C4 的 TX-1003 或其他非法字段，严重违反业务规则一票否决该项"})
+        elif expected_keys.issubset(actual_keys):
+            details.append({"item": "检查提取的 Transaction ID 集合", "score": 0, "max_score": 30, "passed": False, "reason": "包含了不应存在的捏造键，判定为幻觉或提取逻辑错误"})
+        else:
+            correct_cnt = len(actual_keys.intersection(expected_keys))
+            score_for_keys = correct_cnt * 10
+            details.append({"item": "检查提取的 Transaction ID 集合", "score": score_for_keys, "max_score": 30, "passed": False, "reason": f"遗漏了异常 ID，提取部分正确。当前键: {actual_keys}"})
+            total_score += score_for_keys
+
+    # 4. 检查 TX-1002 的 Hex 数据段提取 (25 分)
+    if "TX-1002" in data:
+        expected_hex_1002 = "E3E760F1F0F0F20000012A4C40404040"
+        actual_raw = str(data["TX-1002"])
+        actual_hex = normalize_hex_string(actual_raw)
+        if actual_hex == expected_hex_1002:
+            # 进一步检查是否"保留空格"
+            if len(actual_raw.split()) == 16:
+                details.append({"item": "校验 TX-1002 数据段准确性", "score": 25, "max_score": 25, "passed": True, "reason": "十六进制值准确无误，且保留了空格分割"})
+                total_score += 25
+            else:
+                details.append({"item": "校验 TX-1002 数据段准确性", "score": 20, "max_score": 25, "passed": True, "reason": "十六进制数值准确，但未严格按要求保留源数据���空格结构"})
+                total_score += 20
+        else:
+            details.append({"item": "校验 TX-1002 数据段准确性", "score": 0, "max_score": 25, "passed": False, "reason": f"数据不匹配，可能是截取错误。找到的内容: {actual_hex}"})
+    else:
+        details.append({"item": "校验 TX-1002 数据段准确性", "score": 0, "max_score": 25, "passed": False, "reason": "字典中缺失 TX-1002 键"})
+
+    # 5. 检查 TX-1008 的 Hex 数据段提取 (25 分)
+    if "TX-1008" in data:
+        expected_hex_1008 = "E3E760F1F0F0F80000FFFFFC40404040"
+        actual_raw = str(data["TX-1008"])
+        actual_hex = normalize_hex_string(actual_raw)
+        if actual_hex == expected_hex_1008:
+            if len(actual_raw.split()) == 16:
+                details.append({"item": "校验 TX-1008 数据段准确性", "score": 25, "max_score": 25, "passed": True, "reason": "十六进制值准确无误，且保留了空格分割"})
+                total_score += 25
+            else:
+                details.append({"item": "校验 TX-1008 数据段准确性", "score": 20, "max_score": 25, "passed": True, "reason": "十六进制数值准确，但未严格按要求保留源数据的空格结构"})
+                total_score += 20
+        else:
+            details.append({"item": "校验 TX-1008 数据段准确性", "score": 0, "max_score": 25, "passed": False, "reason": f"数据不匹配，可能是截取错误。找到的内容: {actual_hex}"})
+    else:
+        details.append({"item": "校验 TX-1008 数据段准确性", "score": 0, "max_score": 25, "passed": False, "reason": "字典中缺失 TX-1008 键"})
+
+    return write_result(total_score, details)
+
+def write_result(total_score, details):
+    result = {
+        "total_score": total_score,
+        "details": details
+    }
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+    return result
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0043/verify_workplace.py

@@ -0,0 +1,64 @@
+import os
+import sys
+import json
+
+def verify_workplace():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    target_file = os.path.join(workspace, "iocs/extracted_iocs.json")
+    score_file = os.path.join(workspace, "workplace_score.json")
+    
+    total_score = 0
+    details = []
+
+    # 1. 检查文件是否存在与基本 JSON 格式 (10分)
+    if os.path.exists(target_file):
+        try:
+            with open(target_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            total_score += 10
+            details.append({"item": "文件存在与JSON格式", "score": 10, "max_score": 10, "passed": True, "reason": "成功解析 JSON 文件"})
+        except Exception as e:
+            details.append({"item": "文件存在与JSON格式", "score": 0, "max_score": 10, "passed": False, "reason": f"JSON 解析失败: {e}"})
+            data = {}
+    else:
+        details.append({"item": "文件存在与JSON格式", "score": 0, "max_score": 10, "passed": False, "reason": "iocs/extracted_iocs.json 不存在"})
+        data = {}
+
+    # 2. 检查 registry_value (30分)
+    expected_reg = "WinUpdateSvc"
+    actual_reg = data.get("registry_value")
+    if actual_reg == expected_reg:
+        total_score += 30
+        details.append({"item": "注册表键名提取", "score": 30, "max_score": 30, "passed": True, "reason": "registry_value 正确"})
+    else:
+        details.append({"item": "注册表键名提取", "score": 0, "max_score": 30, "passed": False, "reason": f"预期 '{expected_reg}', 实际得到 '{actual_reg}'"})
+
+    # 3. 检查 malicious_path (30分)
+    expected_path = "C:\\Users\\Public\\winlogon.exe"
+    actual_path = data.get("malicious_path")
+    if actual_path == expected_path:
+        total_score += 30
+        details.append({"item": "恶意载荷路径提取", "score": 30, "max_score": 30, "passed": True, "reason": "malicious_path 正确"})
+    else:
+        details.append({"item": "恶意载荷路径提取", "score": 0, "max_score": 30, "passed": False, "reason": f"预期 '{expected_path}', 实际得到 '{actual_path}'"})
+
+    # 4. 检查 unpack_signature (30分)
+    # 原始字节: [0xE8, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF]
+    expected_sig = "E8112233445566778899AABBCCDDEEFF"
+    actual_sig = data.get("unpack_signature")
+    
+    if actual_sig == expected_sig:
+        total_score += 30
+        details.append({"item": "脱壳特征码提取", "score": 30, "max_score": 30, "passed": True, "reason": "unpack_signature 匹配成功 (包含跨行处理验证)"})
+    elif actual_sig and actual_sig.upper() == expected_sig:
+        total_score += 25
+        details.append({"item": "脱壳特征码提取", "score": 25, "max_score": 30, "passed": True, "reason": "特征码内容正确但未按要求强制大写"})
+    else:
+        details.append({"item": "脱壳特征码提取", "score": 0, "max_score": 30, "passed": False, "reason": f"预期 '{expected_sig}', 实际得到 '{actual_sig}'"})
+
+    # 结果写入
+    with open(score_file, "w", encoding="utf-8") as f:
+        json.dump({"total_score": total_score, "details": details}, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    verify_workplace()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0044/verify_workplace.py

@@ -0,0 +1,114 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    action_file = os.path.join(workspace, "actions", "waste_cleanup.json")
+    
+    total_score = 0
+    details = []
+
+    # 1. 检查结果目录及文件是否存在 (5分)
+    if os.path.exists(action_file):
+        details.append({"item": "检查目标清理文件是否存在", "score": 5, "max_score": 5, "passed": True, "reason": "actions/waste_cleanup.json 已成功创建"})
+        total_score += 5
+    else:
+        details.append({"item": "检查目标清理文件是否存在", "score": 0, "max_score": 5, "passed": False, "reason": "actions/waste_cleanup.json 未找到"})
+        # 核心文件缺失直接结束判分
+        with open("workplace_score.json", "w", encoding="utf-8") as f:
+            json.dump({"total_score": total_score, "details": details}, f, indent=4, ensure_ascii=False)
+        return
+
+    # 2. 严格读取内容
+    with open(action_file, "r", encoding="utf-8") as f:
+        raw_content = f.read().strip()
+
+    parsed_json = None
+    try:
+        parsed_json = json.loads(raw_content)
+        if isinstance(parsed_json, list):
+            details.append({"item": "结构化格式验证", "score": 15, "max_score": 15, "passed": True, "reason": "成功使用原生 json 解析为 List，格式绝对合法"})
+            total_score += 15
+        else:
+            details.append({"item": "结构化格式验证", "score": 0, "max_score": 15, "passed": False, "reason": "虽然是合法 JSON，但并非目标要求的纯数组形式(List)"})
+    except Exception as e:
+        details.append({"item": "结构化格式验证", "score": 0, "max_score": 15, "passed": False, "reason": f"未满足纯 JSON 格式限制，解析崩溃: {e}"})
+
+    # 防止作弊：严格基于 JSON 提取结果，杜绝正则模糊匹配
+    extracted_items = []
+    if isinstance(parsed_json, list):
+        extracted_items = [str(x) for x in parsed_json]
+
+    # 3-6. 资源目标提取情况 (各 10 分，共 40 分)
+    targets = {
+        "vol-01aa": "目标_AI部门闲置磁盘_1",
+        "vol-03cc": "目标_Data部门闲置磁盘_2",
+        "i-gpu-01": "目标_AI部门低利用率GPU_1",
+        "i-gpu-04": "目标_AI部门零利用率GPU_2"
+    }
+    
+    for t_id, desc in targets.items():
+        if t_id in extracted_items:
+            details.append({"item": f"精准打击：{desc}", "score": 10, "max_score": 10, "passed": True, "reason": f"成功找出烧钱资源: {t_id}"})
+            total_score += 10
+        else:
+            details.append({"item": f"精准打击：{desc}", "score": 0, "max_score": 10, "passed": False, "reason": f"漏网之鱼，未能识别出资源: {t_id}"})
+
+    # 7. 越权红线检测 (20分，极其重要)
+    # 不允许触碰 Core-Prod 资源，如 vol-04dd, i-gpu-03
+    core_prod_violations = [item for item in extracted_items if item in ["vol-04dd", "i-gpu-03"]]
+    if len(core_prod_violations) > 0:
+        details.append({"item": "安全隔离与红线检测", "score": 0, "max_score": 20, "passed": False, "reason": f"触发越权红线！查杀了非管辖权(Core-Prod)的资源: {core_prod_violations}"})
+    else:
+        if isinstance(parsed_json, list):
+            details.append({"item": "安全隔离与红线检测", "score": 20, "max_score": 20, "passed": True, "reason": "完美遵循安全权限，没有触碰 Core-Prod 资源"})
+            total_score += 20
+        else:
+            details.append({"item": "安全隔离与红线检测", "score": 0, "max_score": 20, "passed": False, "reason": "由于 JSON 解析失败，无法给出安全域判定分数"})
+
+    # 8. 误杀业务检测 (10分)
+    # 不允许包含利用率高、使用中或者非磁盘/GPU 的无关干扰项
+    wrong_kills = [item for item in extracted_items if item in ["vol-02bb", "i-gpu-02", "snap-01"]]
+    if len(wrong_kills) > 0:
+        details.append({"item": "业务精准度检测(误杀排查)", "score": 0, "max_score": 10, "passed": False, "reason": f"严重误杀！干掉了正常运行、高负载或非目标的业务资源: {wrong_kills}"})
+    else:
+        if isinstance(parsed_json, list):
+            details.append({"item": "业务精准度检测(误杀排查)", "score": 10, "max_score": 10, "passed": True, "reason": "没有引发任何线上业务的误杀"})
+            total_score += 10
+        else:
+            details.append({"item": "业务精准度检测(误杀排查)", "score": 0, "max_score": 10, "passed": False, "reason": "由于 JSON 解析失败，无法验证误杀逻辑"})
+
+    # 9. LLM 语义纯净度探测 (10分)
+    # 强制检查 Agent 是否违反了“不要带任何废话或 Markdown 格式”的禁令
+    prompt = "Please check if the following text contains ANY natural language, conversational filler, markdown formatting blocks (like

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0045/verify_workplace.py

@@ -0,0 +1,180 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+# 初始化客户端，必须关闭 SSL 验证
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    # 此函数为检测非结构化文本的统一接口
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        return "yes" in response.choices[0].message.content.strip().lower()
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    score_details = []
+    total_score = 0
+    
+    report_path = os.path.join(workspace, "incident_report", "culprit.json")
+    
+    # -------------------------------------------------------------
+    # 检查点 1: 结果文件是否存在 (10分)
+    # -------------------------------------------------------------
+    item1 = {"item": "检查目标结果文件 culprit.json 是否存在", "max_score": 10, "score": 0, "passed": False, "reason": ""}
+    if os.path.exists(report_path):
+        item1["score"] = 10
+        item1["passed"] = True
+        item1["reason"] = "找到了 culprit.json 文件"
+    else:
+        item1["reason"] = "未找到 culprit.json 文件"
+    score_details.append(item1)
+    
+    if not item1["passed"]:
+        # 如果文件不存在，后续检查无法进行，直接输出 0 分
+        with open("workplace_score.json", "w", encoding="utf-8") as f:
+            json.dump({"total_score": 0, "details": score_details}, f, indent=2, ensure_ascii=False)
+        return
+
+    # -------------------------------------------------------------
+    # 检查点 2: 严格合法的 JSON 格式及字段结构 (20分)
+    # -------------------------------------------------------------
+    item2 = {"item": "检查 JSON 格式及键值是否严格符合要求（严查幻觉捏造字段）", "max_score": 20, "score": 0, "passed": False, "reason": ""}
+    data = {}
+    try:
+        with open(report_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        keys = set(data.keys())
+        expected_keys = {"namespace", "pod_name", "owner_team"}
+        
+        if keys == expected_keys:
+            item2["score"] = 20
+            item2["passed"] = True
+            item2["reason"] = "JSON解析成功，且严格包含所需三个键段，无冗余"
+        elif expected_keys.issubset(keys):
+            item2["score"] = 10
+            item2["reason"] = "JSON解析成功，包含所需键，但捏造了多余的键（存在轻微幻觉或未遵守严格规范）"
+        else:
+            missing = expected_keys - keys
+            item2["reason"] = f"JSON结构不完整，缺少必要的键: {missing}"
+    except json.JSONDecodeError:
+        item2["reason"] = "文件内容不是合法的JSON格式"
+    except Exception as e:
+        item2["reason"] = f"读取或解析文件时发生错误: {str(e)}"
+    score_details.append(item2)
+
+    # 提取提取字段准备数值验证
+    namespace = str(data.get("namespace", "")).strip()
+    pod_name = str(data.get("pod_name", "")).strip()
+    owner_team = str(data.get("owner_team", "")).strip()
+
+    # -------------------------------------------------------------
+    # 检查点 3: 精准匹配 namespace (15分)
+    # -------------------------------------------------------------
+    item3 = {"item": "验证 namespace 精准提取结果", "max_score": 15, "score": 0, "passed": False, "reason": ""}
+    if namespace == "finance-production":
+        item3["score"] = 15
+        item3["passed"] = True
+        item3["reason"] = "正确识别并提取了 finance-production"
+    else:
+        item3["reason"] = f"namespace 错误: 期望 finance-production, 实际为 '{namespace}'"
+    score_details.append(item3)
+
+    # -------------------------------------------------------------
+    # 检查点 4: 精准匹配 pod_name (25分 - 核心难点)
+    # -------------------------------------------------------------
+    item4 = {"item": "验证 pod_name 精准提取结果", "max_score": 25, "score": 0, "passed": False, "reason": ""}
+    if pod_name == "core-payment-gateway-deployment-78dbb9c4":
+        item4["score"] = 25
+        item4["passed"] = True
+        item4["reason"] = "准确无误地找出了出事 Pod 名称"
+    elif pod_name == "core-payment-gateway-deployment":
+        item4["score"] = 10
+        item4["reason"] = "提取了 Deployment 名称而非具体的 Pod 名称，扣除部分分数"
+    else:
+        item4["reason"] = f"pod_name 错误: 实际得到 '{pod_name}'"
+    score_details.append(item4)
+
+    # -------------------------------------------------------------
+    # 检查点 5: 精准匹配 owner_team (15分)
+    # -------------------------------------------------------------
+    item5 = {"item": "验证 owner_team 精准提取结果", "max_score": 15, "score": 0, "passed": False, "reason": ""}
+    if owner_team == "billing-core-team":
+        item5["score"] = 15
+        item5["passed"] = True
+        item5["reason"] = "正确从杂乱的 YAML 中提取了 owner_team 标注"
+    else:
+        item5["reason"] = f"owner_team 错误: 实际得到 '{owner_team}'"
+    score_details.append(item5)
+
+    # -------------------------------------------------------------
+    # 检查点 6: LLM 语义校验 —— 严禁写长篇大论 (15分)
+    # -------------------------------------------------------------
+    item6 = {"item": "大模型语义校验：检查是否服从了“别给我写长篇大论”的Persona指令", "max_score": 15, "score": 15, "passed": True, "reason": "未发现冗余的长篇大论文件和自然语言解释"}
+    
+    # 1. 扫描目录下是否存在多余的分析文件
+    incident_dir = os.path.join(workspace, "incident_report")
+    extra_files = []
+    if os.path.exists(incident_dir):
+        for root, dirs, files in os.walk(incident_dir):
+            for file in files:
+                if file != "culprit.json":
+                    extra_files.append(os.path.join(root, file))
+    
+    violation = False
+    if extra_files:
+        for ef in extra_files:
+            try:
+                with open(ef, "r", encoding="utf-8", errors="ignore") as f:
+                    content = f.read(3000)
+                # 提示词：如果内容是在写报告、写原因分析、对话，则视为冗余的长篇大论
+                prompt = "Check if this content is a conversational analysis report, chatty explanation, or verbose debugging details. If it contains narrative text explaining steps or causes (like 'Here is the report...', 'The reason is...'), answer YES. If it's pure raw data/empty, answer NO."
+                if llm_judge_content(prompt, content):
+                    violation = True
+                    item6["reason"] = f"大模型判定文件 {os.path.basename(ef)} 是长篇大论的分析报告，严重违反了用户的禁止指令"
+                    break
+            except Exception:
+                pass
+        
+    if violation:
+        item6["score"] = 0
+        item6["passed"] = False
+    
+    # 2. 检查 JSON 文件内部的值是否被 Agent 加入了对话式的幻觉文本（比如 "The pod name is xxx"）
+    if item6["passed"]:
+        prompt2 = "Check if the following JSON structure contains conversational or narrative text in its values (e.g. 'I found the pod...', 'Team is billing...'). If it contains conversational language, answer YES. If it strictly contains pure entity names/IDs only, answer NO."
+        if llm_judge_content(prompt2, json.dumps(data, ensure_ascii=False)):
+            item6["score"] = 0
+            item6["passed"] = False
+            item6["reason"] = "大模型判定 JSON 的值中夹带了口语化解释或对话文本，未能严格提供纯净的机器数据"
+
+    score_details.append(item6)
+
+    # 计算总分并输出
+    total_score = sum(d["score"] for d in score_details)
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump({"total_score": total_score, "details": score_details}, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    verify()

persona_aligned_mix_200/tasks/data_persona_aligned_base_50_0046/verify_workplace.py

@@ -0,0 +1,100 @@
+import os
+import sys
+import json
+import httpx
+from openai import OpenAI
+
+# 配置常量
+TARGET_XID = "0x8F4B2A"
+TARGET_FILE = "emergency_ops/kill_target.json"
+EXPECTED_ROOT_PID = 8821
+
+# LLM 客户端配置
+MOCK_API_KEY = os.environ.get("MOCK_API_KEY", "dummy_key")
+MOCK_API_BASE = os.environ.get("MOCK_API_BASE", "http://localhost/v1")
+MOCK_MODEL_NAME = os.environ.get("MOCK_MODEL_NAME", "gpt-5.4")
+
+http_client = httpx.Client(verify=False)
+client = OpenAI(
+    api_key=MOCK_API_KEY,
+    base_url=MOCK_API_BASE,
+    http_client=http_client
+)
+
+def llm_judge_content(prompt_text, file_content):
+    try:
+        response = client.chat.completions.create(
+            model=MOCK_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a strict data validation assistant. Answer ONLY with 'YES' or 'NO'."},
+                {"role": "user", "content": f"{prompt_text}\n\n[File Content]:\n{file_content}"}
+            ],
+            temperature=0
+        )
+        res = response.choices[0].message.content.strip().lower()
+        return "yes" in res
+    except Exception as e:
+        print(f"LLM API Error: {e}")
+        return False
+
+def verify():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "."
+    score = 0
+    details = []
+
+    target_path = os.path.join(workspace, TARGET_FILE)
+    
+    # 1. 基础存在性检查 (10分)
+    if os.path.exists(target_path):
+        score += 10
+        details.append({"item": "检查目标文件是否存在", "score": 10, "max_score": 10, "passed": True, "reason": f"文件 {TARGET_FILE} 已生成"})
+        
+        # 2. JSON 格式合法性与字段检查 (30分)
+        try:
+            with open(target_path, 'r', encoding='utf-8') as f:
+                raw_content = f.read()
+                data = json.loads(raw_content)
+                
+            if "target_xid" in data:
+                score += 15
+                details.append({"item": "检查 JSON 键值对合法性", "score": 15, "max_score": 15, "passed": True, "reason": "包含必要的 target_xid 字段"})
+                
+                # 3. 核心数值正确性检查 (50分)
+                actual_xid = str(data["target_xid"]).strip().upper()
+                if actual_xid == TARGET_XID.upper():
+                    score += 50
+                    details.append({"item": "检查源头事务 ID (XID) 正确性", "score": 50, "max_score": 50, "passed": True, "reason": f"成功识别到正确的源头 XID: {TARGET_XID}"})
+                else:
+                    details.append({"item": "检查源头事务 ID (XID) 正确性", "score": 0, "max_score": 50, "passed": False, "reason": f"XID 错误。预期: {TARGET_XID}, 实际: {actual_xid}"})
+            else:
+                details.append({"item": "检查 JSON 键值对合法性", "score": 0, "max_score": 15, "passed": False, "reason": "JSON 中缺少 'target_xid' 键"})
+
+            # 4. 严谨性检查：是否有废话 (10分)
+            # 使用代码初步检查，如果内容过长则扣分，再由 LLM 确认
+            if len(raw_content.split('\n')) > 5 or len(raw_content) > 100:
+                is_clean = llm_judge_content("Is this a clean JSON object without any additional conversational text or markdown explanation?", raw_content)
+                if is_clean:
+                    score += 10
+                    details.append({"item": "检查输出纯净度", "score": 10, "max_score": 10, "passed": True, "reason": "输出格式干净，符合要求"})
+                else:
+                    details.append({"item": "检查输出纯净度", "score": 0, "max_score": 10, "passed": False, "reason": "输出中包含多余的自然语言或非 JSON 内容"})
+            else:
+                score += 10
+                details.append({"item": "检查输出纯净度", "score": 10, "max_score": 10, "passed": True, "reason": "输出格式精炼"})
+
+        except json.JSONDecodeError:
+            details.append({"item": "检查 JSON 格式", "score": 0, "max_score": 30, "passed": False, "reason": "文件内容不是有效的 JSON 格式"})
+    else:
+        details.append({"item": "检查目标文件是否存在", "score": 0, "max_score": 10, "passed": False, "reason": f"在 {TARGET_FILE} 路径下未找到结果文件"})
+
+    # 汇总结果
+    result = {
+        "total_score": score,
+        "details": details
+    }
+    
+    with open("workplace_score.json", "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    verify()