scripts/build_no_api_realism_report.py

"""Build a no-API realism report from existing OracleMem artifacts.



The report intentionally separates three evidence layers:



* exact-small synthetic oracle evidence, including deployable local baselines;

* cached LongMemEval-S retrieval/reader diagnostics, with no OPT denominator;

* the structural blocker for true non-synthetic OracleMem coverage evidence.



This script reads local JSON artifacts only. It never imports or calls API

reader code.

"""

from __future__ import annotations

import argparse
import datetime as _dt
import json
from pathlib import Path
from typing import Any


ROOT = Path(__file__).resolve().parents[1]

METHOD_LABELS = {
    "amac_admission": "A-MAC-style admission",
    "memgpt_tiered": "MemGPT-style tiered",
    "mem0_extract": "Mem0-style extraction",
    "generic_candidate_opt": "Generic-candidate OPT",
    "no_tombstone_opt": "No-tombstone OPT",
    "summary_candidate_opt": "Summary-only candidate OPT",
    "oracle_gvt": "Oracle-GVT",
    "opt": "Exact OPT",
    "dense_budgeted_bsc": "OracleMem writer + dense retrieval",
    "dense_rag_e5": "Full raw-store dense retrieval",
    "dense_budgeted_replay": "Budgeted raw replay + dense retrieval",
    "fifo_replay": "FIFO raw replay",
}

DEPLOYABLE_METHODS = ("amac_admission", "memgpt_tiered", "mem0_extract")


def _path(value: str | Path) -> Path:
    path = Path(value)
    return path if path.is_absolute() else ROOT / path


def _load_json(path: Path) -> Any:
    return json.loads(path.read_text(encoding="utf-8"))


def _fmt(value: float | int | None, digits: int = 3) -> str:
    if value is None:
        return "n/a"
    return f"{float(value):.{digits}f}"


def _ci(row: dict[str, Any]) -> str:
    low = row.get("bootstrap95_ratio_to_opt_low")
    high = row.get("bootstrap95_ratio_to_opt_high")
    if low is None or high is None:
        return "n/a"
    return f"[{_fmt(low)}, {_fmt(high)}]"


def _method_rows(local_summary: dict[str, Any]) -> dict[tuple[str, int, str], dict[str, Any]]:
    rows: dict[tuple[str, int, str], dict[str, Any]] = {}
    for row in local_summary.get("by_budget_method", []):
        key = (str(row["distribution"]), int(row["budget"]), str(row["method"]))
        rows[key] = row
    return rows


def _local_highlights(local_summary: dict[str, Any]) -> list[dict[str, Any]]:
    rows = _method_rows(local_summary)
    highlights: list[dict[str, Any]] = []
    for distribution in local_summary.get("distributions", []):
        for budget in local_summary.get("budgets", []):
            deployable_rows = [
                rows[(distribution, budget, method)]
                for method in DEPLOYABLE_METHODS
                if (distribution, budget, method) in rows
            ]
            if not deployable_rows:
                continue
            best = max(deployable_rows, key=lambda row: row.get("mean_ratio_to_opt", float("-inf")))
            highlights.append(
                {
                    "distribution": distribution,
                    "budget": budget,
                    "best_deployable_method": best["method"],
                    "best_deployable_ratio": best.get("mean_ratio_to_opt"),
                    "best_deployable_ci95": [
                        best.get("bootstrap95_ratio_to_opt_low"),
                        best.get("bootstrap95_ratio_to_opt_high"),
                    ],
                    "oracle_gvt_ratio": rows.get((distribution, budget, "oracle_gvt"), {}).get(
                        "mean_ratio_to_opt"
                    ),
                    "generic_candidate_opt_ratio": rows.get(
                        (distribution, budget, "generic_candidate_opt"), {}
                    ).get("mean_ratio_to_opt"),
                    "no_tombstone_opt_ratio": rows.get((distribution, budget, "no_tombstone_opt"), {}).get(
                        "mean_ratio_to_opt"
                    ),
                    "summary_candidate_opt_ratio": rows.get(
                        (distribution, budget, "summary_candidate_opt"), {}
                    ).get("mean_ratio_to_opt"),
                }
            )
    return highlights


