| """Build the public corpus from read-only workspace inputs. Python 3.10+. |
| |
| Raw recordings are grouped by the audited inventory identity, never by bytes |
| alone. JSON strings in Parquet preserve heterogeneous source schemas. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import collections |
| import gzip |
| import hashlib |
| import json |
| import math |
| import re |
| import subprocess |
| from pathlib import Path |
|
|
| import pandas as pd |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
| VERSION = "trajectory-study-parser-v1.0.0" |
| REPO = "pranay5255/agent-trajectory-study-20260930" |
| FOREST_REPO = "pranay5255/forestofaudits-agent-grader-traces-20260608-backfilled" |
| FOREST_REV = "b78e6f7adc3e14323d877d61edd94432938ddfe8" |
| PROJECTS = {"Olmo-RewardHacking": "olmo", "rl_experiments": "qwen", "forestOfAudits": "forest"} |
| UUID = re.compile(r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}") |
| AUTH_KEY = re.compile(r"(?:^|_)(?:api_key|apikey|access_token|auth_token|refresh_token|authorization|authentication|password|passwd|secret|credentials|credential|cookie|client_secret|hf_token|github_token|openai_api_key)(?:$|_)", re.I) |
| SECRET_PATTERNS = [ |
| re.compile(r"\b(?:hf_[A-Za-z0-9]{20,}|sk-(?:proj-)?[A-Za-z0-9_-]{20,}|gh[pousr]_[A-Za-z0-9]{20,}|AKIA[A-Z0-9]{16})\b"), |
| re.compile(r"(?i)\bBearer\s+[A-Za-z0-9._~+/-]{8,}"), |
| re.compile(r"(?i)(?<![A-Za-z0-9_])(?:[A-Z_]{0,64}(?:API_KEY|ACCESS_TOKEN|AUTH_TOKEN|PASSWORD|CLIENT_SECRET|HF_TOKEN|GITHUB_TOKEN)|[\"'](?:api_key|authorization|password|access_token)[\"'])\s*[:=]\s*(?:\"[^\"\n]*\"|'[^'\n]*'|[^\s,;}]+)"), |
| re.compile(r"(?i)([?&](?:api_key|token|access_token|key|secret)=)[^&\s\"']+"), |
| re.compile(r"https?://[^/\s:@]+:[^/\s@]+@"), |
| ] |
|
|
|
|
| def dumps(obj): |
| return json.dumps(obj, ensure_ascii=False, sort_keys=True, separators=(",", ":"), allow_nan=False) |
|
|
|
|
| def digest(data): |
| return hashlib.sha256(data).hexdigest() |
|
|
|
|
| def identity(key): |
| return digest(key.encode())[:24] |
|
|
|
|
| def finite(value): |
| return isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value) |
|
|
|
|
| def nullable_number(value): |
| if value is None or value == "": |
| return None |
| number = float(value) |
| return number if math.isfinite(number) else None |
|
|
|
|
| class Redactor: |
| def __init__(self): |
| self.rows = [] |
|
|
| def mark(self, source, coordinate, kind): |
| self.rows.append({"source_path": source, "coordinate": coordinate, "kind": kind}) |
|
|
| def text(self, value, source, coordinate): |
| for i, pattern in enumerate(SECRET_PATTERNS): |
| value, n = pattern.subn("[REDACTED]", value) |
| if n: |
| self.mark(source, coordinate, f"text_pattern_{i}:{n}") |
| return value |
|
|
| def clean(self, obj, source, coordinate="$"): |
| if isinstance(obj, dict): |
| out = {} |
| for k, v in obj.items(): |
| coord = coordinate + "." + k |
| |
| if AUTH_KEY.search(k): |
| self.mark(source, coord, "authentication_field_removed") |
| continue |
| out[k] = self.clean(v, source, coord) |
| return out |
| if isinstance(obj, list): |
| |
| if not obj or all(isinstance(x, (int, float, bool, type(None))) for x in obj): |
| return [x if not isinstance(x, float) or math.isfinite(x) else None for x in obj] |
| return [self.clean(v, source, f"{coordinate}[{i}]") for i, v in enumerate(obj)] |
| if isinstance(obj, str): |
| return self.text(obj, source, coordinate) |
| if isinstance(obj, float) and not math.isfinite(obj): |
| return None |
| return obj |
|
|
|
|
| def parse_payload(payload, jsonl=False): |
| if not jsonl: |
| try: |
| return json.loads(payload), [] |
| except (ValueError, UnicodeError) as exc: |
| return None, [{"line": 1, "error": str(exc)}] |
| rows, errors = [], [] |
| for i, line in enumerate(payload.decode("utf-8", errors="replace").splitlines(), 1): |
| if not line.strip(): |
| continue |
| try: |
| rows.append({"source_line": i, "value": json.loads(line)}) |
| except ValueError as exc: |
| errors.append({"line": i, "error": str(exc)}) |
| return rows, errors |
|
|
|
|
| def flatten_text(value): |
| if value is None: |
| return "" |
| if isinstance(value, str): |
| return value |
| if isinstance(value, list): |
| return "\n".join(flatten_text(v) for v in value) |
| if isinstance(value, dict): |
| if "text" in value or "content" in value: |
| return flatten_text(value.get("text", value.get("content"))) |
| return dumps(value) |
| return str(value) |
|
|
|
|
| def commands_from(tool): |
| args = tool.get("arguments", tool.get("input", {})) |
| if isinstance(args, str): |
| try: |
| args = json.loads(args) |
| except ValueError: |
| return args if tool.get("name") in {"bash", "exec_command", "shell"} else "" |
| if isinstance(args, dict): |
| return flatten_text(args.get("command", args.get("cmd", args.get("keystrokes", "")))) |
| return "" |
|
|
|
|
| def indicators(command): |
| """Overlapping observable command indicators, not claims about intent.""" |
| c = command.lower() |
| return { |
| "read": bool(re.search(r"(?:^|[\s;&|])(cat|head|tail|sed|less|nl)\b", c)), |
| "search": bool(re.search(r"(?:^|[\s;&|])(rg|grep|find|ls|glob)\b", c)), |
| "edit": bool(re.search(r"(?:>>?|apply_patch|sed\s+-i|\.write_text\(|open\([^\n]*[\"']w)", c)), |
| "test": bool(re.search(r"\b(pytest|forge test|npm test|cargo test|go test|test\.py|compile|slither)\b", c)), |
| "submission": bool(re.search(r"(submission|findings\.json|audit\.md|complete_task|submit|finish)", c)), |
| "evaluator_reference": bool(re.search(r"(test\.py|test_cases\.json|reward\.txt|grader|verifier)", c)), |
| } |
|
|
|
|
| def telemetry(metrics): |
| ids = metrics.get("completion_token_ids", metrics.get("output_token_ids")) |
| lps = metrics.get("logprobs", metrics.get("selected_logprobs")) |
| if not isinstance(ids, list) or not isinstance(lps, list): |
| return {"token_count": 0, "logprob_count": 0, "alignment": "unavailable", "nll_sum": None, "surprisal_nats": None} |
| |
| valid = all(isinstance(t, int) and not isinstance(t, bool) for t in ids) and all(finite(v) and v <= 1e-6 for v in lps) |
| aligned = valid and len(ids) == len(lps) and len(ids) > 0 |
| return {"token_count": len(ids), "logprob_count": len(lps), |
| "alignment": "aligned" if aligned else "invalid_or_misaligned", |
| "nll_sum": -sum(lps) if aligned else None, |
| "surprisal_nats": -sum(lps) / len(lps) if aligned else None} |
|
|
|
|
| def normalize(obj, fmt, episode_id, recording_id): |
| events = [] |
|
|
| def emit(coord, kind, text="", command="", observation="", metrics=None, rejected=False, step=None, line=1, timestamp=None): |
| metrics = metrics or {} |
| event = {"episode_id": episode_id, "recording_id": recording_id, "event_index": len(events), |
| "coordinate": coord, "source_line": line, "step_id": str(step) if step is not None else None, |
| "timestamp": str(timestamp) if timestamp is not None else None, |
| "kind": kind, "text": flatten_text(text), "command": flatten_text(command), |
| "observation": flatten_text(observation), "rejected_response": rejected, |
| "prompt_tokens": metrics.get("prompt_tokens"), "completion_tokens": metrics.get("completion_tokens")} |
| event.update(telemetry(metrics)) |
| event.update({f"indicator_{k}": v for k, v in indicators(event["command"]).items()}) |
| events.append(event) |
|
|
| if obj is None: |
| return events |
| if "jsonl" in fmt: |
| for wrapped in obj: |
| item, line = wrapped["value"], wrapped["source_line"] |
| typ = item.get("type", "unknown") |
| data = item.get("payload") or {} |
| coord = f"$line[{line}]" |
| if typ == "response_item": |
| typ = data.get("type", "unknown") |
| if typ == "message": |
| emit(coord, data.get("role", "message"), data.get("content"), line=line, timestamp=item.get("timestamp")) |
| elif typ in {"function_call", "custom_tool_call"}: |
| command = commands_from(data) or (data.get("input", "") if data.get("name") == "apply_patch" else "") |
| emit(coord, "tool_call", data.get("name", ""), command, line=line) |
| elif typ in {"function_call_output", "custom_tool_call_output"}: |
| emit(coord, "observation", observation=data.get("output"), line=line) |
| elif typ == "reasoning": |
| emit(coord, "reasoning", data.get("summary"), line=line) |
| elif typ in {"item.completed", "item.started"}: |
| if typ != "item.completed": |
| continue |
| v = item.get("item") or {} |
| emit(coord, v.get("type", typ), v.get("text", ""), v.get("command", ""), v.get("aggregated_output", ""), line=line) |
| elif typ == "tool_use": |
| part = item.get("part") or {} |
| state = part.get("state") or {} |
| command = commands_from({"input": state.get("input", {}), "name": part.get("tool")}) |
| emit(coord, "tool_call", part.get("tool", ""), command, state.get("output", ""), line=line) |
| elif typ in {"text", "reasoning"}: |
| emit(coord, typ, (item.get("part") or {}).get("text", ""), line=line) |
| elif typ in {"error", "turn.failed"}: |
| emit(coord, "error", item.get("error", item), line=line) |
| elif typ in {"turn.completed", "step_finish"}: |
| usage = item.get("usage") or (item.get("part") or {}).get("tokens") or {} |
| emit(coord, "usage", metrics={"prompt_tokens": usage.get("input_tokens", usage.get("input")), |
| "completion_tokens": usage.get("output_tokens", usage.get("output"))}, line=line) |
| return events |
| if isinstance(obj, dict) and isinstance(obj.get("steps"), list): |
| for i, s in enumerate(obj["steps"]): |
| tools = s.get("tool_calls") or [] |
| command = "\n".join(commands_from(t) for t in tools) |
| obs = flatten_text((s.get("observation") or {}).get("results", [])) |
| emit(f"$.steps[{i}]", s.get("source", "unknown"), s.get("message", ""), command, obs, |
| s.get("metrics"), step=s.get("step_id"), timestamp=s.get("timestamp")) |
| return events |
| seq = obj if isinstance(obj, list) else obj.get("messages", []) |
| for i, s in enumerate(seq): |
| if not isinstance(s, dict): |
| continue |
| content = flatten_text(s.get("content")) |
| command = "\n".join(commands_from(t) for t in s.get("tool_calls", [])) |
| |
| if s.get("role") == "assistant" and not command: |
| command = "\n".join(re.findall(r"```(?:bash|sh|shell)\s*\n(.*?)```", content, flags=re.S)) |
| prefix = "$" if isinstance(obj, list) else "$.messages" |
| emit(f"{prefix}[{i}]", s.get("role", "unknown"), content, command, timestamp=s.get("timestamp")) |
| response = (s.get("extra") or {}).get("model_response_summary") |
| if response: |
| emit(f"{prefix}[{i}].extra.model_response_summary", "rejected_response", response.get("content"), |
| rejected=True, metrics=response.get("usage")) |
| return events |
|
|
|
|
| def write_table(out, name, rows): |
| path = out / "data" / f"{name}.parquet" |
| path.parent.mkdir(parents=True, exist_ok=True) |
| |
| frame = pd.DataFrame(rows) |
| if frame.empty and not len(frame.columns): |
| frame = pd.DataFrame({"empty": pd.Series(dtype="string")}) |
| frame.to_parquet(path, index=False, compression="zstd", row_group_size=1024) |
| return len(frame) |
|
|
|
|
| class Builder: |
| def __init__(self, root, public, out): |
| self.root, self.public, self.out = root, public, out |
| self.redactor = Redactor() |
| self.sources, self.coverage, self.episodes, self.annotations = [], [], [], [] |
| self.token_rows, self.joins, self.examples = [], [], [] |
| self.event_rows = collections.defaultdict(list) |
| self.event_parts = collections.Counter() |
| self.forest_keys = collections.defaultdict(set) |
| self.packet_map = {} |
| self.inventory = pd.read_csv(root / "trajectory_inventory/recordings.csv", keep_default_na=False) |
| self.selected = self.inventory[self.inventory.project.isin(PROJECTS) & (self.inventory.archive_member == "")] |
| self.qwen_base = root / "rl_experiments/artifacts/qwen_rollout_trajectories" |
| self.qwen_metrics = {} |
| for line in (self.qwen_base / "analysis/trajectory_metrics.jsonl").open(): |
| o = json.loads(line) |
| self.qwen_metrics[o["path"]] = o |
| self.qwen_summaries = {} |
| for p in (self.qwen_base / "runs").rglob("*summary.json"): |
| self.qwen_summaries[p.parent.name] = json.loads(p.read_text()) |
|
|
| def read(self, path, role, collection): |
| stored = path.read_bytes() |
| payload = gzip.decompress(stored) if path.suffix == ".gz" else stored |
| source = str(path.relative_to(self.root)) if path.is_relative_to(self.root) else str(path.relative_to(self.public)) |
| obj, errors = parse_payload(payload, path.name.endswith((".jsonl", ".jsonl.gz"))) |
| clean = self.redactor.clean(obj, source) if obj is not None else self.redactor.text(payload.decode("utf-8", errors="replace"), source, "$") |
| published = dumps(clean).encode() |
| row = {"source_path": source, "collection": collection, "role": role, |
| "source_sha256": digest(stored), "source_bytes": len(stored), |
| "decoded_source_sha256": digest(payload), "decoded_source_bytes": len(payload), |
| "source_encoding": "gzip" if path.suffix == ".gz" else "plain", |
| "publication_sha256": digest(published), "publication_bytes": len(published), |
| "parser_version": VERSION, "parse_errors_json": dumps(errors)} |
| self.sources.append(row) |
| return clean, row, errors |
|
|
| def flush_events(self, collection): |
| rows = self.event_rows[collection] |
| if not rows: |
| return |
| target = self.out / "data/events" / collection / f"part-{self.event_parts[collection]:04d}.parquet" |
| target.parent.mkdir(parents=True, exist_ok=True) |
| |
| strings = {"episode_id", "recording_id", "coordinate", "step_id", "timestamp", "kind", "text", "command", "observation", "alignment"} |
| ints = {"event_index", "source_line", "token_count", "logprob_count", "prompt_tokens", "completion_tokens"} |
| fields = [] |
| for key in rows[0]: |
| if key in strings: |
| dtype = pa.string() |
| elif key in ints: |
| dtype = pa.int64() |
| elif key.startswith("indicator_") or key in {"rejected_response", "canonical_view"}: |
| dtype = pa.bool_() |
| else: |
| dtype = pa.float64() |
| fields.append((key, dtype)) |
| schema = pa.schema(fields) |
| pq.write_table(pa.Table.from_pylist(rows, schema=schema), target, compression="zstd", row_group_size=1024) |
| self.event_parts[collection] += 1 |
| self.event_rows[collection] = [] |
|
|
| def add_telemetry(self, episode_id, recording_id, source, coordinate, metrics): |
| row = {"episode_id": episode_id, "recording_id": recording_id, "source_path": source, |
| "coordinate": coordinate, **telemetry(metrics)} |
| self.token_rows.append(row) |
| return row |
|
|
| def forest_identity(self, path): |
| """Exact audit trial UUID plus complete branch suffix. Never fuzzy-match.""" |
| match = UUID.search(path) |
| if not match: |
| return None |
| trial_start = path.rfind("/", 0, match.start()) + 1 |
| audit = path[trial_start:match.start()].rstrip("_") |
| suffix = path[match.end():] |
| if suffix.startswith("__"): |
| suffix = suffix[suffix.find("/"):] |
| suffix = suffix.removeprefix("/agent_data") |
| |
| if not suffix or suffix == "/": |
| return None |
| return audit, match.group(), suffix |
|
|
| def build_episodes(self): |
| grouped = list(self.selected.groupby("episode_key", sort=True)) |
| print(f"Building {len(grouped)} episode identities", flush=True) |
| for n, (key, group) in enumerate(grouped): |
| canonical_rows = group[group.canonical == True] |
| |
| if canonical_rows.empty: |
| for record in group.to_dict("records"): |
| obj, src, errors = self.read(self.root / record["path"], "invalid_recording", PROJECTS[record["project"]]) |
| rel = f"invalid/{identity(record['path'])}.json.gz" |
| raw_text = self.redactor.text((self.root / record["path"]).read_text(errors="replace"), record["path"], "$raw_invalid") |
| self.bundle(rel, {"data": obj, "source": src, "raw_text_redacted": raw_text}) |
| self.coverage.append({"collection": PROJECTS[record["project"]], "unit": "recording_file", "status": "invalid", "source_path": record["path"], "episode_id": None, "details_json": dumps(errors), "detail_path": rel}) |
| continue |
| assert len(canonical_rows) == 1, key |
| canonical = canonical_rows.iloc[0].to_dict() |
| eid, collection = identity(key), PROJECTS[canonical["project"]] |
| views, all_events, canonical_obj, metadata = [], [], None, {} |
| result, config, telemetry_rows = {}, {}, [] |
| for record in group.to_dict("records"): |
| path = self.root / record["path"] |
| obj, src, errors = self.read(path, record["role"], collection) |
| assert src["decoded_source_sha256"] == record["sha256"], f"Source drift: {path}" |
| rid = identity(record["path"]) |
| src.update(episode_id=eid, recording_id=rid, canonical=bool(record["canonical"])) |
| events = normalize(obj if not isinstance(obj, str) else None, record["format"], eid, rid) |
| for e in events: |
| e["canonical_view"] = bool(record["canonical"]) |
| |
| all_events.extend(events) |
| views.append({"source": src, "format": record["format"], "data": obj}) |
| for e in events: |
| if e["alignment"] != "unavailable": |
| telemetry_rows.append({"episode_id": eid, "recording_id": rid, "source_path": src["source_path"], "coordinate": e["coordinate"], **{k:e[k] for k in ["token_count", "logprob_count", "alignment", "nll_sum", "surprisal_nats"]}}) |
| if record["canonical"]: |
| canonical_obj = obj |
| if collection == "forest": |
| fkey = self.forest_identity(record["path"]) |
| if fkey: |
| self.forest_keys[fkey].add(eid) |
| if errors: |
| self.coverage.append({"collection": collection, "unit": "recording_file", "status": "invalid", "source_path": src["source_path"], "episode_id": eid, "details_json": dumps(errors), "detail_path": f"recordings/{collection}/{eid}.json.gz"}) |
| path = self.root / canonical["path"] |
| |
| if path.parent.name == "agent": |
| for name in ["config.json", "result.json"]: |
| p = path.parent.parent / name |
| if p.exists(): |
| obj, src, errors = self.read(p, "trial_metadata", collection) |
| src.update(episode_id=eid, recording_id=identity(str(p.relative_to(self.root))), canonical=False) |
| views.append({"source": src, "format": "metadata-json", "data": obj}) |
| if isinstance(obj, dict): |
| if name == "config.json": |
| config = obj |
| else: |
| result = obj |
| for p in (path.parent.parent / "verifier").glob("*.json"): |
| obj, src, _ = self.read(p, "verifier_evidence", collection) |
| src.update(episode_id=eid, recording_id=identity(str(p.relative_to(self.root))), canonical=False) |
| views.append({"source": src, "format": "verifier-json", "data": obj}) |
| metadata = (result.get("agent_result") or {}).get("metadata") or {} |
| kwargs = ((config.get("agent") or {}).get("kwargs")) or {} |
| if isinstance(canonical_obj, dict): |
| info = canonical_obj.get("info") or {} |
| c = info.get("config") or {} |
| if not config: |
| config = c |
| else: |
| info = {} |
| |
| |
| rd = (result.get("agent_result") or {}).get("rollout_details") or [] |
| for i, batch in enumerate(rd): |
| ids, lps = batch.get("completion_token_ids", []), batch.get("logprobs", []) |
| if ids and isinstance(ids[0], list): |
| for j in range(max(len(ids), len(lps))): |
| telemetry_rows.append({"episode_id": eid, "recording_id": identity(str(path.parent.parent / "result.json")), "source_path": str((path.parent.parent / "result.json").relative_to(self.root)), "coordinate": f"$.agent_result.rollout_details[{i}].sequence[{j}]", **telemetry({"completion_token_ids": ids[j] if j < len(ids) else [], "logprobs": lps[j] if j < len(lps) else []})}) |
| else: |
| telemetry_rows.append({"episode_id": eid, "recording_id": identity(str(path.parent.parent / "result.json")), "source_path": str((path.parent.parent / "result.json").relative_to(self.root)), "coordinate": f"$.agent_result.rollout_details[{i}]", **telemetry(batch)}) |
| self.token_rows.extend(telemetry_rows) |
| self.event_rows[collection].extend(all_events) |
| if len(self.event_rows[collection]) >= 10000: |
| self.flush_events(collection) |
| relative = canonical["path"].removeprefix("rl_experiments/artifacts/qwen_rollout_trajectories/") |
| qm = self.qwen_metrics.get(relative, {}) |
| run = Path(canonical["experiment"]).name |
| task = result.get("task_name") or qm.get("task") or info.get("task_name") |
| if not task: |
| match = re.search(r"/([^/]+)_" + UUID.pattern, canonical["path"]) |
| task = match.group(1) if match else path.parent.parent.name.split("__")[0] if path.parent.name == "agent" else path.stem |
| vr = result.get("verifier_result") or {} |
| rewards = vr.get("rewards") or {} |
| exception = result.get("exception_info") |
| |
| |
| reward = rewards.get("reward") |
| if reward is None and rewards: |
| reward = rewards.get("score") |
| ce = [e for e in all_events if e["canonical_view"]] |
| cmds = [e["command"].strip() for e in ce if e["command"].strip()] |
| cmd_counts = collections.Counter(cmds) |
| observed_text = "\n".join(e["observation"] + "\n" + e["text"] for e in ce).lower() |
| parser_errors = sum(bool(re.search(r"parsing errors|no tool calls found|formaterror|was not parsed|parsingerror", e["observation"].lower())) for e in ce) |
| model = canonical["model"] or (info.get("config", {}).get("model", {}).get("model_name")) or qm.get("model_name", "") |
| model_revision = kwargs.get("checkpoint_revision", metadata.get("model_revision")) |
| stage = qm.get("stage") or ("generation_only_gate" if "gate" in run else "stress" if "stress" in run else "diagnostic" if "diag" in run else "rollout_collection") |
| if collection == "qwen" and stage == "gate": |
| stage = "generation_only_gate" |
| submission = info.get("submission") |
| stats = info.get("model_stats") or {} |
| mode = "detect" if collection == "qwen" else next((m for m in ["detect", "patch", "exploit"] if re.search(r"(?:[/_-]|^)" + m + r"(?:[/_-]|$)", canonical["path"])), "coding" if collection == "olmo" else "unknown") |
| aligned = [t for t in telemetry_rows if t["alignment"] == "aligned"] |
| total_tokens = sum(t["token_count"] for t in aligned) |
| row = {"episode_id": eid, "episode_key": key, "collection": collection, "task": task, |
| "task_checksum": result.get("task_checksum"), "task_mode": mode, "run": run, |
| "collection_stage": stage, "model": model, "model_revision": model_revision, |
| "model_family": kwargs.get("model_family", metadata.get("model_family")), |
| "checkpoint_stage": kwargs.get("model_stage", metadata.get("model_stage")), |
| "harness": kwargs.get("harness_id", canonical["agent"]), |
| "canonical_source_path": canonical["path"], "canonical_recording_id": identity(canonical["path"]), |
| "recording_views": len(group), "status": canonical["status"], "assistant_turns": canonical["assistant_turns"], |
| "events": len(ce), "commands": len(cmds), "unique_commands": len(cmd_counts), |
| "max_command_repetitions": max(cmd_counts.values(), default=0), |
| "text_chars": sum(len(e["text"]) for e in ce), "observation_chars": sum(len(e["observation"]) for e in ce), |
| "rejected_responses": sum(e["rejected_response"] for e in all_events), |
| "reported_prompt_tokens": nullable_number(canonical["reported_prompt_tokens"]), |
| "reported_completion_tokens": nullable_number(canonical["reported_completion_tokens"]), |
| "context_limit": kwargs.get("max_seq_len", self.qwen_summaries.get(run, {}).get("max_seq_len", config.get("model", {}).get("model_kwargs", {}).get("max_model_len"))), |
| "output_limit": kwargs.get("max_output_tokens", ((canonical_obj or {}).get("agent", {}).get("extra", {}).get("llm_kwargs", {}).get("max_tokens")) if isinstance(canonical_obj, dict) else None), |
| "recorded_cost_usd": (result.get("agent_result") or {}).get("cost_usd", stats.get("instance_cost", stats.get("cost"))), |
| "reward": reward, "outcome_status": "observed" if rewards else "unknown", |
| "verifier_results_json": dumps(rewards), "exception_json": dumps(exception), |
| "submission_present": bool(submission) if "submission" in info else None, |
| "exit_status": info.get("exit_status"), "parser_error_indicators": parser_errors, |
| "exception_recorded": bool(exception), |
| "infrastructure_failure_indicator": bool(re.search(r"docker|sandbox|connection|environment.*(?:error|timeout)|verifier.*timeout|http.*error|rate.limit", dumps(exception).lower())), |
| "budget_exhaustion_indicator": bool(re.search(r"context.length|maximum context|step.limit|turn.budget|output.length|token.limit|cost.limit|timeout", observed_text + dumps(exception).lower() + str(info.get("exit_status", "")).lower())), |
| "retry_count": metadata.get("request_retry_count"), |
| "aligned_sequences": len(aligned), "misaligned_sequences": sum(t["alignment"] == "invalid_or_misaligned" for t in telemetry_rows), |
| "aligned_selected_tokens": total_tokens, |
| "selected_token_surprisal_nats": sum(t["nll_sum"] for t in aligned) / total_tokens if total_tokens else None, |
| "detail_path": f"recordings/{collection}/{eid}.json.gz", |
| "retained_experiment2_id": canonical["retained_experiment2_id"] or None, |
| "parser_version": VERSION} |
| row.update({f"indicator_{k}_commands": sum(indicators(c)[k] for c in cmds) for k in indicators("")}) |
| self.episodes.append(row) |
| self.bundle(row["detail_path"], {"episode": row, "recordings": views, "events": all_events, "token_diagnostics": telemetry_rows}) |
| if qm: |
| self.annotations.append({"collection": collection, "episode_id": eid, "subject_id": eid, "kind": "existing_command_analysis", "evidence_layer": "derived_observable_indicators", "source_path": "rl_experiments/artifacts/qwen_rollout_trajectories/analysis/trajectory_metrics.jsonl", "source_coordinate": relative, "data_json": dumps(self.redactor.clean(qm, relative))}) |
| if n % 100 == 0: |
| print(f" {n}/{len(grouped)}", flush=True) |
| for c in PROJECTS.values(): |
| self.flush_events(c) |
|
|
| def bundle(self, relative, obj): |
| path = self.out / relative |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with path.open("wb") as handle: |
| with gzip.GzipFile(fileobj=handle, mode="wb", mtime=0, compresslevel=5) as zipped: |
| zipped.write(dumps(obj).encode()) |
|
|
| def import_forest(self): |
| for name, kind, expected in [("train_sft_process_all_actions.jsonl", "process", 8633), ("train_sft_gold_clean_final.jsonl", "final", 218), ("rejected_or_unparsed_records.jsonl", "rejection", 74)]: |
| path = self.public / name |
| raw = path.read_bytes() |
| rows = [json.loads(l) for l in raw.splitlines() if l.strip()] |
| assert len(rows) == expected |
| clean = self.redactor.clean(rows, f"{FOREST_REPO}@{FOREST_REV}/{name}") |
| relative = f"derived/forest/{name}.gz" |
| |
| target = self.out / relative |
| target.parent.mkdir(parents=True, exist_ok=True) |
| text = "\n".join(dumps(o) for o in clean) + "\n" |
| with target.open("wb") as h: |
| with gzip.GzipFile(fileobj=h, mode="wb", mtime=0) as z: |
| z.write(text.encode()) |
| self.sources.append({"source_path": name, "collection": "forest", "role": "public_derived_" + kind, "source_sha256": digest(raw), "source_bytes": len(raw), "publication_sha256": digest(text.encode()), "publication_bytes": len(text.encode()), "public_path": relative, "source_repository": FOREST_REPO, "source_revision": FOREST_REV, "parser_version": VERSION}) |
| for line, o in enumerate(clean, 1): |
| meta = o.get("metadata") or o |
| source_path = meta.get("source_path", "") |
| k = self.forest_identity(source_path) |
| candidates = self.forest_keys.get(k, set()) if k else set() |
| eid = next(iter(candidates)) if len(candidates) == 1 else None |
| match_status = "verified_trial_uuid_and_branch" if eid else "ambiguous" if candidates else "unmatched_source" if source_path else "gold_without_trajectory" |
| example_id = o.get("id") or f"rejection:{line}" |
| if source_path: |
| self.joins.append({"example_id": example_id, "example_kind": kind, "public_source_path": source_path, "episode_id": eid, "match_status": match_status, "candidate_count": len(candidates), "identity_json": dumps(k), "source_revision": FOREST_REV}) |
| messages = o.get("messages") or [] |
| self.examples.append({"collection": "forest", "example_id": example_id, "example_kind": kind, "episode_id": eid, |
| "task": o.get("audit_id"), "task_mode": o.get("task_mode"), "source": o.get("source"), |
| "match_status": match_status, "truncated": bool(meta.get("truncated") or meta.get("assistant_truncated") or meta.get("user_truncated")), |
| "messages_json": dumps(messages), "metadata_json": dumps(meta), "source_path": name, "source_line": line, |
| "source_repository": FOREST_REPO, "source_revision": FOREST_REV, "detail_path": relative, |
| "data_json": dumps(o) if kind == "rejection" else None}) |
| for name in ["README.md", "dataset_summary.json", "audit_splits.json", ".gitattributes"]: |
| p = self.public / name |
| raw = p.read_bytes() |
| clean = self.redactor.text(raw.decode(), name, "$") |
| target = self.out / "provenance/forest_public" / name |
| target.parent.mkdir(parents=True, exist_ok=True) |
| target.write_text(clean) |
| self.sources.append({"source_path": name, "collection": "forest", "role": "public_source_metadata", "source_sha256": digest(raw), "source_bytes": len(raw), "publication_sha256": digest(clean.encode()), "publication_bytes": len(clean.encode()), "public_path": str(target.relative_to(self.out)), "source_repository": FOREST_REPO, "source_revision": FOREST_REV, "parser_version": VERSION}) |
|
|
| def import_judges(self): |
| base = self.root / "Olmo-RewardHacking/results/judge-baseline-20260910" |
| packet_path = base / "experiment1/frozen-packets.jsonl" |
| packets, src, errors = self.read(packet_path, "derived_judge_packets", "olmo") |
| assert not errors and len(packets) == 144 |
| for wrapped in packets: |
| o = wrapped["value"] |
| pid = o["packet_id"] |
| relative = f"derived/olmo/packets/{pid}.json.gz" |
| self.bundle(relative, o) |
| self.packet_map[o["run_id"]] = pid |
| self.examples.append({"collection": "olmo", "example_id": pid, "example_kind": "experiment1_judge_packet", "episode_id": None, |
| "task": (o["packet"].get("task") or {}).get("task_id") if isinstance(o["packet"].get("task"), dict) else str(o["packet"].get("task")), |
| "task_mode": "coding", "match_status": "original_raw_run_missing", "truncated": None, |
| "metadata_json": dumps({k:v for k,v in o.items() if k != "packet"}), "source_path": src["source_path"], "source_line": wrapped["source_line"], "detail_path": relative}) |
| |
| for name in ["experiment1-luna-judgments.jsonl", "experiment1/gpt5-trajectory-judgments.jsonl", "experiment1/gpt5-solution-judgments.jsonl", "experiment2-luna-judgments.jsonl", "experiment1-gpt5-vs-luna.jsonl", "experiment1-luna-judgments.attempts.jsonl"]: |
| p = base / name |
| rows, src, errors = self.read(p, "existing_judge_labels", "olmo") |
| assert not errors |
| self.bundle(f"derived/olmo/{p.name}.gz", rows) |
| retained = {e["retained_experiment2_id"]:e["episode_id"] for e in self.episodes if e["retained_experiment2_id"]} |
| for row in rows: |
| o = row["value"] |
| pid = o.get("packet_id") or self.packet_map.get(o.get("run_id")) |
| |
| |
| eid = retained.get(o.get("trajectory_id")) |
| self.annotations.append({"collection": "olmo", "episode_id": eid, "subject_id": pid or o.get("custom_id") or o.get("run_id"), |
| "kind": p.stem, "evidence_layer": "judge_interpretation" if "attempts" not in name else "judge_execution_log", "source_path": src["source_path"], "source_coordinate": f"line:{row['source_line']}", "data_json": dumps(o)}) |
| self.coverage.append({"collection": "olmo", "unit": "judge_packet_population", "status": "original_raw_run_missing", "count": 144, "source_path": "Olmo-RewardHacking/runs/think-instruct-pilot/20260822T114511Z", "details_json": dumps({"packets_available": True, "judge_labels_available": True})}) |
|
|
| def import_auxiliary(self): |
| datasets = pd.read_csv(self.root / "trajectory_inventory/datasets.csv") |
| p = self.root / datasets[datasets.kind == "transition_log"].iloc[0].path |
| rows, src, errors = self.read(p, "auxiliary_q09_transition_log", "q09") |
| assert not errors and len(rows) == 446 |
| self.bundle("auxiliary/q09_transitions.json.gz", rows) |
| write_table(self.out, "q09_transitions", [{"transition_index": r["source_line"] - 1, "source_path": src["source_path"], "source_line": r["source_line"], "data_json": dumps(r["value"])} for r in rows]) |
| for p in sorted(self.qwen_base.rglob("*.json")): |
| if p.name == "trajectory.json": |
| continue |
| |
| if "trials" in p.parts: |
| continue |
| obj, src, _ = self.read(p, "qwen_collection_metadata", "qwen") |
| self.bundle("provenance/qwen/" + identity(src["source_path"]) + ".json.gz", obj) |
| if p.name.endswith("summary.json"): |
| self.annotations.append({"collection": "qwen", "episode_id": None, "subject_id": p.parent.name, "kind": p.stem, "evidence_layer": "recorded_generation_gate", "source_path": src["source_path"], "source_coordinate": "$", "data_json": dumps(obj)}) |
| remote = json.loads((self.qwen_base / "remote_index.json").read_text()) |
| extant = {str(p.relative_to(self.qwen_base)) for p in (self.qwen_base / "runs").rglob("trajectory.json")} |
| missing = [p for paths in remote["runs"].values() for p in paths if p not in extant] |
| assert len(missing) == 368 |
| for p in missing: |
| self.coverage.append({"collection": "qwen", "unit": "candidate_trial", "status": "trajectory_missing_at_archive_time", "source_path": p, "details_json": dumps({"outcome_status": "unknown", "archive_time": "2026-08-17"})}) |
| base = self.root / "rl_experiments/artifacts/qwen38_27b_64k_gate_001" |
| rows, src, errors = self.read(base / "analysis/trajectory_metrics.jsonl", "qwen_27b_summary_only", "qwen") |
| assert not errors and len(rows) == 64 |
| self.bundle("auxiliary/qwen27b_summary_only.json.gz", rows) |
| write_table(self.out, "qwen27b_summary_only", [{"summary_index": i, "run": "qwen38_27b_64k_gate_001", "data_json": dumps(r["value"])} for i,r in enumerate(rows)]) |
| for i, r in enumerate(rows): |
| self.coverage.append({"collection": "qwen", "unit": "summary_record", "status": "27b_summary_only", "source_path": src["source_path"], "source_line": r["source_line"], "details_json": dumps(r["value"])}) |
| for name in ["gate_summary.json", "manifest.json", "analysis/aggregate.json"]: |
| obj, src, _ = self.read(base / name, "qwen_27b_summary_metadata", "qwen") |
| self.bundle("provenance/qwen/" + identity(src["source_path"]) + ".json.gz", obj) |
| if name == "gate_summary.json": |
| self.annotations.append({"collection": "qwen", "episode_id": None, "subject_id": base.name, "kind": "gate_summary", "evidence_layer": "recorded_generation_gate_summary_only", "source_path": src["source_path"], "source_coordinate": "$", "data_json": dumps(obj)}) |
|
|
| def finish(self): |
| for c in PROJECTS.values(): |
| write_table(self.out, c, [e for e in self.episodes if e["collection"] == c]) |
| for name, rows in [("sources", self.sources), ("coverage", self.coverage), ("annotations", self.annotations), ("examples", self.examples), ("forest_joins", self.joins), ("token_diagnostics", self.token_rows), ("redactions", self.redactor.rows)]: |
| write_table(self.out, name, rows) |
| |
| self.selected.to_csv(self.out / "provenance/recording_inventory.csv", index=False) |
| repos = {} |
| for project in PROJECTS: |
| def git(*args): |
| p = subprocess.run(["git", "-C", str(self.root / project), *args], capture_output=True, text=True) |
| return p.stdout.strip() if p.returncode == 0 else None |
| repos[project] = {"head": git("rev-parse", "HEAD"), "dirty": bool(git("status", "--porcelain")), "remote": git("remote", "get-url", "origin")} |
| counts = collections.Counter(e["collection"] for e in self.episodes) |
| assert dict(counts) == {"olmo": 570, "qwen": 510, "forest": 371}, counts |
| assert len(set(e["episode_id"] for e in self.episodes)) == len(self.episodes) |
| summary = {"schema_version": VERSION, "repository": REPO, "episode_counts": dict(counts), |
| "recording_views": self.selected.groupby("project").size().to_dict(), |
| "source_files": len(self.sources), "examples": dict(collections.Counter(e["example_kind"] for e in self.examples)), |
| "join_status": dict(collections.Counter(j["match_status"] for j in self.joins)), |
| "token_alignment": dict(collections.Counter(t["alignment"] for t in self.token_rows)), |
| "coverage": dict(collections.Counter(c["status"] for c in self.coverage)), |
| "redaction_operations": len(self.redactor.rows), "source_repositories": self.redactor.clean(repos, "git_provenance"), |
| "forest_public_repository": FOREST_REPO, "forest_public_revision": FOREST_REV, |
| "scope": "Rollout collections. Qwen generation gates do not demonstrate RL updates. Derived examples are not additional episodes."} |
| (self.out / "provenance/build_summary.json").write_text(json.dumps(summary, indent=2) + "\n") |
| print(json.dumps(summary, indent=2), flush=True) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--root", type=Path, default=Path("/home/experiments_base")) |
| parser.add_argument("--forest-public", type=Path, default=Path("/home/experiments_base/trajectory_study_inputs/forest_public")) |
| parser.add_argument("--out", type=Path, default=Path(__file__).resolve().parents[1]) |
| args = parser.parse_args() |
| (args.out / "provenance").mkdir(parents=True, exist_ok=True) |
| builder = Builder(args.root, args.forest_public, args.out) |
| builder.build_episodes() |
| builder.import_forest() |
| builder.import_judges() |
| builder.import_auxiliary() |
| builder.finish() |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
