| |
| """Gather the artifacts worth keeping from auto-impl and RSIChallenge into one |
| upload-ready tree. |
| |
| The output is a single self-describing folder that can be pushed to the |
| HuggingFace dataset repo `Jerry999/RSIChallenge` by |
| `scripts/upload_artifacts_hf.sh`, and that is also the thing to hand to the |
| babel server or to a future reader who has neither cluster. |
| |
| Move or copy -- and why it differs per artifact |
| ----------------------------------------------- |
| The instruction was to *move*, not copy, so that we end up with one organised |
| home for each file rather than a second scattered duplicate. That is right for |
| run artifacts. It is wrong for anything git tracks, and it is wrong for a file |
| a live pipeline still opens. So the rule is applied per artifact: |
| |
| MOVE, no symlink `solve_out_sanitized.txt`, `solve_parsed_sanitized.txt` |
| These are byte-identical duplicates of the unsanitized |
| files next to them (verified across every run: 40/40 |
| identical, and the upstream sanitizer only redacts values |
| from `.env`, none of which appear). The unsanitized copy |
| stays where the analysis pipeline reads it, the duplicate |
| moves here. This genuinely reclaims space and breaks |
| nothing. |
| |
| MOVE + symlink `metrics.json`, `prompt.txt`, `time_taken.txt`, |
| `final_eval_*.txt`, and the RSIChallenge run directories. |
| Single copies that `analysis/` and the RSIChallenge |
| scripts still open by path, so the original path is left |
| pointing into this tree. Nothing is duplicated and |
| nothing breaks. `--undo` reverses it. |
| |
| COPY Documents and code under git. Moving them would delete |
| them from a tracked working tree, which is never what |
| "tidy up" means. Git already stores them once; the copy |
| here exists so the dataset stands alone. |
| |
| Deliberately left out |
| --------------------- |
| `final_model/` the trained checkpoints. Hundreds of GB across 168 runs. |
| `agent_home/`, `task/` |
| the agent's workspace and the training data it built -- |
| tens of GB, and `task/` holds benchmark test items that |
| were deliberately placed there for the contamination |
| self-check. Publishing it would redistribute test data. |
| `hf_cache/`, `containers/`, `apptainer/` |
| third-party weights and images, not ours to publish. |
| `_aborted_*` preempted stubs with no `metrics.json`. Counted in the |
| manifest, not shipped. |
| |
| Nothing is uploaded from here. This machine's sandbox cannot reach |
| huggingface.co; the upload is a separate script the user runs. |
| |
| python scripts/compose_artifacts.py --dry-run # plan only, touch nothing |
| python scripts/compose_artifacts.py # build the tree |
| python scripts/compose_artifacts.py --undo # put the moved files back |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import os |
| import re |
| import shutil |
| import sys |
| from datetime import datetime, timezone |
| from pathlib import Path |
|
|
| LUSTRE = Path("/lustre-storage/fsx_2/user/jiaruiliu/ptb-data") |
| HOME = Path("/home/jiaruiliu") |
| REPOS = HOME / "local/git-repos" |
| |
| |
| DEFAULT_STAGING = Path("/lustre-storage/fsx_2/user/jiaruiliu/hf_upload/RSIChallenge") |
|
|
| |
| PTB_SWEEPS = [ |
| ("claude_run1", LUSTRE / "results/claude_non_api_claude-opus-5_10h_run1", "claude_opus5_10h_run1"), |
| ("claude_run2", LUSTRE / "results/claude_non_api_claude-opus-5_10h_run2", "claude_opus5_10h_run2"), |
| ("codex_run1", LUSTRE / "results_codex_sdk_gpt-5.6-sol_20261006/codex_sdk_gpt-5.6-sol_10h_run1", |
| "codex_gpt56sol_10h_run1"), |
| ("direct_baseline", LUSTRE / "results/baseline_direct_inference_zeroshot", "direct_inference_zeroshot"), |
| ] |
|
|
| |
| |
| |
| MOVE_DEDUP = {"solve_out_sanitized.txt": "trace.txt", |
| "solve_parsed_sanitized.txt": "trace_parsed.txt"} |
| MOVE_SYMLINK = {"metrics.json": "metrics.json", |
| "prompt.txt": "prompt.txt", |
| "time_taken.txt": "time_taken.txt"} |
|
|
| SECRET_PATTERNS = [ |
| re.compile(rb"sk-[A-Za-z0-9_-]{20,}"), |
| re.compile(rb"ghp_[A-Za-z0-9]{20,}"), |
| re.compile(rb"hf_[A-Za-z0-9]{20,}"), |
| re.compile(rb"AKIA[0-9A-Z]{12,}"), |
| re.compile(rb"-----BEGIN [A-Z ]*PRIVATE KEY"), |
| re.compile(rb"eyJ[A-Za-z0-9_-]{30,}\.[A-Za-z0-9_-]{20,}\."), |
| ] |
| |
| NEVER = re.compile(r"(^|/)(\.env|oauth_token|api_keys\.json|\.netrc|id_rsa|token)$") |
|
|
|
|
| class Plan: |
| """Collects what will happen so --dry-run and the real run share one path.""" |
|
|
| def __init__(self, dry: bool): |
| self.dry = dry |
| self.moved: list[tuple[str, str, bool]] = [] |
| self.copied: list[tuple[str, str]] = [] |
| self.skipped: dict[str, int] = {} |
|
|
| def skip(self, why: str) -> None: |
| self.skipped[why] = self.skipped.get(why, 0) + 1 |
|
|
| def move(self, src: Path, dst: Path, symlink_back: bool) -> None: |
| if NEVER.search(str(src)): |
| self.skip("credential-shaped filename") |
| return |
| self.moved.append((str(src), str(dst), symlink_back)) |
| if self.dry: |
| return |
| dst.parent.mkdir(parents=True, exist_ok=True) |
| if dst.exists(): |
| if src.is_symlink(): |
| return |
| dst.unlink() |
| shutil.move(str(src), str(dst)) |
| if symlink_back: |
| src.symlink_to(dst) |
|
|
| def copy(self, src: Path, dst: Path) -> None: |
| if NEVER.search(str(src)): |
| self.skip("credential-shaped filename") |
| return |
| self.copied.append((str(src), str(dst))) |
| if self.dry: |
| return |
| dst.parent.mkdir(parents=True, exist_ok=True) |
| if src.is_dir(): |
| shutil.copytree(src, dst, dirs_exist_ok=True, |
| ignore=shutil.ignore_patterns(".git", "__pycache__", "*.pyc", |
| ".env", "oauth_token", "api_keys.json")) |
| else: |
| shutil.copy2(src, dst) |
|
|
|
|
| def stage_ptb_runs(plan: Plan, staging: Path) -> dict: |
| """Per-run artifacts from the four PostTrainBench sweeps.""" |
| stats = {} |
| for label, root, destname in PTB_SWEEPS: |
| if not root.is_dir(): |
| plan.skip(f"missing sweep root {label}") |
| continue |
| kept = aborted = 0 |
| for run in sorted(p for p in root.iterdir() if p.is_dir()): |
| if run.name.startswith("_aborted"): |
| aborted += len(list(run.iterdir())) |
| continue |
| |
| groups = [run] if not run.name.startswith("_") else sorted( |
| p for p in run.iterdir() if p.is_dir()) |
| for d in groups: |
| if not (d / "metrics.json").is_file(): |
| plan.skip("run without metrics.json") |
| continue |
| tag = d.name if d is run else f"extra/{d.name}" |
| out = staging / "auto-impl/runs" / destname / tag |
| for name, newname in MOVE_DEDUP.items(): |
| if (d / name).is_file() and not (d / name).is_symlink(): |
| plan.move(d / name, out / newname, symlink_back=False) |
| for name, newname in MOVE_SYMLINK.items(): |
| if (d / name).is_file() and not (d / name).is_symlink(): |
| plan.move(d / name, out / newname, symlink_back=True) |
| for ev in sorted(d.glob("final_eval_*.txt")): |
| if not ev.is_symlink(): |
| plan.move(ev, out / ev.name, symlink_back=True) |
| kept += 1 |
| stats[label] = {"runs_staged": kept, "aborted_entries_skipped": aborted} |
| return stats |
|
|
|
|
| def stage_repo(plan: Plan, repo: Path, staging: Path, subdirs: list[str]) -> None: |
| for sub in subdirs: |
| src = repo / sub |
| if src.exists(): |
| plan.copy(src, staging / repo.name / sub) |
|
|
|
|
| def stage_rsi_runs(plan: Plan, staging: Path) -> None: |
| """RSIChallenge run outputs: moved wholesale, with the original path symlinked.""" |
| base = HOME / "rsi_runs" |
| if not base.is_dir(): |
| plan.skip("no rsi_runs directory") |
| return |
| for sub in sorted(p for p in base.iterdir() if p.is_dir()): |
| if sub.is_symlink(): |
| continue |
| plan.move(sub, staging / "RSIChallenge/rsi_runs" / sub.name, symlink_back=True) |
|
|
|
|
| def scan_secrets(staging: Path, limit_mb: int = 64) -> list[str]: |
| """Grep the staged tree for credential-shaped strings. Gate, not decoration.""" |
| hits = [] |
| for p in staging.rglob("*"): |
| if not p.is_file() or p.is_symlink(): |
| continue |
| if p.stat().st_size > limit_mb * 1024 * 1024: |
| hits.append(f"{p} (NOT SCANNED: larger than {limit_mb} MB)") |
| continue |
| try: |
| blob = p.read_bytes() |
| except OSError: |
| continue |
| for pat in SECRET_PATTERNS: |
| if pat.search(blob): |
| hits.append(f"{p} matches {pat.pattern.decode(errors='replace')}") |
| break |
| return hits |
|
|
|
|
| def write_manifest(staging: Path, stats: dict, plan: Plan) -> dict: |
| files = [p for p in staging.rglob("*") if p.is_file() and not p.is_symlink()] |
| total = sum(p.stat().st_size for p in files) |
| by_top: dict[str, dict] = {} |
| for p in files: |
| top = p.relative_to(staging).parts[0] |
| e = by_top.setdefault(top, {"files": 0, "bytes": 0}) |
| e["files"] += 1 |
| e["bytes"] += p.stat().st_size |
| manifest = { |
| "composed_utc": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"), |
| "composed_on": "aws server", |
| "target_repo": "Jerry999/RSIChallenge (HuggingFace dataset)", |
| "total_files": len(files), |
| "total_bytes": total, |
| "total_mb": round(total / 1048576, 1), |
| "by_section": {k: {**v, "mb": round(v["bytes"] / 1048576, 1)} for k, v in sorted(by_top.items())}, |
| "ptb_sweeps": stats, |
| "moved": len(plan.moved), |
| "copied": len(plan.copied), |
| "skipped": plan.skipped, |
| } |
| (staging / "MANIFEST.json").write_text(json.dumps(manifest, indent=1)) |
| return manifest |
|
|
|
|
| README = """# RSIChallenge — artifacts / 工件集 |
| |
| **Composed on the aws server.** Source repos: [`auto-impl`](https://github.com/jiarui-liu/auto-impl) |
| (PostTrainBench agent study) and `RSIChallenge` (recursive self-improvement study). |
| Built by `scripts/compose_artifacts.py`; inventory in `MANIFEST.json`. |
| |
| ## 高层要点 / Takeaways |
| |
| 1. **这是两个项目的"可移植产物"合集** —— 能跨机器、跨时间复用的那部分: |
| agent trace、逐 run 指标、分析中间产物、全部文档。 |
| 2. **不含模型权重、agent 工作区和训练数据。** 前者有数百 GB,后者含被刻意放进沙箱的 |
| benchmark 测试题(发布等于再分发测试集)。详见下面"未收录"。 |
| 3. **trace 是核心资产**:168 个 run、每个 10 小时的自主研究过程,逐条工具调用与输出。 |
| 4. 每个 run 目录自带 `metrics.json`(最终分数)与 `prompt.txt`(任务原文),可独立使用。 |
| |
| > This is the portable subset of two projects: agent traces, per-run metrics, analysis |
| > intermediates and all documents. It deliberately excludes model weights, agent workspaces and |
| > the training data the agents built — the last of those contains benchmark test items that were |
| > placed in the sandbox on purpose for a contamination self-check, so publishing it would |
| > redistribute test data. The traces are the asset: 168 runs of ten-hour autonomous research, |
| > tool call by tool call. |
| |
| ## Layout / 结构 |
| |
| ``` |
| auto-impl/ |
| docs/ 研究文档:结果、综述、总报告(中英双语) |
| analysis/ trace 分析管线的代码与产物(探针、噪声、泄漏审计) |
| scripts/ 提交与复现脚本 |
| runs/ |
| claude_opus5_10h_run1/<task>_<model>_<timestamp>/ |
| claude_opus5_10h_run2/... (第二个种子;extra/ 下是同配置重复) |
| codex_gpt56sol_10h_run1/... |
| direct_inference_zeroshot/... (不训练的基线) |
| ├── trace.txt 完整 agent trace(每行一个事件,带 ISO 时间戳) |
| ├── trace_parsed.txt 解析后的可读版本 |
| ├── metrics.json 最终分数 |
| ├── prompt.txt 给 agent 的任务原文 |
| ├── final_eval_*.txt 评测日志 |
| └── time_taken.txt |
| RSIChallenge/ |
| docs/ 研究文档 |
| experiments/ 实验代码 |
| rsi_runs/ run 产物(traces/ 与 substeps/) |
| ``` |
| |
| ## 未收录,以及为什么 / What is not here |
| |
| | 未收录 | 原因 | |
| |---|---| |
| | `final_model/` | 168 个 run 的训练后权重,数百 GB | |
| | `agent_home/`、`task/` | agent 工作区与它自己构建的训练数据;**`task/` 含 benchmark 测试题**(沙箱里刻意放的,供 agent 自查污染),发布等于再分发测试集 | |
| | `hf_cache/`、容器镜像 | 第三方权重与镜像,不是我们的东西 | |
| | `_aborted_*` | 被抢占的残缺 run,没有 `metrics.json`;数量记在 `MANIFEST.json` 里 | |
| |
| ## 可比性警告 / Caveats |
| |
| - `arenahardwriting` 与 `healthbench` 由**本地 Qwen3.6-27B** 评分,顶替 OpenAI `gpt-5-mini` |
| (集群连不上)。**绝对值与已发表数字不可比** —— zero-shot 下本地 judge 给 0.034、论文给 0.095。 |
| 两个 agent 用的是同一个替代 judge,所以**它们之间**可比。 |
| - agent 沙箱是刻意**禁网**的(`--network=none`),上游官方设定是联网无限制。 |
| - 逐格比较的 95% 噪声门槛是 **0.125**(跨 sweep)/ **0.084**(同 sweep 内); |
| 小于它的分差不构成证据。方法见 `auto-impl/docs/results/seed_variance_run1_run2_2026-10.md`。 |
| """ |
|
|
|
|
| def main() -> None: |
| ap = argparse.ArgumentParser(description=__doc__, |
| formatter_class=argparse.RawDescriptionHelpFormatter) |
| ap.add_argument("--staging", type=Path, default=DEFAULT_STAGING) |
| ap.add_argument("--dry-run", action="store_true", help="print the plan, change nothing") |
| ap.add_argument("--undo", action="store_true", help="restore files that were moved + symlinked") |
| args = ap.parse_args() |
|
|
| if args.undo: |
| return undo(args.staging) |
|
|
| plan = Plan(args.dry_run) |
| if not args.dry_run: |
| args.staging.mkdir(parents=True, exist_ok=True) |
|
|
| stats = stage_ptb_runs(plan, args.staging) |
| stage_repo(plan, REPOS / "auto-impl", args.staging, |
| ["docs", "analysis", "scripts", "src", "CLAUDE.md"]) |
| stage_repo(plan, REPOS / "RSIChallenge", args.staging, |
| ["docs", "experiments", "scripts", "CLAUDE.md"]) |
| stage_rsi_runs(plan, args.staging) |
|
|
| print(f"{'PLAN (nothing changed)' if args.dry_run else 'COMPOSED'}") |
| print(f" moved : {len(plan.moved)} ({sum(1 for *_, s in plan.moved if s)} with a symlink left behind)") |
| print(f" copied : {len(plan.copied)}") |
| for why, n in sorted(plan.skipped.items()): |
| print(f" skipped: {n:5d} {why}") |
| for label, s in stats.items(): |
| print(f" {label:18s} {s['runs_staged']:3d} runs staged, " |
| f"{s['aborted_entries_skipped']} aborted entries skipped") |
| if args.dry_run: |
| print(f"\nWould write to {args.staging}") |
| return |
|
|
| (args.staging / "README.md").write_text(README) |
| manifest = write_manifest(args.staging, stats, plan) |
| print(f"\n staged total: {manifest['total_files']} files, {manifest['total_mb']} MB") |
| for k, v in manifest["by_section"].items(): |
| print(f" {k:16s} {v['files']:6d} files {v['mb']:8.1f} MB") |
|
|
| print("\nScanning the staged tree for credentials ...") |
| hits = scan_secrets(args.staging) |
| gate = args.staging / ".secret-scan-passed" |
| if hits: |
| gate.unlink(missing_ok=True) |
| print(f" FAILED -- {len(hits)} suspicious file(s). Upload is blocked:") |
| for h in hits[:20]: |
| print(f" {h}") |
| sys.exit(1) |
| gate.write_text(manifest["composed_utc"] + "\n") |
| print(" clean -- no credential-shaped strings found.") |
| print(f"\nNext: bash scripts/upload_artifacts_hf.sh (run it on a machine that reaches huggingface.co)") |
|
|
|
|
| def undo(staging: Path) -> None: |
| """Walk the original tree and pull every symlink-into-staging back home.""" |
| restored = 0 |
| for root in [p for _, p, _ in PTB_SWEEPS] + [HOME / "rsi_runs"]: |
| if not root.exists(): |
| continue |
| for p in root.rglob("*"): |
| if not p.is_symlink(): |
| continue |
| target = Path(os.readlink(p)) |
| if staging not in target.parents: |
| continue |
| p.unlink() |
| shutil.move(str(target), str(p)) |
| restored += 1 |
| print(f"restored {restored} path(s) from {staging}") |
| print("note: the de-duplicated `*_sanitized.txt` copies are not restored -- " |
| "their unsanitized twins were never moved and are byte-identical.") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