def _reader_deltas(reader_summary: dict[str, Any]) -> dict[str, Any]:
    metrics = reader_summary.get("metrics", {})
    return metrics.get("dense_budgeted_bsc", {}).get(
        "_paired_focus_deltas_vs_oraclemem_dense",
        metrics.get("_paired_focus_deltas_vs_oraclemem_dense", {}),
    )


def _extract_summary(

    local_summary: dict[str, Any],

    retrieval_summary: dict[str, Any],

    reader_summary: dict[str, Any],

    coverage_audit: dict[str, Any],

) -> dict[str, Any]:
    retrieval_metrics = retrieval_summary.get("metrics", {})
    reader_metrics = reader_summary.get("metrics", {})
    coverage_ready = coverage_audit.get("coverage_ready_artifacts", [])

    return {
        "schema_version": 1,
        "generated_date": _dt.date.today().isoformat(),
        "api_called": False,
        "local_exact_sweep": {
            "num_rows": local_summary.get("num_rows"),
            "distributions": local_summary.get("distributions", []),
            "budgets": local_summary.get("budgets", []),
            "methods": local_summary.get("methods", []),
            "highlights": _local_highlights(local_summary),
        },
        "external_cached_retrieval": {
            "source": retrieval_summary.get("source"),
            "metric_basis": retrieval_summary.get("metric_basis"),
            "topk": retrieval_summary.get("topk"),
            "focus_n": retrieval_metrics.get("dense_budgeted_bsc", {}).get("focus_n"),
            "oraclemem_focus_recall_at_5": retrieval_metrics.get("dense_budgeted_bsc", {}).get(
                "focus_recall_at_5"
            ),
            "full_raw_focus_recall_at_5": retrieval_metrics.get("dense_rag_e5", {}).get(
                "focus_recall_at_5"
            ),
            "oraclemem_minus_full_raw_focus_recall_at_5": retrieval_metrics.get(
                "dense_budgeted_bsc", {}
            ).get("delta_focus_vs_full_dense_rag"),
        },
        "external_cached_reader": {
            "reader": reader_summary.get("reader"),
            "reader_model": reader_summary.get("reader_model"),
            "scope": "cached artifact only; reader was not rerun",
            "focus_n": reader_metrics.get("dense_budgeted_bsc", {}).get("focus", {}).get("n"),
            "oraclemem_focus_f1": reader_metrics.get("dense_budgeted_bsc", {})
            .get("focus", {})
            .get("token_f1"),
            "full_raw_focus_f1": reader_metrics.get("dense_rag_e5", {})
            .get("focus", {})
            .get("token_f1"),
            "oraclemem_focus_evidence_use": reader_metrics.get("dense_budgeted_bsc", {})
            .get("focus", {})
            .get("evidence_use"),
            "full_raw_focus_evidence_use": reader_metrics.get("dense_rag_e5", {})
            .get("focus", {})
            .get("evidence_use"),
            "paired_deltas_vs_full_raw": _reader_deltas(reader_summary).get("dense_rag_e5", {}),
        },
        "non_synthetic_oracle_blocker": {
            "coverage_ready_artifacts": coverage_ready,
            "blocked": len(coverage_ready) == 0,
            "required_package": [
                "experiences.jsonl",
                "evidence_units.jsonl",
                "queries.jsonl with required_unit_ids",
                "candidate_memories.jsonl",
                "coverage_matrix.jsonl",
                "annotation_decisions.jsonl",
                "candidate_generation_manifest.json",
            ],
        },
    }


def _render_local_table(summary: dict[str, Any]) -> list[str]:
    lines = [
        "| Distribution | Budget | Best local deployable writer | Ratio to synthetic OPT | Oracle-GVT | Generic-candidate OPT | No-tombstone OPT |",
        "| --- | ---: | --- | ---: | ---: | ---: | ---: |",
    ]
    for row in summary["local_exact_sweep"]["highlights"]:
        best_label = METHOD_LABELS.get(row["best_deployable_method"], row["best_deployable_method"])
        lines.append(
            "| "
            f"`{row['distribution']}` | {row['budget']} | {best_label} | "
            f"{_fmt(row['best_deployable_ratio'])} {row['best_deployable_ci95'] and '[' + _fmt(row['best_deployable_ci95'][0]) + ', ' + _fmt(row['best_deployable_ci95'][1]) + ']'} | "
            f"{_fmt(row['oracle_gvt_ratio'])} | "
            f"{_fmt(row['generic_candidate_opt_ratio'])} | "
            f"{_fmt(row['no_tombstone_opt_ratio'])} |"
        )
    return lines


