"""Audit OracleMem artifacts for evidence-unit and coverage completeness. This is a lightweight structural audit. It does not judge annotation quality; it checks whether artifacts expose the fields needed for a non-synthetic OracleMem coverage package: * evidence units; * query-to-unit requirements; * candidate memories with costs and groups; * candidate-by-unit coverage rows. Existing LongMemEval artifacts are expected to be session-evidence diagnostics, not full coverage matrices. The report makes that boundary explicit. """ from __future__ import annotations import argparse import json from collections import Counter from dataclasses import asdict, dataclass, field from pathlib import Path from typing import Any, Iterable DEFAULT_ARTIFACTS: tuple[tuple[str, str, str], ...] = ( ( "oraclemem_exact_500_results", "oraclemem_runs/exact_500/raw_results.jsonl", "Synthetic exact result rows; selected ids and metrics, not full matrix.", ), ( "oraclemem_stress_exact_500_results", "oraclemem_runs/stress_exact_500/raw_results.jsonl", "Synthetic stress result rows; selected ids and metrics, not full matrix.", ), ( "oraclemem_decomp_det_300_summary", "oraclemem_runs/decomp_det_300/summary.json", "Synthetic deterministic decomposition summary.", ), ( "longmemeval_retrieval_rows", "llm_memory_validation/competitor_run_v2/retrieval_rows.json", "LongMemEval-S retrieval rows with coarse gold session ids.", ), ( "longmemeval_focus_summary", "llm_memory_validation/longmemeval_focus_report_core4/summary.json", "LongMemEval-S retrieval report summary.", ), ( "gpt55_reader_outputs", "llm_memory_validation/longmemeval_reader_api_gpt55_answer_supported_focus_full/reader_outputs.jsonl", "Frozen-context GPT-5.5 reader outputs.", ), ( "gpt55_error_audit_rows", "llm_memory_validation/longmemeval_reader_api_gpt55_answer_supported_focus_full/error_audit_rows.jsonl", "Reader error audit rows.", ), ( "gpt55_reader_semantic_sample", "llm_memory_validation/longmemeval_reader_api_gpt55_answer_supported_focus_full/semantic_audit_sample_50.jsonl", "Reader semantic audit sample.", ), ( "gpt55_scoring_audit_summary", "llm_memory_validation/scoring_audit_gpt55/normalized_scoring_v2.json", "Normalized scoring audit summary.", ), ( "gpt55_scoring_audit_sample", "llm_memory_validation/scoring_audit_gpt55/semantic_audit_sample_50.jsonl", "Balanced human/judge scoring audit sample.", ), ) UNIT_KEYS = {"unit_id", "evidence_unit_id"} UNIT_CONTAINER_KEYS = {"units", "evidence_units"} QUERY_ID_KEYS = {"query_id", "question_id"} UNIT_REQUIREMENT_KEYS = {"required_unit_ids", "required_units"} SESSION_REQUIREMENT_KEYS = {"answer_session_ids", "gold_session_ids"} CANDIDATE_KEYS = {"candidate_id"} SELECTED_CANDIDATE_KEYS = {"selected_candidate_ids"} CANDIDATE_DETAIL_KEYS = { "candidate_id", "experience_id", "candidate_group", "representation_type", "representation", "text", "serialized", "cost", "cost_tokens", } COVERAGE_KEYS = {"coverage", "coverage_label", "fidelity"} COVERAGE_SUMMARY_KEYS = { "update_metrics", "retrieval_metrics", "retrieval_summary", "gold_recall_in_context", "evidence_use", "support_in_context", "retrieved_at_5", } CONTEXT_KEYS = {"context_session_ids", "used_memory_ids", "retrieved_memories"} PACKAGE_FILE_ALIASES: tuple[tuple[str, tuple[str, ...]], ...] = ( ("manifest", ("candidate_generation_manifest.json", "manifest.json")), ("evidence_units", ("evidence_units.jsonl",)), ("queries", ("queries.jsonl",)), ("experiences", ("experiences.jsonl",)), ("candidate_memories", ("candidate_memories.jsonl",)), ("coverage_matrix", ("coverage_matrix.jsonl",)), ("annotation_decisions", ("annotation_decisions.jsonl",)), ) @dataclass class ArtifactAudit: name: str path: str role: str exists: bool format: str = "missing" row_count: int = 0 sampled_rows: int = 0 key_counts: dict[str, int] = field(default_factory=dict) signals: dict[str, bool] = field(default_factory=dict) completeness: dict[str, float] = field(default_factory=dict) statuses: dict[str, str] = field(default_factory=dict) gaps: list[str] = field(default_factory=list) errors: list[str] = field(default_factory=list) package_files: dict[str, bool] = field(default_factory=dict) def _load_json(path: Path, sample_rows: int) -> tuple[str, int, list[dict[str, Any]]]: data = json.loads(path.read_text(encoding="utf-8")) records: list[dict[str, Any]] = [] row_count = 0 if isinstance(data, list): row_count = len(data) records = [row for row in data[:sample_rows] if isinstance(row, dict)] return "json_list", row_count, records if isinstance(data, dict): list_values = { key: value for key, value in data.items() if isinstance(value, list) and value and all(isinstance(item, dict) for item in value[:5]) } if list_values: for key, rows in list_values.items(): row_count += len(rows) remaining = max(0, sample_rows - len(records)) if remaining: for row in rows[:remaining]: item = dict(row) item["_container_key"] = key records.append(item) return "json_dict_of_lists", row_count, records records = [data] return "json_object", 1, records return type(data).__name__, 1, [] def _load_jsonl(path: Path, sample_rows: int) -> tuple[str, int, list[dict[str, Any]]]: records: list[dict[str, Any]] = [] row_count = 0 with path.open("r", encoding="utf-8") as handle: for line_number, line in enumerate(handle, start=1): stripped = line.strip() if not stripped: continue row_count += 1 if len(records) >= sample_rows: continue try: row = json.loads(stripped) except json.JSONDecodeError as exc: raise ValueError(f"bad JSONL at line {line_number}: {exc}") from exc if isinstance(row, dict): records.append(row) return "jsonl", row_count, records def _load_records(path: Path, sample_rows: int) -> tuple[str, int, list[dict[str, Any]]]: if path.is_dir(): records: list[dict[str, Any]] = [] row_count = 0 per_file_sample = max(1, sample_rows // max(1, len(PACKAGE_FILE_ALIASES))) for label, child_names in PACKAGE_FILE_ALIASES: child = next((path / child_name for child_name in child_names if (path / child_name).exists()), None) if child is None: continue if len(records) >= sample_rows: remaining = per_file_sample else: remaining = max(per_file_sample, sample_rows - len(records)) child_format, child_count, child_records = _load_records(child, remaining) row_count += child_count for record in child_records[:remaining]: item = dict(record) item["_container_key"] = label item["_container_file"] = child.name item["_container_format"] = child_format records.append(item) return "coverage_package_dir", row_count, records suffix = path.suffix.lower() if suffix == ".jsonl": return _load_jsonl(path, sample_rows) if suffix == ".json": return _load_json(path, sample_rows) if suffix == ".md": return "markdown", 1, [{"text": path.read_text(encoding="utf-8", errors="replace")}] return suffix.lstrip(".") or "unknown", 0, [] def _package_file_presence(path: Path) -> dict[str, bool]: if not path.is_dir(): return {} return { label: any((path / child_name).exists() for child_name in child_names) for label, child_names in PACKAGE_FILE_ALIASES } def _all_keys(records: Iterable[dict[str, Any]]) -> Counter[str]: counts: Counter[str] = Counter() for record in records: for key in record: counts[str(key)] += 1 return counts def _has_any_key(records: list[dict[str, Any]], keys: set[str]) -> bool: return any(any(key in record for key in keys) for record in records) def _has_nested_container(records: list[dict[str, Any]], keys: set[str]) -> bool: for record in records: for key in keys: value = record.get(key) if isinstance(value, list) and value: return True if isinstance(value, dict) and value: return True return False def _fraction_with(records: list[dict[str, Any]], keys: set[str]) -> float: if not records: return 0.0 return sum(1 for record in records if any(key in record for key in keys)) / len(records) def _candidate_detail_signal(records: list[dict[str, Any]]) -> bool: for record in records: if not any(key in record for key in CANDIDATE_KEYS): continue has_experience = "experience_id" in record has_rep = "representation_type" in record or "representation" in record has_text = "text" in record or "serialized" in record has_cost = "cost" in record or "cost_tokens" in record if has_experience and has_rep and has_text and has_cost: return True return False def _coverage_matrix_signal(records: list[dict[str, Any]]) -> bool: for record in records: if "coverage" in record and ( "candidate_id" in record or "experience_id" in record or "unit_id" in record or "evidence_unit_id" in record ): return True if "candidate_id" in record and ("unit_id" in record or "evidence_unit_id" in record): if any(key in record for key in COVERAGE_KEYS): return True return False def _invalid_coverage_rows(records: list[dict[str, Any]]) -> int: invalid = 0 for record in records: if "coverage" not in record: continue coverage = record["coverage"] values: list[Any] = [] if isinstance(coverage, dict): values.extend(coverage.values()) elif isinstance(coverage, list): for item in coverage: if isinstance(item, dict): values.append(item.get("coverage", item.get("fidelity"))) else: values.append(item) else: values.append(coverage) for value in values: try: numeric = float(value) except (TypeError, ValueError): invalid += 1 continue if numeric < 0.0 or numeric > 1.0: invalid += 1 return invalid def _status_and_gaps(signals: dict[str, bool], invalid_coverage_rows: int) -> tuple[dict[str, str], list[str]]: statuses: dict[str, str] = {} gaps: list[str] = [] if signals["unit_level_evidence"]: statuses["evidence_units"] = "unit-level present" elif signals["session_level_evidence"]: statuses["evidence_units"] = "session-level only" gaps.append("No explicit evidence_units/unit_id records; evidence is coarse session id support.") else: statuses["evidence_units"] = "missing" gaps.append("No evidence-unit or session-level gold evidence ids detected.") if signals["unit_query_requirements"]: statuses["query_requirements"] = "unit requirements present" elif signals["session_query_requirements"]: statuses["query_requirements"] = "session ids only" gaps.append("No required_unit_ids detected for query-level semantic coverage.") else: statuses["query_requirements"] = "missing" gaps.append("No query requirement fields detected.") if signals["candidate_details"]: statuses["candidate_memories"] = "candidate records present" elif signals["selected_candidate_ids"]: statuses["candidate_memories"] = "selected ids only" gaps.append("Selected candidate ids are present, but candidate texts/costs/coverage are not serialized here.") elif signals["retrieved_context"]: statuses["candidate_memories"] = "retrieved context only" gaps.append("Retrieved/context memories are present, but not finite write-choice candidates.") else: statuses["candidate_memories"] = "missing" gaps.append("No candidate-memory records detected.") if signals["coverage_matrix"]: statuses["coverage_matrix"] = "candidate-unit coverage present" elif signals["coverage_summaries"]: statuses["coverage_matrix"] = "summary metrics only" gaps.append("Coverage/evidence appears only as aggregate or reader/retrieval metrics.") else: statuses["coverage_matrix"] = "missing" gaps.append("No candidate-by-evidence coverage matrix detected.") if invalid_coverage_rows: gaps.append(f"Sample contains {invalid_coverage_rows} coverage values outside [0, 1] or nonnumeric.") full_ready = ( signals["unit_level_evidence"] and signals["unit_query_requirements"] and signals["candidate_details"] and signals["coverage_matrix"] and invalid_coverage_rows == 0 ) synthetic_result_only = signals["exact_ratio"] and signals["selected_candidate_ids"] and not signals["coverage_matrix"] session_diagnostic = signals["session_level_evidence"] and not signals["unit_query_requirements"] if full_ready: statuses["oracle_denominator"] = "machine-checkable coverage package" elif synthetic_result_only: statuses["oracle_denominator"] = "result rows only; regenerate/serialize hidden synthetic instance for matrix audit" elif session_diagnostic: statuses["oracle_denominator"] = "not exact OracleMem; session-evidence diagnostic" else: statuses["oracle_denominator"] = "not coverage-ready" return statuses, gaps def audit_artifact(name: str, path: Path, role: str, sample_rows: int) -> ArtifactAudit: audit = ArtifactAudit(name=name, path=str(path), role=role, exists=path.exists()) if not path.exists(): audit.errors.append("missing path") audit.gaps.append("Artifact path does not exist.") return audit audit.package_files = _package_file_presence(path) try: fmt, row_count, records = _load_records(path, sample_rows) except Exception as exc: audit.errors.append(str(exc)) audit.gaps.append("Could not parse artifact.") return audit key_counts = _all_keys(records) invalid_coverage_rows = _invalid_coverage_rows(records) signals = { "unit_level_evidence": _has_any_key(records, UNIT_KEYS) or _has_nested_container(records, UNIT_CONTAINER_KEYS), "session_level_evidence": _has_any_key(records, SESSION_REQUIREMENT_KEYS), "unit_query_requirements": _has_any_key(records, UNIT_REQUIREMENT_KEYS), "session_query_requirements": _has_any_key(records, SESSION_REQUIREMENT_KEYS), "candidate_details": _candidate_detail_signal(records), "selected_candidate_ids": _has_any_key(records, SELECTED_CANDIDATE_KEYS), "coverage_matrix": _coverage_matrix_signal(records), "coverage_summaries": _has_any_key(records, COVERAGE_SUMMARY_KEYS), "retrieved_context": _has_any_key(records, CONTEXT_KEYS), "exact_ratio": _has_any_key(records, {"ratio_to_opt", "denominator_label", "optimum_value"}), } statuses, gaps = _status_and_gaps(signals, invalid_coverage_rows) if audit.package_files: missing_package_files = [ label for label, present in audit.package_files.items() if not present ] if missing_package_files: statuses["oracle_denominator"] = "not coverage-ready" gaps.append( "Coverage package directory is missing required files: " + ", ".join(missing_package_files) + "." ) audit.format = fmt audit.row_count = row_count audit.sampled_rows = len(records) audit.key_counts = dict(sorted(key_counts.items())) audit.signals = signals audit.completeness = { "sample_with_unit_ids": _fraction_with(records, UNIT_KEYS), "sample_with_required_unit_ids": _fraction_with(records, UNIT_REQUIREMENT_KEYS), "sample_with_gold_or_answer_session_ids": _fraction_with(records, SESSION_REQUIREMENT_KEYS), "sample_with_candidate_ids": _fraction_with(records, CANDIDATE_KEYS), "sample_with_selected_candidate_ids": _fraction_with(records, SELECTED_CANDIDATE_KEYS), "sample_with_coverage": _fraction_with(records, {"coverage"}), "sample_with_context_or_used_ids": _fraction_with(records, CONTEXT_KEYS), } audit.statuses = statuses audit.gaps = gaps return audit def _parse_artifact_arg(value: str) -> tuple[str, str, str]: if "=" in value: name, raw_path = value.split("=", 1) return name.strip(), raw_path.strip(), "User-specified artifact." path = Path(value) return path.stem, value, "User-specified artifact." def _markdown_table_row(audit: ArtifactAudit) -> str: gap = audit.gaps[0] if audit.gaps else "No structural gap detected." return ( f"| `{audit.name}` | {audit.row_count} | " f"{audit.statuses.get('evidence_units', 'missing')} | " f"{audit.statuses.get('query_requirements', 'missing')} | " f"{audit.statuses.get('candidate_memories', 'missing')} | " f"{audit.statuses.get('coverage_matrix', 'missing')} | " f"{audit.statuses.get('oracle_denominator', 'not coverage-ready')} | " f"{gap} |" ) def render_report(audits: list[ArtifactAudit]) -> str: ready = [ audit for audit in audits if audit.statuses.get("oracle_denominator") == "machine-checkable coverage package" ] lines = [ "# Coverage Artifact Audit", "", "This report checks whether existing artifacts expose the machine-readable fields needed for non-synthetic OracleMem coverage annotation. It is a structural audit only; it does not certify semantic label quality.", "", "## Verdict", "", ] if ready: names = ", ".join(f"`{audit.name}`" for audit in ready) lines.append(f"Coverage-ready package candidates detected: {names}.") else: lines.append( "No audited current artifact is a complete non-synthetic coverage package. Existing LongMemEval artifacts remain session-level retrieval/reader/scoring diagnostics; synthetic result rows rely on generator code for hidden coverage and do not serialize a full matrix in the result files." ) lines.extend( [ "", "## Artifact Matrix", "", "| Artifact | Rows | Evidence | Query Requirements | Candidates | Coverage | Denominator Status | First Gap |", "| --- | ---: | --- | --- | --- | --- | --- | --- |", ] ) for audit in audits: lines.append(_markdown_table_row(audit)) lines.extend( [ "", "## Completeness Signals", "", "| Artifact | Sampled | Unit IDs | Required Units | Gold Sessions | Candidate IDs | Selected IDs | Coverage | Context/Used IDs |", "| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |", ] ) for audit in audits: c = audit.completeness lines.append( f"| `{audit.name}` | {audit.sampled_rows} | " f"{c.get('sample_with_unit_ids', 0.0):.3f} | " f"{c.get('sample_with_required_unit_ids', 0.0):.3f} | " f"{c.get('sample_with_gold_or_answer_session_ids', 0.0):.3f} | " f"{c.get('sample_with_candidate_ids', 0.0):.3f} | " f"{c.get('sample_with_selected_candidate_ids', 0.0):.3f} | " f"{c.get('sample_with_coverage', 0.0):.3f} | " f"{c.get('sample_with_context_or_used_ids', 0.0):.3f} |" ) lines.extend( [ "", "## Acceptance Gate", "", "Synthetic exact-small OracleMem instances can be exported for structural inspection with `python run_oraclemem_mvp.py --export-coverage-matrices`; pass an exported package directory to this script with `--artifact name=path/to/coverage_instances/base/seed_0`.", "", "To upgrade a non-synthetic LongMemEval/LoCoMo-style artifact from diagnostic to exact OracleMem coverage, add the package described in `COVERAGE_VALIDATION_PROTOCOL.md`: `evidence_units.jsonl`, `queries.jsonl` with `required_unit_ids`, `candidate_memories.jsonl`, `coverage_matrix.jsonl`, annotation decisions, and a candidate-generation manifest.", "", "Hard blockers for non-synthetic coverage are 100% schema completeness for eval queries, evidence units, positive coverage rows, candidate groups/costs, no future-source coverage, no generator leakage, and solver inputs derivable from the artifacts without hidden code defaults.", "", "| Acceptance item | Required threshold |", "| --- | ---: |", "| Eval queries with answer/category/session ids/adjudicated required units | 100% |", "| Required unit ids resolvable in `evidence_units.jsonl` | 100% |", "| Evidence units source-backed and adjudication resolved | 100% |", "| Positive coverage rows valid, sourced, rationalized, resolved | 100% |", "| Candidate groups, representation types, text, and costs valid | 100% |", "| Future-source coverage leakage | 0 rows |", "| Forbidden generator inputs leaked | 0 records |", "| Binary coverage agreement before adjudication | kappa >= 0.70 |", "| None/partial/full coverage agreement before adjudication | weighted kappa >= 0.60 |", "| Unit candidate availability at coverage >= 0.75 | >= 0.95 |", "| Query feasible support before budget | >= 0.90 |", "| Update/current-truth support for validity claims | >= 0.90 |", "| Hallucinated coverage after adjudication | 0 rows |", ] ) return "\n".join(lines) + "\n" def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument( "--output-dir", type=Path, default=Path("llm_memory_validation/coverage_artifact_audit"), ) parser.add_argument( "--artifact", action="append", default=[], help="Additional artifact as name=path or path. Can be repeated.", ) parser.add_argument("--no-defaults", action="store_true") parser.add_argument("--sample-rows", type=int, default=5000) args = parser.parse_args() specs: list[tuple[str, str, str]] = [] if not args.no_defaults: specs.extend(DEFAULT_ARTIFACTS) specs.extend(_parse_artifact_arg(value) for value in args.artifact) if not specs: raise SystemExit("No artifacts to audit.") audits = [ audit_artifact(name, Path(path), role, sample_rows=args.sample_rows) for name, path, role in specs ] payload = { "schema_version": 1, "sample_rows": args.sample_rows, "coverage_ready_artifacts": [ audit.name for audit in audits if audit.statuses.get("oracle_denominator") == "machine-checkable coverage package" ], "artifacts": [asdict(audit) for audit in audits], } args.output_dir.mkdir(parents=True, exist_ok=True) (args.output_dir / "summary.json").write_text( json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8", ) (args.output_dir / "REPORT.md").write_text(render_report(audits), encoding="utf-8") print(json.dumps(payload, indent=2, sort_keys=True)) if __name__ == "__main__": main()