from __future__ import annotations import argparse import json import re import string from collections import Counter, defaultdict from pathlib import Path from typing import Iterable from longmemeval_reader_eval import ( FOCUS_TYPES, METHOD_LABELS, ContextEntry, entries_from_full_raw, is_insufficient_answer, load_examples, reconstruct_context, token_f1, ) DEFAULT_RUN_DIR = Path("llm_memory_validation/longmemeval_reader_api_gpt55_answer_supported_focus_full") DEFAULT_OUT_DIR = Path("llm_memory_validation/scoring_audit_gpt55") DEFAULT_DATASET = Path("llm_memory_validation/cache/longmemeval_s_cleaned.json") DEFAULT_RETRIEVAL_ROWS = Path("llm_memory_validation/competitor_run_v2/retrieval_rows.json") ORACLE_METHOD = "dense_budgeted_bsc" FULL_RAW_METHOD = "dense_rag_e5" HIGH_F1_THRESHOLD = 0.5 ARTICLES = {"a", "an", "the"} MONTHS = { "january": "01", "jan": "01", "february": "02", "feb": "02", "march": "03", "mar": "03", "april": "04", "apr": "04", "may": "05", "june": "06", "jun": "06", "july": "07", "jul": "07", "august": "08", "aug": "08", "september": "09", "sep": "09", "sept": "09", "october": "10", "oct": "10", "november": "11", "nov": "11", "december": "12", "dec": "12", } NUMBER_WORDS = { "zero": "0", "one": "1", "two": "2", "three": "3", "four": "4", "five": "5", "six": "6", "seven": "7", "eight": "8", "nine": "9", "ten": "10", "eleven": "11", "twelve": "12", "thirteen": "13", "fourteen": "14", "fifteen": "15", "sixteen": "16", "seventeen": "17", "eighteen": "18", "nineteen": "19", "twenty": "20", } def read_jsonl(path: Path) -> list[dict]: rows: list[dict] = [] with path.open(encoding="utf-8") as handle: for line in handle: stripped = line.strip() if stripped: rows.append(json.loads(stripped)) return rows def load_reader_outputs(run_dir: Path) -> list[dict]: jsonl_path = run_dir / "reader_outputs.jsonl" if jsonl_path.exists(): return read_jsonl(jsonl_path) predictions_path = run_dir / "predictions.json" artifacts = json.loads(predictions_path.read_text(encoding="utf-8")) rows: list[dict] = [] for method_rows in artifacts.values(): rows.extend(method_rows) return rows def strip_parentheticals(text: str) -> str: return re.sub(r"\([^)]*\)", " ", text) def normalize_aliases(text: str) -> str: replacements = [ (r"\bU\.?\s*S\.?\s*A\.?\b", " United States "), (r"\bU\.?\s*S\.?\b", " United States "), (r"\bUnited States of America\b", " United States "), (r"\bU\.?\s*K\.?\b", " United Kingdom "), (r"\bNew York City\b", " NYC "), ] result = text for pattern, repl in replacements: result = re.sub(pattern, repl, result, flags=re.IGNORECASE) return result def normalize_date_mentions(text: str) -> str: text = re.sub(r"\b(\d{1,2})(st|nd|rd|th)\b", r"\1", text, flags=re.IGNORECASE) def month_day_year(match: re.Match[str]) -> str: month = MONTHS[match.group(1).lower()] day = int(match.group(2)) year = match.group(3) if year: return f" {year}-{month}-{day:02d} " return f" {month}-{day:02d} " text = re.sub( r"\b(" + "|".join(MONTHS) + r")\s+(\d{1,2})(?:,\s*|\s+)?(\d{4})?\b", month_day_year, text, flags=re.IGNORECASE, ) def slash_date(match: re.Match[str]) -> str: first = int(match.group(1)) second = int(match.group(2)) year = match.group(3) if year: return f" {year}-{first:02d}-{second:02d} " return f" {first:02d}-{second:02d} " text = re.sub(r"\b(\d{1,2})[/-](\d{1,2})(?:[/-](\d{2,4}))?\b", slash_date, text) return text def normalize_number_words(text: str) -> str: def repl(match: re.Match[str]) -> str: return NUMBER_WORDS[match.group(0).lower()] return re.sub(r"\b(" + "|".join(NUMBER_WORDS) + r")\b", repl, text, flags=re.IGNORECASE) def normalized_answer(text: str) -> str: text = normalize_aliases(str(text)) text = normalize_date_mentions(text) text = normalize_number_words(text) text = text.lower() text = text.translate(str.maketrans("", "", string.punctuation)) tokens = [token for token in text.split() if token not in ARTICLES] return " ".join(tokens) def gold_variants(gold: str) -> list[str]: raw = str(gold).strip() variants = [raw] no_parens = strip_parentheticals(raw).strip() if no_parens and no_parens != raw: variants.append(no_parens) acceptable_split = re.split( r"\.\s*|;\s*|\bis also acceptable\b|\bare also acceptable\b|\balso acceptable\b", no_parens, flags=re.IGNORECASE, ) for part in acceptable_split: part = re.sub(r"\b(including|also)\b.*$", "", part.strip(), flags=re.IGNORECASE).strip() if part: variants.append(part) for sep in [" / ", " or "]: if sep in no_parens.lower(): pattern = re.compile(re.escape(sep), flags=re.IGNORECASE) variants.extend(part.strip() for part in pattern.split(no_parens) if part.strip()) seen: set[str] = set() unique: list[str] = [] for variant in variants: normalized = normalized_answer(variant) if normalized and normalized not in seen: seen.add(normalized) unique.append(variant) return unique def normalized_exact_match(prediction: str, gold: str) -> float: pred_norm = normalized_answer(prediction) if not pred_norm: return 0.0 return float(any(pred_norm == normalized_answer(variant) for variant in gold_variants(gold))) def infer_answer_type(question: str, gold: str) -> str: question_l = str(question).lower() gold_l = str(gold).lower() combined = f"{question_l} {gold_l}" if is_insufficient_answer(gold) or gold_l in {"unknown", "not enough information", "insufficient evidence"}: return "unknown/insufficient" if re.search( r"\b(when|what date|what day|what time|how long|days?|weeks?|months?|years?|" r"monday|tuesday|wednesday|thursday|friday|saturday|sunday|" + "|".join(MONTHS) + r"|\d{1,2}:\d{2}|\d{4})\b", combined, ): return "date/time" if re.search(r"\b(where|location|venue|city|country|state|address|airport|hotel|restaurant|museum|park)\b", combined): return "location" if re.search(r"\b(who|whose|person|name|friend|doctor|teacher|manager|partner|colleague|author|artist|band)\b", combined): return "person/name" if re.search(r"\b(prefer|preference|favorite|favourite|like|love|dislike|allerg|diet|order|want|usually)\b", combined): return "preference" if re.search(r"\b(event|happened|concert|trip|meeting|appointment|flight|visit|party|wedding|first|last|before|after|sequence|order)\b", combined): return "event" if normalized_answer(gold): return "free-form fact" return "unknown/insufficient" def mean(rows: list[dict], field: str) -> float: if not rows: return 0.0 return sum(float(row.get(field, 0.0)) for row in rows) / len(rows) def summarize_rows(rows: list[dict]) -> dict: return { "n": len(rows), "raw_em": mean(rows, "raw_em"), "normalized_em": mean(rows, "normalized_em"), "token_f1": mean(rows, "token_f1"), "evidence_use": mean(rows, "evidence_use"), "insufficient_evidence_rate": mean(rows, "abstained_float"), "unsupported_answer_rate": mean(rows, "unsupported_answer"), "parse_failure_rate": mean(rows, "parse_failure_float"), "gold_evidence_retrieved": mean(rows, "gold_evidence_retrieved_float"), } def enrich_rows(rows: list[dict], examples_by_id: dict[str, dict]) -> list[dict]: enriched: list[dict] = [] for row in rows: example = examples_by_id.get(row.get("question_id"), {}) gold_ids = set(row.get("gold_session_ids", [])) context_ids = set(row.get("context_session_ids", [])) gold_retrieved = bool(gold_ids & context_ids) question = example.get("question", "") gold = row.get("gold_answer", example.get("answer", "")) prediction = row.get("prediction", "") raw_em = float(row.get("exact_match", 0.0)) norm_em = normalized_exact_match(prediction, gold) enriched.append( { **row, "question": question, "gold": gold, "answer": prediction, "raw_em": raw_em, "normalized_em": norm_em, "token_f1": float(row.get("token_f1", token_f1(prediction, gold))), "abstained_float": float(bool(row.get("abstained"))), "parse_failure_float": float(bool(row.get("parse_failure"))), "gold_evidence_retrieved": gold_retrieved, "gold_evidence_retrieved_float": float(gold_retrieved), "gold_recall_in_context": len(gold_ids & context_ids) / max(len(gold_ids), 1), "answer_type": infer_answer_type(question, gold), } ) return enriched def by_method(rows: Iterable[dict]) -> dict[str, list[dict]]: grouped: dict[str, list[dict]] = defaultdict(list) for row in rows: grouped[row["method"]].append(row) return dict(grouped) def answer_type_summary(rows: list[dict]) -> dict: result: dict[str, dict] = {} for method, method_rows in sorted(by_method(rows).items()): type_rows: dict[str, list[dict]] = defaultdict(list) for row in method_rows: type_rows[row["answer_type"]].append(row) result[method] = { "method_label": method_rows[0].get("method_label", METHOD_LABELS.get(method, method)), "answer_types": { answer_type: summarize_rows(type_group) for answer_type, type_group in sorted(type_rows.items()) }, } return result def method_summary(rows: list[dict], focus_types: set[str]) -> dict: summary: dict[str, dict] = {} for method, method_rows in sorted(by_method(rows).items()): focus_rows = [row for row in method_rows if row.get("question_type") in focus_types] summary[method] = { "method_label": method_rows[0].get("method_label", METHOD_LABELS.get(method, method)), "overall": summarize_rows(method_rows), "focus": summarize_rows(focus_rows), } return summary def retrieval_lookup(retrieval_rows: dict[str, list[dict]]) -> dict[str, dict[str, dict]]: return { method: {row["question_id"]: row for row in method_rows} for method, method_rows in retrieval_rows.items() } def raw_context_from_row(row: dict, examples_by_id: dict[str, dict]) -> list[ContextEntry]: example = examples_by_id.get(row.get("question_id"), {}) full_raw = entries_from_full_raw(example) if example else {} return [full_raw[session_id] for session_id in row.get("context_session_ids", []) if session_id in full_raw] def context_for_row( row: dict, contexts: dict[tuple[str, str], list[ContextEntry]], examples_by_id: dict[str, dict], retrieval_by_method: dict[str, dict[str, dict]], budget_frac: float, max_context_words: int, ) -> list[ContextEntry]: key = (row["method"], row["question_id"]) if key in contexts: return contexts[key] example = examples_by_id.get(row["question_id"]) retrieval_row = retrieval_by_method.get(row["method"], {}).get(row["question_id"]) if example is not None and retrieval_row is not None: context, _fallbacks = reconstruct_context( example, retrieval_row, row["method"], budget_frac, max_context_words, ) else: context = raw_context_from_row(row, examples_by_id) contexts[key] = context return context def memories_for_row( row: dict, contexts: dict[tuple[str, str], list[ContextEntry]], examples_by_id: dict[str, dict], retrieval_by_method: dict[str, dict[str, dict]], budget_frac: float, max_context_words: int, max_chars: int, ) -> list[dict]: context = context_for_row( row, contexts, examples_by_id, retrieval_by_method, budget_frac, max_context_words, ) gold_ids = set(row.get("gold_session_ids", [])) used_ids = set(row.get("used_memory_ids", [])) memories = [] for entry in context: memories.append( { "memory_id": entry.session_id, "action": entry.action, "source": entry.source, "is_gold_evidence": entry.session_id in gold_ids, "used_by_reader": entry.session_id in used_ids, "text": entry.text[:max_chars], } ) return memories def sample_payload( row: dict, audit_category: str, contexts: dict[tuple[str, str], list[ContextEntry]], examples_by_id: dict[str, dict], retrieval_by_method: dict[str, dict[str, dict]], budget_frac: float, max_context_words: int, max_memory_chars: int, paired_row: dict | None = None, ) -> dict: payload = { "audit_category": audit_category, "question_id": row.get("question_id"), "question_type": row.get("question_type"), "answer_type": row.get("answer_type"), "question": row.get("question", ""), "gold": row.get("gold", row.get("gold_answer", "")), "method": row.get("method"), "method_label": row.get("method_label", METHOD_LABELS.get(row.get("method", ""), row.get("method", ""))), "answer": row.get("answer", row.get("prediction", "")), "retrieved_memories": memories_for_row( row, contexts, examples_by_id, retrieval_by_method, budget_frac, max_context_words, max_memory_chars, ), "used_memory_ids": row.get("used_memory_ids", []), "raw_em": row.get("raw_em", 0.0), "normalized_em": row.get("normalized_em", 0.0), "f1": row.get("token_f1", 0.0), "gold_evidence_retrieved": bool(row.get("gold_evidence_retrieved")), "gold_recall_in_context": row.get("gold_recall_in_context", 0.0), "evidence_use": row.get("evidence_use", 0.0), "abstained": bool(row.get("abstained")), "unsupported_answer": row.get("unsupported_answer", 0.0), "gold_session_ids": row.get("gold_session_ids", []), "context_session_ids": row.get("context_session_ids", []), } if paired_row is not None: payload["paired_full_raw"] = { "method": paired_row.get("method"), "method_label": paired_row.get("method_label", METHOD_LABELS.get(paired_row.get("method", ""), "")), "answer": paired_row.get("answer", paired_row.get("prediction", "")), "raw_em": paired_row.get("raw_em", 0.0), "normalized_em": paired_row.get("normalized_em", 0.0), "f1": paired_row.get("token_f1", 0.0), "gold_evidence_retrieved": bool(paired_row.get("gold_evidence_retrieved")), "evidence_use": paired_row.get("evidence_use", 0.0), "abstained": bool(paired_row.get("abstained")), "used_memory_ids": paired_row.get("used_memory_ids", []), "context_session_ids": paired_row.get("context_session_ids", []), } return payload def select_top(rows: list[dict], limit: int, used_keys: set[tuple[str, str]], key_fn) -> list[dict]: selected: list[dict] = [] for row in sorted(rows, key=key_fn): row_key = (row["method"], row["question_id"]) if row_key in used_keys: continue selected.append(row) used_keys.add(row_key) if len(selected) >= limit: break return selected def build_balanced_sample( rows: list[dict], contexts: dict[tuple[str, str], list[ContextEntry]], examples_by_id: dict[str, dict], retrieval_by_method: dict[str, dict[str, dict]], budget_frac: float, max_context_words: int, max_memory_chars: int, ) -> tuple[list[dict], dict]: rows_by_method = by_method(rows) oracle_rows = rows_by_method.get(ORACLE_METHOD, []) full_rows = rows_by_method.get(FULL_RAW_METHOD, []) full_by_qid = {row["question_id"]: row for row in full_rows} used_keys: set[tuple[str, str]] = set() sample_rows: list[dict] = [] category_counts: dict[str, int] = {} category = "oraclemem_abstained_despite_support" selected = select_top( [ row for row in oracle_rows if row.get("gold_evidence_retrieved") and row.get("abstained") ], 20, used_keys, key_fn=lambda row: (row.get("question_type", ""), row.get("question_id", "")), ) category_counts[category] = len(selected) sample_rows.extend( sample_payload( row, category, contexts, examples_by_id, retrieval_by_method, budget_frac, max_context_words, max_memory_chars, ) for row in selected ) category = "oraclemem_high_f1_em0" selected = select_top( [ row for row in oracle_rows if row.get("raw_em", 0.0) == 0.0 and row.get("token_f1", 0.0) >= HIGH_F1_THRESHOLD and not row.get("abstained") ], 10, used_keys, key_fn=lambda row: (-row.get("token_f1", 0.0), row.get("question_id", "")), ) category_counts[category] = len(selected) sample_rows.extend( sample_payload( row, category, contexts, examples_by_id, retrieval_by_method, budget_frac, max_context_words, max_memory_chars, ) for row in selected ) category = "full_raw_high_f1_em0" selected = select_top( [ row for row in full_rows if row.get("raw_em", 0.0) == 0.0 and row.get("token_f1", 0.0) >= HIGH_F1_THRESHOLD and not row.get("abstained") ], 10, used_keys, key_fn=lambda row: (-row.get("token_f1", 0.0), row.get("question_id", "")), ) category_counts[category] = len(selected) sample_rows.extend( sample_payload( row, category, contexts, examples_by_id, retrieval_by_method, budget_frac, max_context_words, max_memory_chars, ) for row in selected ) category = "oraclemem_full_raw_disagreement" disagreement_rows: list[tuple[float, dict, dict]] = [] used_question_ids = {row["question_id"] for row in sample_rows} for oracle in oracle_rows: full = full_by_qid.get(oracle["question_id"]) if full is None or oracle["question_id"] in used_question_ids: continue abstain_diff = float(bool(oracle.get("abstained")) != bool(full.get("abstained"))) norm_diff = float(oracle.get("normalized_em", 0.0) != full.get("normalized_em", 0.0)) evidence_diff = abs(float(oracle.get("evidence_use", 0.0)) - float(full.get("evidence_use", 0.0))) f1_diff = abs(float(oracle.get("token_f1", 0.0)) - float(full.get("token_f1", 0.0))) score = 2.0 * abstain_diff + norm_diff + evidence_diff + f1_diff if score > 0.0: disagreement_rows.append((score, oracle, full)) disagreement_rows.sort(key=lambda item: (-item[0], item[1].get("question_type", ""), item[1].get("question_id", ""))) selected_pairs = disagreement_rows[:10] category_counts[category] = len(selected_pairs) for _score, oracle, full in selected_pairs: sample_rows.append( sample_payload( oracle, category, contexts, examples_by_id, retrieval_by_method, budget_frac, max_context_words, max_memory_chars, paired_row=full, ) ) return sample_rows, category_counts def normalization_deltas(rows: list[dict], limit: int = 25) -> list[dict]: changed = [ row for row in rows if row.get("normalized_em", 0.0) > row.get("raw_em", 0.0) ] changed.sort(key=lambda row: (row.get("method", ""), row.get("question_id", ""))) return [ { "question_id": row.get("question_id"), "question_type": row.get("question_type"), "answer_type": row.get("answer_type"), "method": row.get("method"), "method_label": row.get("method_label"), "gold": row.get("gold"), "prediction": row.get("prediction"), "raw_em": row.get("raw_em"), "normalized_em": row.get("normalized_em"), "token_f1": row.get("token_f1"), } for row in changed[:limit] ] def write_jsonl(path: Path, rows: list[dict]) -> None: with path.open("w", encoding="utf-8") as handle: for row in rows: handle.write(json.dumps(row, ensure_ascii=True) + "\n") def format_rate(value: float) -> str: return f"{value:.4f}" def write_report(path: Path, audit: dict) -> None: lines = [ "# GPT-5.5 Scoring Audit", "", f"- Input run: `{audit['input_run_dir']}`", f"- Rows audited: `{audit['n_rows']}`", "- Scope: existing frozen-context GPT-5.5 reader outputs only; no new model calls.", "- Optional semantic judge: not run, because no cached judge outputs were present and the task asked not to spend on full benchmark judging.", "", "## Normalized Scoring", "", "Normalized EM lowercases, strips punctuation and articles, collapses whitespace, canonicalizes simple date mentions, maps number words zero to twenty to digits, and handles a small alias set (US/USA, UK, NYC). Gold labels with explicit acceptable alternatives are split into deterministic variants.", "", "| Method | Raw EM | Normalized EM | Token F1 | Evidence use | Insuff. | Gold retrieved |", "|---|---:|---:|---:|---:|---:|---:|", ] for method, row in audit["method_summary"].items(): focus = row["focus"] lines.append( f"| {row['method_label']} | {format_rate(focus['raw_em'])} | " f"{format_rate(focus['normalized_em'])} | {format_rate(focus['token_f1'])} | " f"{format_rate(focus['evidence_use'])} | {format_rate(focus['insufficient_evidence_rate'])} | " f"{format_rate(focus['gold_evidence_retrieved'])} |" ) lines.extend( [ "", "## Answer-Type Analysis", "", "| Method | Answer type | n | Raw EM | Normalized EM | Token F1 | Evidence use | Insuff. |", "|---|---|---:|---:|---:|---:|---:|---:|", ] ) for _method, method_row in audit["answer_type_analysis"].items(): for answer_type, metrics in method_row["answer_types"].items(): lines.append( f"| {method_row['method_label']} | {answer_type} | {metrics['n']} | " f"{format_rate(metrics['raw_em'])} | {format_rate(metrics['normalized_em'])} | " f"{format_rate(metrics['token_f1'])} | {format_rate(metrics['evidence_use'])} | " f"{format_rate(metrics['insufficient_evidence_rate'])} |" ) lines.extend( [ "", "## Balanced Audit Sample", "", f"- Sample path: `{audit['sample_path']}`", f"- Total rows: `{audit['sample_summary']['n']}`", "", "| Category | Rows |", "|---|---:|", ] ) for category, count in audit["sample_summary"]["category_counts"].items(): lines.append(f"| `{category}` | {count} |") delta_count = len(audit["normalization_delta_examples"]) lines.extend( [ "", "## Interpretation", "", f"- Normalized EM changes {audit['normalization_changed_count']} of {audit['n_rows']} method-question rows; the first {delta_count} changed examples are stored in `normalized_scoring_v2.json`.", "- Normalization materially raises absolute EM for OracleMem and full raw, mainly for explicit acceptable duration labels and number-word/date formatting.", "- The OracleMem/full-raw normalized-EM gap remains modest; the strongest external signal is still OracleMem's higher token-F1 and evidence-use.", "- The balanced sample is intended for a human or cheap blinded judge pass: it separates supported abstentions, high-overlap EM failures, full-raw EM failures, and OracleMem/full-raw disagreements.", ] ) path.write_text("\n".join(lines) + "\n", encoding="utf-8") def main() -> None: parser = argparse.ArgumentParser(description="Audit GPT-5.5 LongMemEval reader scoring.") parser.add_argument("--run-dir", type=Path, default=DEFAULT_RUN_DIR) parser.add_argument("--out-dir", type=Path, default=DEFAULT_OUT_DIR) parser.add_argument("--dataset-json", type=Path, default=DEFAULT_DATASET) parser.add_argument("--retrieval-rows-json", type=Path, default=DEFAULT_RETRIEVAL_ROWS) parser.add_argument("--budget-frac", type=float, default=0.20) parser.add_argument("--max-context-words", type=int, default=1800) parser.add_argument("--max-memory-chars", type=int, default=900) parser.add_argument("--focus-types", type=str, default=",".join(sorted(FOCUS_TYPES))) args = parser.parse_args() focus_types = {part.strip() for part in args.focus_types.split(",") if part.strip()} args.out_dir.mkdir(parents=True, exist_ok=True) examples = load_examples(args.dataset_json, None) examples_by_id = {example["question_id"]: example for example in examples} reader_rows = load_reader_outputs(args.run_dir) enriched = enrich_rows(reader_rows, examples_by_id) retrieval_rows = json.loads(args.retrieval_rows_json.read_text(encoding="utf-8")) retrieval_by_method = retrieval_lookup(retrieval_rows) contexts: dict[tuple[str, str], list[ContextEntry]] = {} sample, category_counts = build_balanced_sample( enriched, contexts, examples_by_id, retrieval_by_method, args.budget_frac, args.max_context_words, args.max_memory_chars, ) sample_path = args.out_dir / "semantic_audit_sample_50.jsonl" write_jsonl(sample_path, sample) deltas = normalization_deltas(enriched) audit = { "input_run_dir": str(args.run_dir), "dataset_json": str(args.dataset_json), "retrieval_rows_json": str(args.retrieval_rows_json), "n_rows": len(enriched), "focus_types": sorted(focus_types), "normalization_definition": { "lowercase": True, "strip_punctuation": True, "strip_articles": sorted(ARTICLES), "collapse_whitespace": True, "date_normalization": "month-name dates and simple slash/dash dates are canonicalized when detectable", "number_word_normalization": "zero through twenty are mapped to digits", "aliases": ["US/USA -> United States", "UK -> United Kingdom", "New York City -> NYC"], "gold_variants": "explicit acceptable alternatives and parenthetical-free variants are considered", }, "method_summary": method_summary(enriched, focus_types), "answer_type_analysis": answer_type_summary(enriched), "normalization_changed_count": sum( 1 for row in enriched if row.get("normalized_em", 0.0) > row.get("raw_em", 0.0) ), "normalization_delta_examples": deltas, "sample_summary": { "n": len(sample), "category_counts": category_counts, "balance_target": { "oraclemem_abstained_despite_support": 20, "oraclemem_high_f1_em0": 10, "full_raw_high_f1_em0": 10, "oraclemem_full_raw_disagreement": 10, }, }, "sample_path": str(sample_path), "semantic_judge": { "used": False, "reason": "No cached judge outputs were present; no new API judge calls were made.", }, } json_path = args.out_dir / "normalized_scoring_v2.json" json_path.write_text(json.dumps(audit, indent=2, ensure_ascii=True), encoding="utf-8") write_report(args.out_dir / "SCORING_AUDIT.md", audit) print(json.dumps({"wrote": [str(json_path), str(sample_path), str(args.out_dir / "SCORING_AUDIT.md")]}, indent=2)) if __name__ == "__main__": main()