def _render_report(summary: dict[str, Any], inputs: dict[str, Path]) -> str:
    retrieval = summary["external_cached_retrieval"]
    reader = summary["external_cached_reader"]
    blocker = summary["non_synthetic_oracle_blocker"]
    paired = reader.get("paired_deltas_vs_full_raw", {})
    f1_delta = paired.get("token_f1", {})
    evidence_delta = paired.get("evidence_use", {})
    em_delta = paired.get("exact_match", {})

    lines = [
        "# No-API Realism Report",
        "",
        f"Date: {summary['generated_date']}",
        "",
        "Scope: local-only report for the reviewer concern that the empirical evidence is too synthetic. This report reads existing artifacts and the 50-seed no-API local sweep; it does not call OpenRouter, OpenAI, embedding services, or any API reader.",
        "",
        "## Verdict",
        "",
        "This strengthens realism in two limited ways: it adds deployable local writer heuristics that do not use oracle coverage to the exact-small benchmark, and it places cached LongMemEval-S retrieval/reader diagnostics beside the synthetic oracle evidence. It does not convert LongMemEval-S into an exact OracleMem benchmark, because the current external artifacts have session-level evidence only and no candidate-by-evidence coverage matrix.",
        "",
        "## Inputs",
        "",
        f"- Local exact-small realism sweep: `{inputs['local_summary'].relative_to(ROOT)}`",
        f"- Cached LongMemEval-S retrieval summary: `{inputs['retrieval_summary'].relative_to(ROOT)}`",
        f"- Cached frozen-context reader summary: `{inputs['reader_summary'].relative_to(ROOT)}`",
        f"- Coverage artifact audit: `{inputs['coverage_audit'].relative_to(ROOT)}`",
        "",
        "## Local No-API Realism Sweep",
        "",
        "Command used for the sweep:",
        "",
        "```powershell",
        "python run_oraclemem_mvp.py --n-seeds 50 --budgets 4,6 --distribution base,update_chain,scope_shift_v2 --methods opt,oracle_gvt,memgpt_tiered,mem0_extract,amac_admission,no_tombstone_opt,generic_candidate_opt,generic_candidate_gvt,summary_candidate_opt --out-dir oraclemem_runs\\no_api_realism_50 --enable-retrieval",
        "```",
        "",
        "These rows are still synthetic exact-small rows, because the hidden evidence units and coverage matrix come from the generator. The realism improvement is narrower: the deployable writer rows are local heuristics that do not read held-out query ids, oracle coverage vectors, oracle marginals, or API estimates.",
        "",
        *_render_local_table(summary),
        "",
        "Interpretation: the local deployable baselines are competitive on some validity/scope cases, especially `update_chain` and `scope_shift_v2`, while candidate-pool ablations still expose a large gap when validity-state records are unavailable. This is a stronger synthetic diagnostic, not natural-trace proof.",
        "",
        "## Cached External Diagnostics",
        "",
        f"LongMemEval-S retrieval remains external but retrieval-only: focus R@5 is {_fmt(retrieval.get('oraclemem_focus_recall_at_5'))} for OracleMem writer + dense retrieval versus {_fmt(retrieval.get('full_raw_focus_recall_at_5'))} for full raw-store dense retrieval, a delta of {_fmt(retrieval.get('oraclemem_minus_full_raw_focus_recall_at_5'))}. These are gold answer-session-id retrieval scores, not answer accuracy and not ratios to OPT.",
        "",
        f"The cached frozen-context reader artifact remains a historical API result, but this report did not rerun it. On the focus slice, OracleMem token F1 is {_fmt(reader.get('oraclemem_focus_f1'))} versus {_fmt(reader.get('full_raw_focus_f1'))} for full raw dense; evidence use is {_fmt(reader.get('oraclemem_focus_evidence_use'))} versus {_fmt(reader.get('full_raw_focus_evidence_use'))}. The paired F1 delta versus full raw is {_fmt(f1_delta.get('mean_delta'))} with CI [{_fmt((f1_delta.get('ci95') or [None, None])[0])}, {_fmt((f1_delta.get('ci95') or [None, None])[1])}], while the exact-match delta is {_fmt(em_delta.get('mean_delta'))} with CI [{_fmt((em_delta.get('ci95') or [None, None])[0])}, {_fmt((em_delta.get('ci95') or [None, None])[1])}].",
        "",
        f"Evidence-use delta versus full raw is {_fmt(evidence_delta.get('mean_delta'))} with CI [{_fmt((evidence_delta.get('ci95') or [None, None])[0])}, {_fmt((evidence_delta.get('ci95') or [None, None])[1])}]. This supports a transfer diagnostic under frozen contexts, not deployed memory-system superiority.",
        "",
        "## Blocker For True Non-Synthetic Oracle Evidence",
        "",
        "The exact remaining blocker is a complete non-synthetic OracleMem coverage package. Current audited artifacts are not coverage-ready, so no non-synthetic `ratio_to_opt` should be reported.",
        "",
        "Required package:",
        "",
    ]
    lines.extend(f"- `{item}`" for item in blocker["required_package"])
    lines.extend(
        [
            "",
            "The package must pass the acceptance gate in `COVERAGE_VALIDATION_PROTOCOL.md`: 100% resolved evidence units, query `required_unit_ids`, candidate groups/costs/text, positive coverage rows with rationales/source spans, no future-source leakage, no forbidden generator inputs, and solver inputs derivable from the artifacts without hidden code defaults.",
            "",
            "## Claim Boundary",
            "",
            "- Synthetic exact-small results can report `ratio_to_opt` only because exact OPT is certified from generated hidden coverage.",
            "- Local deployable-writer rows improve realism inside that synthetic setting but do not prove performance on natural traces.",
            "- LongMemEval-S retrieval/reader rows are external diagnostics with session-level evidence only; they should never be described as exact OracleMem oracle ratios.",
            "- True non-synthetic evidence requires the coverage package above or a clearly named non-OPT reference/upper-bound denominator.",
            "",
        ]
    )
    return "\n".join(lines)


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--local-summary",
        default="oraclemem_runs/no_api_realism_50/summary.json",
        help="Summary JSON from the local no-API deployable-writer sweep.",
    )
    parser.add_argument(
        "--retrieval-summary",
        default="llm_memory_validation/longmemeval_focus_report_core4/summary.json",
        help="Cached LongMemEval-S retrieval summary JSON.",
    )
    parser.add_argument(
        "--reader-summary",
        default="llm_memory_validation/longmemeval_reader_api_gpt55_answer_supported_focus_full/summary.json",
        help="Cached frozen-context reader summary JSON.",
    )
    parser.add_argument(
        "--coverage-audit",
        default="llm_memory_validation/coverage_artifact_audit/summary.json",
        help="Coverage artifact audit summary JSON.",
    )
    parser.add_argument(
        "--output-dir",
        default="oraclemem_runs/no_api_realism_50",
        help="Directory for REPORT.md and realism_summary.json.",
    )
    args = parser.parse_args()

    inputs = {
        "local_summary": _path(args.local_summary),
        "retrieval_summary": _path(args.retrieval_summary),
        "reader_summary": _path(args.reader_summary),
        "coverage_audit": _path(args.coverage_audit),
    }

    summary = _extract_summary(
        _load_json(inputs["local_summary"]),
        _load_json(inputs["retrieval_summary"]),
        _load_json(inputs["reader_summary"]),
        _load_json(inputs["coverage_audit"]),
    )
    output_dir = _path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)
    (output_dir / "realism_summary.json").write_text(
        json.dumps(summary, indent=2, sort_keys=True) + "\n",
        encoding="utf-8",
    )
    (output_dir / "REPORT.md").write_text(_render_report(summary, inputs), encoding="utf-8")
    print(f"wrote {output_dir / 'REPORT.md'}")
    print(f"wrote {output_dir / 'realism_summary.json'}")


if __name__ == "__main__":
    main()