| """Build a Gemini-annotated natural OracleMem pilot from LongMemEval-S. | |
| This script is intentionally separate from the synthetic OracleMem runner. It | |
| uses Gemini through OpenRouter to create an auditable natural-trace coverage | |
| package: | |
| * candidate memories are generated from conversation sessions only; | |
| * query/gold answers are used only in a separate annotation step that maps | |
| extracted evidence units to the evaluation question; | |
| * exact OPT is solved over the resulting finite candidate set; | |
| * local published-system-inspired writer policies are scored under the same | |
| candidate set and budget. | |
| The default run is a small pilot. Scale `--limit` only after checking cache hit | |
| rate, cost, and package quality. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import hashlib | |
| import json | |
| import math | |
| import random | |
| import re | |
| import statistics | |
| import string | |
| import time | |
| import urllib.error | |
| import urllib.request | |
| from collections import defaultdict | |
| from dataclasses import asdict, dataclass | |
| from pathlib import Path | |
| import sys | |
| from typing import Any, Iterable, Mapping, Sequence | |
| ROOT = Path(__file__).resolve().parents[1] | |
| if str(ROOT) not in sys.path: | |
| sys.path.insert(0, str(ROOT)) | |
| from oraclemem.evaluate import ( | |
| CandidateMemory, | |
| OracleMemInstance, | |
| SelectionResult, | |
| evaluate_instance, | |
| write_benchmark_outputs, | |
| ) | |
| FOCUS_TYPES = {"knowledge-update", "temporal-reasoning"} | |
| DEFAULT_MODEL = "google/gemini-3.1-flash-lite-preview" | |
| DEFAULT_METHODS = ( | |
| "opt", | |
| "oracle_gvt", | |
| "memgpt_tiered", | |
| "mem0_extract", | |
| "amem_graph", | |
| "amac_admission", | |
| "recency_raw", | |
| "summary_only", | |
| "fact_only", | |
| ) | |
| def load_env_file(path: Path) -> dict[str, str]: | |
| values: dict[str, str] = {} | |
| if not path.exists(): | |
| return values | |
| for line in path.read_text(encoding="utf-8").splitlines(): | |
| stripped = line.strip() | |
| if not stripped or stripped.startswith("#") or "=" not in stripped: | |
| continue | |
| key, value = stripped.split("=", 1) | |
| values[key.strip()] = value.strip().strip('"').strip("'") | |
| return values | |
| def stable_hash(text: str) -> str: | |
| return hashlib.sha256(text.encode("utf-8")).hexdigest() | |
| def safe_token(value: str) -> str: | |
| cleaned = "".join(char if char.isalnum() or char in "._-" else "_" for char in value) | |
| return cleaned.strip("._") or "item" | |
| def word_count(text: str) -> int: | |
| return len(re.findall(r"\S+", text)) | |
| def truncate_words(text: str, limit: int) -> str: | |
| words = re.findall(r"\S+", text) | |
| if len(words) <= limit: | |
| return text | |
| return " ".join(words[:limit]) + " ..." | |
| def extract_json_object(text: str | None) -> dict[str, Any]: | |
| if not text: | |
| return {} | |
| stripped = text.strip() | |
| try: | |
| parsed = json.loads(stripped) | |
| return parsed if isinstance(parsed, dict) else {} | |
| except json.JSONDecodeError: | |
| pass | |
| match = re.search(r"\{.*\}", stripped, flags=re.DOTALL) | |
| if not match: | |
| return {} | |
| try: | |
| parsed = json.loads(match.group(0)) | |
| except json.JSONDecodeError: | |
| return {} | |
| return parsed if isinstance(parsed, dict) else {} | |
| class OpenRouterJsonClient: | |
| """Small cached OpenRouter JSON client for Gemini annotation.""" | |
| def __init__( | |
| self, | |
| *, | |
| api_key: str, | |
| model: str, | |
| cache_path: Path, | |
| max_tokens: int = 1400, | |
| temperature: float = 0.0, | |
| timeout: int = 120, | |
| request_sleep: float = 0.02, | |
| ) -> None: | |
| self.api_key = api_key | |
| self.model = model | |
| self.cache_path = cache_path | |
| self.max_tokens = max_tokens | |
| self.temperature = temperature | |
| self.timeout = timeout | |
| self.request_sleep = request_sleep | |
| self.cache: dict[str, dict[str, Any]] = {} | |
| if cache_path.exists(): | |
| self.cache = json.loads(cache_path.read_text(encoding="utf-8")) | |
| def _write_cache(self) -> None: | |
| self.cache_path.parent.mkdir(parents=True, exist_ok=True) | |
| self.cache_path.write_text(json.dumps(self.cache, indent=2, sort_keys=True), encoding="utf-8") | |
| def __call__(self, prompt: str, *, purpose: str) -> dict[str, Any]: | |
| settings = { | |
| "model": self.model, | |
| "max_tokens": self.max_tokens, | |
| "temperature": self.temperature, | |
| "purpose": purpose, | |
| } | |
| prompt_hash = stable_hash(json.dumps(settings, sort_keys=True) + "\n" + prompt) | |
| if prompt_hash in self.cache: | |
| cached = dict(self.cache[prompt_hash]) | |
| cached["cache_hit"] = True | |
| cached["prompt_hash"] = prompt_hash | |
| return cached | |
| payload = { | |
| "model": self.model, | |
| "messages": [{"role": "user", "content": prompt}], | |
| "temperature": self.temperature, | |
| "max_tokens": self.max_tokens, | |
| "max_completion_tokens": self.max_tokens, | |
| "response_format": {"type": "json_object"}, | |
| } | |
| request = urllib.request.Request( | |
| "https://openrouter.ai/api/v1/chat/completions", | |
| data=json.dumps(payload).encode("utf-8"), | |
| headers={ | |
| "Authorization": f"Bearer {self.api_key}", | |
| "Content-Type": "application/json", | |
| "HTTP-Referer": "https://localhost/oraclemem", | |
| "X-Title": "OracleMem Natural Coverage Pilot", | |
| }, | |
| method="POST", | |
| ) | |
| try: | |
| with urllib.request.urlopen(request, timeout=self.timeout) as response: | |
| body = json.loads(response.read().decode("utf-8")) | |
| except urllib.error.HTTPError as error: | |
| details = error.read().decode("utf-8", errors="replace") | |
| raise RuntimeError(f"OpenRouter HTTP {error.code}: {details}") from error | |
| content = body["choices"][0]["message"].get("content") | |
| parsed = extract_json_object(content) | |
| result = { | |
| "cache_hit": False, | |
| "prompt_hash": prompt_hash, | |
| "purpose": purpose, | |
| "model": self.model, | |
| "parsed": parsed, | |
| "raw_content": content, | |
| "usage": body.get("usage", {}), | |
| "provider": body.get("provider"), | |
| } | |
| self.cache[prompt_hash] = result | |
| self._write_cache() | |
| if self.request_sleep > 0: | |
| time.sleep(self.request_sleep) | |
| return result | |
| class GeneratedSession: | |
| session_id: str | |
| date: str | |
| source_kind: str | |
| text: str | |
| response: dict[str, Any] | |
| prompt_hash: str | |
| cache_hit: bool | |
| usage: Mapping[str, Any] | |
| def session_text(turns: Sequence[Mapping[str, Any]], *, max_words: int) -> str: | |
| lines: list[str] = [] | |
| for turn in turns: | |
| role = str(turn.get("role", "unknown")).strip() or "unknown" | |
| content = str(turn.get("content", "")).strip() | |
| if content: | |
| lines.append(f"{role}: {content}") | |
| return truncate_words("\n".join(lines), max_words) | |
| def session_prompt(session_id: str, date: str, text: str) -> str: | |
| return f"""You are constructing a write-time memory benchmark from one conversation session. | |
| Do not use any hidden question or answer. Use only the session text below. | |
| Extract up to 4 source-backed evidence units that could matter for future long-term memory questions. Then generate alternative candidate memory representations for this same session: | |
| - one Mem0-style atomic fact candidate, if useful; | |
| - one A-Mem-style graph/linked note candidate, if useful; | |
| - one MemGPT-style compact summary candidate, if useful; | |
| - one tombstone/update candidate only if the session explicitly corrects, supersedes, invalidates, or updates prior information. | |
| Every candidate must list which evidence unit ids it supports. Use only ids you created. Do not invent facts unsupported by the session. | |
| Return exactly JSON: | |
| {{ | |
| "evidence_units": [ | |
| {{ | |
| "unit_id": "u1", | |
| "kind": "current_fact|temporal_fact|preference|update|abstention|other", | |
| "canonical_text": "...", | |
| "source_quote": "short exact quote from session", | |
| "importance": 0.5 | |
| }} | |
| ], | |
| "candidates": [ | |
| {{ | |
| "candidate_id": "c1", | |
| "representation_type": "atomic_fact|graph_edge|summary|tombstone|compound_update", | |
| "generator": "gemini_mem0|gemini_amem|gemini_memgpt|gemini_validity", | |
| "text": "...", | |
| "covers_unit_ids": ["u1"], | |
| "confidence": 0.8 | |
| }} | |
| ] | |
| }} | |
| Session id: {session_id} | |
| Session date: {date} | |
| Session text: | |
| {text} | |
| """ | |
| def query_prompt(question: str, answer: str, units: Sequence[Mapping[str, Any]]) -> str: | |
| payload = [ | |
| { | |
| "unit_id": row["unit_id"], | |
| "canonical_text": row["canonical_text"], | |
| "source_quote": row.get("source_quote", ""), | |
| "session_id": row.get("session_id", ""), | |
| } | |
| for row in units | |
| ] | |
| return f"""You are annotating a long-term memory evaluation question. | |
| Select the minimal evidence unit ids needed to answer the question. Use the gold answer only for annotation. | |
| A set of units is sufficient if a careful reader can derive the answer from those units by simple reasoning: | |
| - For temporal questions, include the event/date units needed to compare order or compute a duration. | |
| - For "which happened first/earlier" questions, include units for both compared events when available. | |
| - For update/current-truth questions, include the current-truth unit and any invalidating or superseded unit needed to avoid a stale answer. | |
| - Individual units do not need to literally contain the final answer if their combination supports it. | |
| Return an empty list only when the provided units cannot support the answer even with simple temporal, arithmetic, or update reasoning. Do not create new unit ids. | |
| Return exactly JSON: | |
| {{ | |
| "required_unit_ids": ["..."], | |
| "rationale": "..." | |
| }} | |
| Question: {question} | |
| Gold answer: {answer} | |
| Evidence units: | |
| {json.dumps(payload, ensure_ascii=False, indent=2)} | |
| """ | |
| def derived_required_units_prompt( | |
| question: str, | |
| answer: str, | |
| sessions: Sequence[GeneratedSession], | |
| existing_units: Sequence[Mapping[str, Any]], | |
| ) -> str: | |
| session_payload = [ | |
| { | |
| "session_id": session.session_id, | |
| "date": session.date, | |
| "source_kind": session.source_kind, | |
| "text": truncate_words(session.text, 900), | |
| } | |
| for session in sessions | |
| ] | |
| unit_payload = [ | |
| { | |
| "unit_id": row.get("unit_id", ""), | |
| "canonical_text": row.get("canonical_text", ""), | |
| "source_quote": row.get("source_quote", ""), | |
| "session_id": row.get("session_id", ""), | |
| } | |
| for row in existing_units | |
| ] | |
| payload = { | |
| "question": question, | |
| "gold_answer": answer, | |
| "sessions": session_payload, | |
| "existing_units": unit_payload, | |
| } | |
| return f"""You are adding missing hidden evidence labels for an OracleMem benchmark package. | |
| The memory candidates have already been generated from sessions only. Do not propose or edit memory candidates. | |
| Your task is only to create benchmark evidence units when the existing units are too coarse or omitted the answer-critical fact. | |
| Create the minimal source-backed evidence units needed to answer the question. Use the gold answer only for annotation. | |
| Each unit must be supported by a quote from one of the listed sessions. For temporal questions, create event/date units that allow a reader to compare order or compute the duration; the unit does not have to state the final derived answer. | |
| Return an empty list only if the sessions themselves do not support the answer. | |
| Return exactly JSON: | |
| {{ | |
| "required_evidence_units": [ | |
| {{ | |
| "session_id": "...", | |
| "canonical_text": "...", | |
| "source_quote": "...", | |
| "kind": "temporal_fact|current_fact|update|preference|other", | |
| "importance": 1.0 | |
| }} | |
| ], | |
| "rationale": "..." | |
| }} | |
| PACKAGE: | |
| {json.dumps(payload, ensure_ascii=False, indent=2)} | |
| """ | |
| def clean_float(value: Any, default: float = 0.5) -> float: | |
| try: | |
| numeric = float(value) | |
| except (TypeError, ValueError): | |
| return default | |
| if not math.isfinite(numeric): | |
| return default | |
| return min(1.0, max(0.0, numeric)) | |
| def candidate_cost(representation_type: str, text: str) -> int: | |
| words = max(1, word_count(text)) | |
| if representation_type == "raw_span": | |
| return max(12, words) | |
| if representation_type in {"atomic_fact", "tombstone"}: | |
| return max(4, min(20, words)) | |
| if representation_type == "graph_edge": | |
| return max(8, min(35, words)) | |
| if representation_type in {"summary", "compound_update"}: | |
| return max(10, min(45, words)) | |
| return max(6, min(45, words)) | |
| def build_instance( | |
| example: Mapping[str, Any], | |
| generated_sessions: Sequence[GeneratedSession], | |
| query_annotation: Mapping[str, Any], | |
| ) -> tuple[OracleMemInstance, dict[str, Any]]: | |
| question_id = str(example["question_id"]) | |
| candidates: list[CandidateMemory] = [] | |
| unit_rows: list[dict[str, Any]] = [] | |
| unit_weights: dict[str, float] = {} | |
| current_units: list[str] = [] | |
| invalidation_units: list[str] = [] | |
| stale_units: list[str] = [] | |
| for session_index, generated in enumerate(generated_sessions): | |
| parsed = generated.response | |
| local_unit_map: dict[str, str] = {} | |
| for unit_index, unit in enumerate(parsed.get("evidence_units", []) or []): | |
| local_id = str(unit.get("unit_id", f"u{unit_index + 1}")).strip() | |
| global_id = f"{safe_token(question_id)}::{safe_token(generated.session_id)}::{safe_token(local_id)}" | |
| kind = str(unit.get("kind", "other")).strip() or "other" | |
| canonical = str(unit.get("canonical_text", "")).strip() | |
| quote = str(unit.get("source_quote", "")).strip() | |
| if not canonical: | |
| continue | |
| local_unit_map[local_id] = global_id | |
| importance = clean_float(unit.get("importance"), default=0.5) | |
| unit_rows.append( | |
| { | |
| "unit_id": global_id, | |
| "local_unit_id": local_id, | |
| "session_id": generated.session_id, | |
| "kind": kind, | |
| "canonical_text": canonical, | |
| "source_quote": quote, | |
| "importance": importance, | |
| "source_kind": generated.source_kind, | |
| "timestamp": session_index, | |
| } | |
| ) | |
| unit_weights.setdefault(global_id, 0.0) | |
| if kind in {"update", "current_fact", "temporal_fact", "preference"}: | |
| current_units.append(global_id) | |
| if kind == "update": | |
| invalidation_units.append(global_id) | |
| if local_unit_map: | |
| raw_coverage = {unit_id: 1.0 for unit_id in local_unit_map.values()} | |
| raw_text = truncate_words(generated.text, 220) | |
| candidates.append( | |
| CandidateMemory( | |
| candidate_id=f"{safe_token(question_id)}::{safe_token(generated.session_id)}::raw", | |
| experience_id=f"{safe_token(question_id)}::{safe_token(generated.session_id)}", | |
| representation_type="raw_span", | |
| serialized=raw_text, | |
| cost=candidate_cost("raw_span", raw_text), | |
| coverage=raw_coverage, | |
| time_index=session_index, | |
| generator="longmemeval_raw", | |
| confidence=1.0, | |
| ) | |
| ) | |
| for candidate_index, raw_candidate in enumerate(parsed.get("candidates", []) or []): | |
| text = str(raw_candidate.get("text", "")).strip() | |
| if not text: | |
| continue | |
| representation_type = str(raw_candidate.get("representation_type", "summary")).strip() or "summary" | |
| if representation_type not in { | |
| "atomic_fact", | |
| "graph_edge", | |
| "summary", | |
| "tombstone", | |
| "compound_update", | |
| }: | |
| representation_type = "summary" | |
| coverage: dict[str, float] = {} | |
| for local_id in raw_candidate.get("covers_unit_ids", []) or []: | |
| global_id = local_unit_map.get(str(local_id).strip()) | |
| if global_id: | |
| coverage[global_id] = 1.0 | |
| if not coverage: | |
| continue | |
| generator = str(raw_candidate.get("generator", "gemini_writer")).strip() or "gemini_writer" | |
| candidates.append( | |
| CandidateMemory( | |
| candidate_id=( | |
| f"{safe_token(question_id)}::{safe_token(generated.session_id)}::" | |
| f"{safe_token(generator)}_{candidate_index}" | |
| ), | |
| experience_id=f"{safe_token(question_id)}::{safe_token(generated.session_id)}", | |
| representation_type=representation_type, | |
| serialized=text, | |
| cost=candidate_cost(representation_type, text), | |
| coverage=coverage, | |
| time_index=session_index, | |
| generator=generator, | |
| confidence=clean_float(raw_candidate.get("confidence"), default=0.75), | |
| ) | |
| ) | |
| available_units = {row["unit_id"] for row in unit_rows} | |
| required_unit_ids = [ | |
| str(unit_id) | |
| for unit_id in query_annotation.get("required_unit_ids", []) | |
| if str(unit_id) in available_units | |
| ] | |
| for unit_id in required_unit_ids: | |
| unit_weights[unit_id] = 1.0 | |
| instance = OracleMemInstance( | |
| instance_id=f"longmemeval_gemini_{safe_token(question_id)}", | |
| seed=None, | |
| candidates=tuple(candidates), | |
| unit_weights=unit_weights, | |
| current_units=tuple(current_units), | |
| invalidation_units=tuple(invalidation_units), | |
| stale_units=tuple(stale_units), | |
| ) | |
| metadata = { | |
| "question_id": question_id, | |
| "question_type": example.get("question_type"), | |
| "question": example.get("question"), | |
| "answer": example.get("answer"), | |
| "answer_session_ids": list(example.get("answer_session_ids", []) or []), | |
| "required_unit_ids": required_unit_ids, | |
| "query_annotation": dict(query_annotation), | |
| "unit_rows": unit_rows, | |
| "selected_sessions": [asdict(generated) for generated in generated_sessions], | |
| } | |
| return instance, metadata | |
| def write_jsonl(path: Path, rows: Iterable[Mapping[str, Any]]) -> None: | |
| path.parent.mkdir(parents=True, exist_ok=True) | |
| with path.open("w", encoding="utf-8") as handle: | |
| for row in rows: | |
| handle.write(json.dumps(dict(row), sort_keys=True) + "\n") | |
| def file_sha256(path: Path) -> str: | |
| digest = hashlib.sha256() | |
| with path.open("rb") as handle: | |
| for chunk in iter(lambda: handle.read(1024 * 1024), b""): | |
| digest.update(chunk) | |
| return digest.hexdigest() | |
| def coverage_label(value: float) -> str: | |
| if value >= 1.0: | |
| return "full" | |
| if value >= 0.75: | |
| return "partial_strong" | |
| if value >= 0.5: | |
| return "partial_weak" | |
| return "hint_only" | |
| def export_natural_package( | |
| *, | |
| out_dir: Path, | |
| instances: Sequence[OracleMemInstance], | |
| metadata_by_instance: Mapping[str, Mapping[str, Any]], | |
| model: str, | |
| cache_path: Path, | |
| prompt_hashes: Mapping[str, Sequence[str]], | |
| total_usage: Mapping[str, float], | |
| ) -> dict[str, Any]: | |
| out_dir.mkdir(parents=True, exist_ok=True) | |
| experience_rows: list[dict[str, Any]] = [] | |
| evidence_rows: list[dict[str, Any]] = [] | |
| query_rows: list[dict[str, Any]] = [] | |
| candidate_rows: list[dict[str, Any]] = [] | |
| coverage_rows: list[dict[str, Any]] = [] | |
| annotation_rows: list[dict[str, Any]] = [] | |
| for instance in instances: | |
| metadata = dict(metadata_by_instance[instance.instance_id]) | |
| session_meta = { | |
| row["session_id"]: row for row in metadata.get("selected_sessions", []) | |
| } | |
| for session_id, session in sorted(session_meta.items()): | |
| experience_id = f"{safe_token(metadata['question_id'])}::{safe_token(session_id)}" | |
| experience_rows.append( | |
| { | |
| "experience_id": experience_id, | |
| "session_id": session_id, | |
| "timestamp": session.get("date", ""), | |
| "text": session.get("text", ""), | |
| "split": "longmemeval_s_support_slice", | |
| "source_kind": session.get("source_kind", ""), | |
| "source_span_ids": [f"{experience_id}:full_session"], | |
| } | |
| ) | |
| for unit in metadata.get("unit_rows", []): | |
| evidence_rows.append( | |
| { | |
| "unit_id": unit["unit_id"], | |
| "kind": unit["kind"], | |
| "canonical_text": unit["canonical_text"], | |
| "source_spans": [ | |
| { | |
| "span_id": f"{safe_token(metadata['question_id'])}::{safe_token(unit['session_id'])}:full_session", | |
| "session_id": unit["session_id"], | |
| "text": unit.get("source_quote") or unit["canonical_text"], | |
| } | |
| ], | |
| "timestamp": unit.get("timestamp", 0), | |
| "state": "current", | |
| "proposition_id": unit["unit_id"], | |
| "annotator_ids": [model], | |
| "adjudication_status": "model_annotated", | |
| "unit_weight": float(instance.unit_weights.get(unit["unit_id"], 0.0)), | |
| "source_kind": unit.get("source_kind", ""), | |
| } | |
| ) | |
| query_rows.append( | |
| { | |
| "query_id": metadata["question_id"], | |
| "question": metadata["question"], | |
| "answer": metadata["answer"], | |
| "category": metadata["question_type"], | |
| "required_unit_ids": metadata.get("required_unit_ids", []), | |
| "answer_session_ids": metadata.get("answer_session_ids", []), | |
| "split": "longmemeval_s_support_slice", | |
| "annotation_rationale": metadata.get("query_annotation", {}).get("rationale", ""), | |
| } | |
| ) | |
| for candidate in instance.candidates: | |
| candidate_rows.append( | |
| { | |
| "candidate_id": candidate.candidate_id, | |
| "experience_id": candidate.experience_id, | |
| "candidate_group": candidate.experience_id, | |
| "representation_type": candidate.representation_type, | |
| "text": candidate.serialized, | |
| "serialized": candidate.serialized, | |
| "cost_tokens": candidate.cost, | |
| "cost": candidate.cost, | |
| "generator_id": candidate.generator, | |
| "confidence": candidate.confidence, | |
| "time_index": candidate.time_index, | |
| } | |
| ) | |
| for unit_id, value in sorted(candidate.coverage.items()): | |
| coverage_rows.append( | |
| { | |
| "candidate_id": candidate.candidate_id, | |
| "experience_id": candidate.experience_id, | |
| "candidate_group": candidate.experience_id, | |
| "unit_id": unit_id, | |
| "coverage": float(value), | |
| "coverage_label": coverage_label(float(value)), | |
| "rationale": "Gemini-generated candidate declares support for this extracted source-backed evidence unit; raw spans cover all units extracted from their source session.", | |
| "source_span_ids": [f"{candidate.experience_id}:full_session"], | |
| "annotator_ids": [model], | |
| "adjudication_status": "model_annotated", | |
| } | |
| ) | |
| for index, row in enumerate(coverage_rows): | |
| annotation_rows.append( | |
| { | |
| "record_id": f"gemini_natural_coverage:{index:06d}", | |
| "record_type": "coverage_cell", | |
| "decision": "accepted_model_annotation", | |
| "primary_annotator": model, | |
| "verifier": model, | |
| "adjudicator": "not_human_adjudicated", | |
| "candidate_id": row["candidate_id"], | |
| "unit_id": row["unit_id"], | |
| "notes": "Single-model annotation; not a human-adjudicated final benchmark label.", | |
| } | |
| ) | |
| paths = { | |
| "experiences": out_dir / "experiences.jsonl", | |
| "evidence_units": out_dir / "evidence_units.jsonl", | |
| "queries": out_dir / "queries.jsonl", | |
| "candidate_memories": out_dir / "candidate_memories.jsonl", | |
| "coverage_matrix": out_dir / "coverage_matrix.jsonl", | |
| "annotation_decisions": out_dir / "annotation_decisions.jsonl", | |
| } | |
| write_jsonl(paths["experiences"], experience_rows) | |
| write_jsonl(paths["evidence_units"], evidence_rows) | |
| write_jsonl(paths["queries"], query_rows) | |
| write_jsonl(paths["candidate_memories"], candidate_rows) | |
| write_jsonl(paths["coverage_matrix"], coverage_rows) | |
| write_jsonl(paths["annotation_decisions"], annotation_rows) | |
| file_hashes = {path.name: file_sha256(path) for path in paths.values()} | |
| manifest = { | |
| "schema_version": 1, | |
| "synthetic_instance": False, | |
| "dataset": "LongMemEval-S", | |
| "split": "support-slice pilot", | |
| "generator_model": model, | |
| "api_provider": "OpenRouter", | |
| "api_cache": str(cache_path), | |
| "prompt_hashes": {key: list(values) for key, values in prompt_hashes.items()}, | |
| "allowed_inputs": [ | |
| "conversation session text for candidate generation", | |
| "question and gold answer for separate required-unit annotation", | |
| ], | |
| "forbidden_inputs_for_candidate_generation": [ | |
| "held-out question text", | |
| "gold answer", | |
| "required_unit_ids", | |
| "solver outputs", | |
| ], | |
| "limitations": [ | |
| "support-slice package includes selected answer-support sessions and optional sampled distractors; it is not a full-haystack write-time benchmark", | |
| "coverage is single-model annotated and not human adjudicated", | |
| "published-system rows are local policy mappings over Gemini-generated candidate types unless an external system adapter is explicitly reported", | |
| ], | |
| "counts": { | |
| "instances": len(instances), | |
| "experiences": len(experience_rows), | |
| "evidence_units": len(evidence_rows), | |
| "queries": len(query_rows), | |
| "candidate_memories": len(candidate_rows), | |
| "positive_coverage_rows": len(coverage_rows), | |
| }, | |
| "usage": dict(total_usage), | |
| "file_hashes": file_hashes, | |
| } | |
| manifest_path = out_dir / "candidate_generation_manifest.json" | |
| manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8") | |
| readme_path = out_dir / "README.md" | |
| readme_path.write_text( | |
| "\n".join( | |
| [ | |
| "# Gemini Natural OracleMem Coverage Package", | |
| "", | |
| "This is a LongMemEval-S support-slice pilot, not a finalized human-adjudicated benchmark.", | |
| "Candidate generation used only conversation sessions. Query/gold answer was used only to annotate required evidence units.", | |
| "", | |
| f"Instances: {len(instances)}", | |
| f"Evidence units: {len(evidence_rows)}", | |
| f"Candidate memories: {len(candidate_rows)}", | |
| f"Positive coverage rows: {len(coverage_rows)}", | |
| "", | |
| ] | |
| ), | |
| encoding="utf-8", | |
| ) | |
| return { | |
| "package_dir": str(out_dir), | |
| "candidate_generation_manifest": str(manifest_path), | |
| "README": str(readme_path), | |
| **{key: str(value) for key, value in paths.items()}, | |
| } | |
| def choose_examples( | |
| examples: Sequence[Mapping[str, Any]], | |
| *, | |
| focus_only: bool, | |
| limit: int, | |
| seed: int, | |
| ) -> list[Mapping[str, Any]]: | |
| filtered = [ | |
| example | |
| for example in examples | |
| if (not focus_only or example.get("question_type") in FOCUS_TYPES) | |
| ] | |
| rng = random.Random(seed) | |
| filtered = sorted(filtered, key=lambda row: str(row.get("question_id", ""))) | |
| rng.shuffle(filtered) | |
| return filtered[:limit] | |
| def choose_session_indices(example: Mapping[str, Any], *, distractors: int, rng: random.Random) -> list[int]: | |
| session_ids = list(example.get("haystack_session_ids", []) or []) | |
| answer_ids = set(example.get("answer_session_ids", []) or []) | |
| answer_indices = [index for index, sid in enumerate(session_ids) if sid in answer_ids] | |
| distractor_indices = [index for index, sid in enumerate(session_ids) if sid not in answer_ids] | |
| rng.shuffle(distractor_indices) | |
| selected = sorted(set(answer_indices + distractor_indices[:distractors])) | |
| if not selected and session_ids: | |
| selected = [len(session_ids) - 1] | |
| return selected | |
| def usage_totals(api_rows: Sequence[Mapping[str, Any]]) -> dict[str, float]: | |
| totals = defaultdict(float) | |
| for row in api_rows: | |
| usage = row.get("usage", {}) or {} | |
| for key in ("prompt_tokens", "completion_tokens", "total_tokens", "cost"): | |
| try: | |
| totals[key] += float(usage.get(key, 0.0) or 0.0) | |
| except (TypeError, ValueError): | |
| pass | |
| totals["api_calls"] += 0.0 if row.get("cache_hit") else 1.0 | |
| totals["cache_hits"] += 1.0 if row.get("cache_hit") else 0.0 | |
| return dict(totals) | |
| def render_report( | |
| *, | |
| summary: Mapping[str, Any], | |
| resolved_summary: Sequence[Mapping[str, Any]], | |
| resolved_count: int, | |
| unresolved_count: int, | |
| package_paths: Mapping[str, Any], | |
| audit_summary: Mapping[str, Any] | None, | |
| usage: Mapping[str, float], | |
| source_repos: Mapping[str, str], | |
| ) -> str: | |
| lines = [ | |
| "# Gemini Natural OracleMem Pilot", | |
| "", | |
| "This run uses Gemini through OpenRouter to build a LongMemEval-S support-slice coverage package.", | |
| "It is stronger than synthetic-only evidence, but it is not yet a full non-synthetic benchmark because labels are single-model annotated and the haystack is sliced to selected support/distractor sessions.", | |
| "", | |
| "## Source Repos Inspected", | |
| "", | |
| ] | |
| for name, path in sorted(source_repos.items()): | |
| lines.append(f"- `{name}`: `{path}`") | |
| lines.extend( | |
| [ | |
| "", | |
| "## API Usage", | |
| "", | |
| f"- New API calls: {int(usage.get('api_calls', 0.0))}", | |
| f"- Cache hits: {int(usage.get('cache_hits', 0.0))}", | |
| f"- Total tokens: {usage.get('total_tokens', 0.0):.0f}", | |
| f"- Estimated cost from OpenRouter usage: ${usage.get('cost', 0.0):.4f}", | |
| f"- Coverage-resolved instances: {resolved_count}", | |
| f"- Unresolved instances with zero required units: {unresolved_count}", | |
| "", | |
| "## Coverage Package", | |
| "", | |
| ] | |
| ) | |
| if int(usage.get("api_calls", 0.0)) == 0 and int(usage.get("cache_hits", 0.0)) > 0 and usage.get("total_tokens", 0.0) > 0: | |
| lines[-2:-2] = [ | |
| "Note: this report was regenerated from cache. The cached rerun made zero additional API calls while preserving historical token/cost metadata from the original uncached calls.", | |
| "", | |
| ] | |
| for key, value in sorted(package_paths.items()): | |
| lines.append(f"- `{key}`: `{value}`") | |
| if audit_summary: | |
| ready = audit_summary.get("coverage_ready_artifacts", []) | |
| lines.extend( | |
| [ | |
| "", | |
| "## Structural Audit", | |
| "", | |
| f"- Coverage-ready artifacts according to structural audit: {ready}", | |
| ] | |
| ) | |
| lines.extend(["", "## Aggregate Results", ""]) | |
| for row in summary.get("by_budget_method", []): | |
| lines.append( | |
| "- budget {budget}, `{method}`: ratio_to_opt={ratio:.3f}, objective={obj:.3f}, cost={cost:.1f}, feasible={feasible}".format( | |
| budget=row.get("budget"), | |
| method=row.get("method"), | |
| ratio=row.get("mean_ratio_to_opt", 0.0), | |
| obj=row.get("mean_objective", 0.0), | |
| cost=row.get("mean_selected_cost", 0.0), | |
| feasible=row.get("all_budget_feasible") and row.get("all_group_feasible"), | |
| ) | |
| ) | |
| lines.extend( | |
| [ | |
| "", | |
| "## Coverage-Resolved Subset", | |
| "", | |
| "These rows exclude examples whose required evidence units could not be resolved from the generated coverage package. This is the safer number for paper discussion.", | |
| "", | |
| ] | |
| ) | |
| for row in resolved_summary: | |
| lines.append( | |
| "- budget {budget}, `{method}`: n={n}, ratio_to_opt={ratio:.3f}, objective={obj:.3f}, cost={cost:.1f}".format( | |
| budget=row["budget"], | |
| method=row["method"], | |
| n=row["n"], | |
| ratio=row["mean_ratio_to_opt"], | |
| obj=row["mean_objective"], | |
| cost=row["mean_selected_cost"], | |
| ) | |
| ) | |
| lines.extend( | |
| [ | |
| "", | |
| "## Interpretation Boundary", | |
| "", | |
| "- Candidate generation is query-independent at the session level.", | |
| "- Required-unit annotation uses the question and gold answer; this is benchmark labeling, not a writer input.", | |
| "- The MemGPT/Mem0/A-Mem/A-MAC rows use local policy mappings over Gemini-generated candidate types. They are not full published-system executions unless a future adapter records that explicitly.", | |
| "- This pilot is suitable as a NeurIPS rebuttal/progress artifact, not as the final main empirical table without scaling and adjudication.", | |
| "", | |
| ] | |
| ) | |
| return "\n".join(lines) | |
| def aggregate_resolved_subset( | |
| results: Sequence[SelectionResult], | |
| metadata_by_instance: Mapping[str, Mapping[str, Any]], | |
| ) -> list[dict[str, Any]]: | |
| grouped: dict[tuple[int, str], list[SelectionResult]] = defaultdict(list) | |
| for row in results: | |
| metadata = metadata_by_instance.get(row.instance_id, {}) | |
| if not metadata.get("required_unit_ids"): | |
| continue | |
| grouped[(int(row.budget), str(row.method))].append(row) | |
| summary: list[dict[str, Any]] = [] | |
| for (budget, method), rows in sorted(grouped.items()): | |
| ratios = [float(row.ratio_to_opt) for row in rows if row.ratio_to_opt is not None] | |
| summary.append( | |
| { | |
| "budget": budget, | |
| "method": method, | |
| "n": len(rows), | |
| "mean_ratio_to_opt": statistics.mean(ratios) if ratios else 0.0, | |
| "mean_objective": statistics.mean(float(row.objective_value) for row in rows), | |
| "mean_selected_cost": statistics.mean(float(row.selected_cost) for row in rows), | |
| "all_budget_feasible": all(row.budget_feasible for row in rows), | |
| "all_group_feasible": all(row.group_feasible for row in rows), | |
| } | |
| ) | |
| return summary | |
| def resolution_rows(metadata_by_instance: Mapping[str, Mapping[str, Any]]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: | |
| """Return resolved/unresolved example rows for downstream natural-package runs.""" | |
| resolved: list[dict[str, Any]] = [] | |
| unresolved: list[dict[str, Any]] = [] | |
| for instance_id, metadata in sorted(metadata_by_instance.items()): | |
| row = { | |
| "instance_id": instance_id, | |
| "question_id": metadata.get("question_id"), | |
| "question_type": metadata.get("question_type"), | |
| "question": metadata.get("question"), | |
| "answer": metadata.get("answer"), | |
| "answer_session_ids": metadata.get("answer_session_ids", []), | |
| "required_unit_ids": metadata.get("required_unit_ids", []), | |
| "selected_session_ids": [ | |
| session.get("session_id") | |
| for session in metadata.get("selected_sessions", []) | |
| ], | |
| "n_units": len(metadata.get("unit_rows", [])), | |
| "n_required_units": len(metadata.get("required_unit_ids", [])), | |
| } | |
| if row["required_unit_ids"]: | |
| resolved.append(row) | |
| else: | |
| row["unresolved_reason"] = "no_required_units_resolved_from_generated_evidence" | |
| unresolved.append(row) | |
| return resolved, unresolved | |
| def main() -> None: | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument("--dataset-json", type=Path, default=Path("llm_memory_validation/cache/longmemeval_s_cleaned.json")) | |
| parser.add_argument("--out-dir", type=Path, default=Path("llm_memory_validation/gemini_natural_oraclemem_pilot")) | |
| parser.add_argument("--api-env", type=Path, default=Path("api.env")) | |
| parser.add_argument("--api-cache", type=Path, default=None) | |
| parser.add_argument("--model", default=DEFAULT_MODEL) | |
| parser.add_argument("--limit", type=int, default=8) | |
| parser.add_argument("--seed", type=int, default=0) | |
| parser.add_argument("--distractors-per-example", type=int, default=2) | |
| parser.add_argument("--max-session-words", type=int, default=850) | |
| parser.add_argument("--budgets", default="30,60") | |
| parser.add_argument("--methods", default=",".join(DEFAULT_METHODS)) | |
| parser.add_argument("--focus-only", action="store_true", default=True) | |
| parser.add_argument("--no-focus-only", action="store_false", dest="focus_only") | |
| parser.add_argument("--max-tokens", type=int, default=1400) | |
| parser.add_argument("--request-sleep", type=float, default=0.02) | |
| args = parser.parse_args() | |
| env = load_env_file(args.api_env) | |
| api_key = env.get("OPENROUTER_API_KEY") | |
| if not api_key: | |
| raise RuntimeError(f"OPENROUTER_API_KEY not found in {args.api_env}") | |
| args.out_dir.mkdir(parents=True, exist_ok=True) | |
| api_cache = args.api_cache or (args.out_dir / "openrouter_cache_gemini_natural_oraclemem.json") | |
| client = OpenRouterJsonClient( | |
| api_key=api_key, | |
| model=args.model, | |
| cache_path=api_cache, | |
| max_tokens=args.max_tokens, | |
| request_sleep=args.request_sleep, | |
| ) | |
| examples = json.loads(args.dataset_json.read_text(encoding="utf-8")) | |
| selected_examples = choose_examples( | |
| examples, | |
| focus_only=args.focus_only, | |
| limit=args.limit, | |
| seed=args.seed, | |
| ) | |
| rng = random.Random(args.seed) | |
| instances: list[OracleMemInstance] = [] | |
| metadata_by_instance: dict[str, dict[str, Any]] = {} | |
| api_rows: list[dict[str, Any]] = [] | |
| prompt_hashes: dict[str, list[str]] = defaultdict(list) | |
| for example_index, example in enumerate(selected_examples): | |
| session_ids = list(example.get("haystack_session_ids", []) or []) | |
| session_dates = list(example.get("haystack_dates", []) or []) | |
| sessions = list(example.get("haystack_sessions", []) or []) | |
| answer_ids = set(example.get("answer_session_ids", []) or []) | |
| generated_sessions: list[GeneratedSession] = [] | |
| for session_index in choose_session_indices( | |
| example, | |
| distractors=args.distractors_per_example, | |
| rng=rng, | |
| ): | |
| if session_index >= len(sessions): | |
| continue | |
| sid = str(session_ids[session_index]) if session_index < len(session_ids) else f"session_{session_index}" | |
| date = str(session_dates[session_index]) if session_index < len(session_dates) else "" | |
| text = session_text(sessions[session_index], max_words=args.max_session_words) | |
| source_kind = "answer_support" if sid in answer_ids else "distractor" | |
| response = client( | |
| session_prompt(sid, date, text), | |
| purpose="session_candidate_generation", | |
| ) | |
| api_rows.append(response) | |
| prompt_hashes["session_candidate_generation"].append(str(response["prompt_hash"])) | |
| generated_sessions.append( | |
| GeneratedSession( | |
| session_id=sid, | |
| date=date, | |
| source_kind=source_kind, | |
| text=text, | |
| response=dict(response.get("parsed", {})), | |
| prompt_hash=str(response["prompt_hash"]), | |
| cache_hit=bool(response.get("cache_hit")), | |
| usage=dict(response.get("usage", {}) or {}), | |
| ) | |
| ) | |
| all_unit_rows: list[dict[str, Any]] = [] | |
| for generated in generated_sessions: | |
| for unit in generated.response.get("evidence_units", []) or []: | |
| local_id = str(unit.get("unit_id", "")).strip() | |
| if not local_id: | |
| continue | |
| global_id = f"{safe_token(example['question_id'])}::{safe_token(generated.session_id)}::{safe_token(local_id)}" | |
| all_unit_rows.append( | |
| { | |
| "unit_id": global_id, | |
| "canonical_text": str(unit.get("canonical_text", "")).strip(), | |
| "source_quote": str(unit.get("source_quote", "")).strip(), | |
| "session_id": generated.session_id, | |
| } | |
| ) | |
| query_response = client( | |
| query_prompt( | |
| str(example.get("question", "")), | |
| str(example.get("answer", "")), | |
| all_unit_rows, | |
| ), | |
| purpose="query_required_unit_annotation", | |
| ) | |
| api_rows.append(query_response) | |
| prompt_hashes["query_required_unit_annotation"].append(str(query_response["prompt_hash"])) | |
| query_annotation = dict(query_response.get("parsed", {})) | |
| available_unit_ids = {str(row["unit_id"]) for row in all_unit_rows} | |
| resolved_required_ids = [ | |
| str(unit_id) | |
| for unit_id in query_annotation.get("required_unit_ids", []) or [] | |
| if str(unit_id) in available_unit_ids | |
| ] | |
| if not resolved_required_ids and generated_sessions: | |
| derived_response = client( | |
| derived_required_units_prompt( | |
| str(example.get("question", "")), | |
| str(example.get("answer", "")), | |
| generated_sessions, | |
| all_unit_rows, | |
| ), | |
| purpose="query_derived_required_unit_annotation", | |
| ) | |
| api_rows.append(derived_response) | |
| prompt_hashes["query_derived_required_unit_annotation"].append(str(derived_response["prompt_hash"])) | |
| derived = derived_response.get("parsed", {}) if isinstance(derived_response, Mapping) else {} | |
| session_by_id = {session.session_id: session for session in generated_sessions} | |
| derived_required_ids: list[str] = [] | |
| local_counts: dict[str, int] = defaultdict(int) | |
| for session in generated_sessions: | |
| local_counts[session.session_id] = len(session.response.get("evidence_units", []) or []) | |
| for unit in derived.get("required_evidence_units", []) or []: | |
| if not isinstance(unit, Mapping): | |
| continue | |
| session_id = str(unit.get("session_id", "")).strip() | |
| if session_id not in session_by_id: | |
| continue | |
| canonical = str(unit.get("canonical_text", "")).strip() | |
| quote = str(unit.get("source_quote", "")).strip() | |
| if not canonical: | |
| continue | |
| local_counts[session_id] += 1 | |
| local_id = f"dq{local_counts[session_id]}" | |
| session = session_by_id[session_id] | |
| session.response.setdefault("evidence_units", []).append( | |
| { | |
| "unit_id": local_id, | |
| "canonical_text": canonical, | |
| "source_quote": quote, | |
| "kind": str(unit.get("kind", "temporal_fact")).strip() or "temporal_fact", | |
| "importance": clean_float(unit.get("importance"), default=1.0), | |
| } | |
| ) | |
| global_id = f"{safe_token(example['question_id'])}::{safe_token(session_id)}::{safe_token(local_id)}" | |
| derived_required_ids.append(global_id) | |
| if derived_required_ids: | |
| query_annotation = { | |
| "required_unit_ids": derived_required_ids, | |
| "rationale": ( | |
| "Derived evidence-unit fallback: " | |
| + str(derived.get("rationale", query_annotation.get("rationale", ""))) | |
| ), | |
| "derived_required_unit_annotation": True, | |
| "initial_query_annotation": dict(query_response.get("parsed", {})), | |
| } | |
| instance, metadata = build_instance( | |
| example, | |
| generated_sessions, | |
| query_annotation, | |
| ) | |
| if not instance.candidates: | |
| continue | |
| instances.append(instance) | |
| metadata_by_instance[instance.instance_id] = metadata | |
| print( | |
| f"[{example_index + 1}/{len(selected_examples)}] {example.get('question_id')} " | |
| f"candidates={len(instance.candidates)} required={len(metadata['required_unit_ids'])}" | |
| ) | |
| budgets = [int(part.strip()) for part in args.budgets.split(",") if part.strip()] | |
| methods = [part.strip() for part in args.methods.split(",") if part.strip()] | |
| results: list[SelectionResult] = [] | |
| for instance in instances: | |
| results.extend( | |
| evaluate_instance( | |
| instance, | |
| budgets, | |
| methods=methods, | |
| retrieval_modes=("fixed", "oracle"), | |
| ) | |
| ) | |
| paths = write_benchmark_outputs(results, args.out_dir) | |
| usage = usage_totals(api_rows) | |
| package_paths = export_natural_package( | |
| out_dir=args.out_dir / "coverage_package", | |
| instances=instances, | |
| metadata_by_instance=metadata_by_instance, | |
| model=args.model, | |
| cache_path=api_cache, | |
| prompt_hashes=prompt_hashes, | |
| total_usage=usage, | |
| ) | |
| api_rows_path = args.out_dir / "api_calls.jsonl" | |
| write_jsonl(api_rows_path, api_rows) | |
| metadata_path = args.out_dir / "instance_metadata.json" | |
| metadata_path.write_text(json.dumps(metadata_by_instance, indent=2, sort_keys=True), encoding="utf-8") | |
| audit_summary = None | |
| audit_path = args.out_dir / "coverage_audit" / "summary.json" | |
| if audit_path.exists(): | |
| audit_summary = json.loads(audit_path.read_text(encoding="utf-8")) | |
| summary = json.loads(Path(paths["summary_json"]).read_text(encoding="utf-8")) | |
| resolved_count = sum(1 for metadata in metadata_by_instance.values() if metadata.get("required_unit_ids")) | |
| unresolved_count = len(metadata_by_instance) - resolved_count | |
| resolved_summary = aggregate_resolved_subset(results, metadata_by_instance) | |
| resolved_summary_path = args.out_dir / "coverage_resolved_summary.json" | |
| resolved_rows, unresolved_rows = resolution_rows(metadata_by_instance) | |
| resolved_rows_path = args.out_dir / "resolved_examples.jsonl" | |
| unresolved_rows_path = args.out_dir / "unresolved_examples.jsonl" | |
| write_jsonl(resolved_rows_path, resolved_rows) | |
| write_jsonl(unresolved_rows_path, unresolved_rows) | |
| resolution_report_path = args.out_dir / "coverage_resolution_report.md" | |
| resolution_rate = (len(resolved_rows) / len(metadata_by_instance)) if metadata_by_instance else 0.0 | |
| resolution_report_path.write_text( | |
| "\n".join( | |
| [ | |
| "# Coverage Resolution Report", | |
| "", | |
| f"- Attempted/constructed instances: {len(metadata_by_instance)}", | |
| f"- Coverage-resolved instances: {len(resolved_rows)}", | |
| f"- Unresolved instances: {len(unresolved_rows)}", | |
| f"- Coverage-resolved rate: {resolution_rate:.3f}", | |
| "", | |
| "An instance is coverage-resolved when the query annotation maps at least one required evidence unit to evidence units generated from the selected support/distractor sessions or the source-backed derived-unit annotation pass.", | |
| ] | |
| ) | |
| + "\n", | |
| encoding="utf-8", | |
| ) | |
| resolved_summary_path.write_text( | |
| json.dumps( | |
| { | |
| "coverage_resolved_instances": resolved_count, | |
| "unresolved_instances": unresolved_count, | |
| "by_budget_method": resolved_summary, | |
| }, | |
| indent=2, | |
| sort_keys=True, | |
| ) | |
| + "\n", | |
| encoding="utf-8", | |
| ) | |
| report = render_report( | |
| summary=summary, | |
| resolved_summary=resolved_summary, | |
| resolved_count=resolved_count, | |
| unresolved_count=unresolved_count, | |
| package_paths=package_paths, | |
| audit_summary=audit_summary, | |
| usage=usage, | |
| source_repos={ | |
| "Mem0": "external_repos/mem0", | |
| "A-Mem": "external_repos/AgenticMemory", | |
| "Letta/MemGPT": "external_repos/letta", | |
| }, | |
| ) | |
| report_path = args.out_dir / "REPORT.md" | |
| report_path.write_text(report, encoding="utf-8") | |
| run_manifest = { | |
| "schema_version": 1, | |
| "model": args.model, | |
| "limit": args.limit, | |
| "focus_only": args.focus_only, | |
| "distractors_per_example": args.distractors_per_example, | |
| "instances": len(instances), | |
| "budgets": budgets, | |
| "methods": methods, | |
| "paths": { | |
| **paths, | |
| "package": package_paths, | |
| "api_calls": str(api_rows_path), | |
| "metadata": str(metadata_path), | |
| "coverage_resolved_summary": str(resolved_summary_path), | |
| "resolved_examples": str(resolved_rows_path), | |
| "unresolved_examples": str(unresolved_rows_path), | |
| "coverage_resolution_report": str(resolution_report_path), | |
| "report": str(report_path), | |
| }, | |
| "usage": usage, | |
| } | |
| (args.out_dir / "run_manifest.json").write_text( | |
| json.dumps(run_manifest, indent=2, sort_keys=True) + "\n", | |
| encoding="utf-8", | |
| ) | |
| print(json.dumps(run_manifest, indent=2, sort_keys=True)) | |
| if __name__ == "__main__": | |
| main() | |