"""Modal launcher for the official Prime RL training and inference processes.""" import modal from pathlib import Path ROOT = Path(__file__).resolve().parent ACTIVE_PROFILE = 'rl-next' ACTIVE_WORKSPACE = 'susindra-turtlelabs' if modal.is_local(): from task_source import contract_digest CONTRACT = contract_digest() else: import os CONTRACT = os.environ["WORKSPACE_CONTRACT_SHA256"] task_cache = modal.Volume.from_name("workspace-agent-task-cache", create_if_missing=True) RELEASE_IMAGE = "ghcr.io/primeintellect-ai/prime-rl@sha256:bd810178d034ea134663be6d21b6269af02e88b4a54517d481a1874b139af52f" app = modal.App("workspace-prime-training-smoke") outputs = modal.Volume.from_name("workspace-agent-training") cache = modal.Volume.from_name("workspace-agent-hf-cache") image = (modal.Image.from_registry(RELEASE_IMAGE).entrypoint([]) .dockerfile_commands("USER root") .apt_install("git", "openssh-client") .run_commands("uv pip install --exclude-newer-package modal=2026-10-30 --exclude-newer-package synchronicity=2026-10-30 --python /app/.venv/bin/python 'verifiers[harbor,modal]==0.4.1.dev12' 'renderers[multimodal]==0.1.13.dev5' 'harbor==0.24.0' 'modal==1.6.3'") .env({"WORKSPACE_CONTRACT_SHA256": CONTRACT}) .add_local_file(ROOT / "task_source.py", "/workspace-smoke/task_source.py", copy=True) .add_local_file(ROOT / "task-source.json", "/workspace-smoke/task-source.json", copy=True) .add_local_file(ROOT / "bash_timeout.py", "/workspace-smoke/bash_timeout.py", copy=True) .run_commands("/app/.venv/bin/python /workspace-smoke/bash_timeout.py") .add_local_file(ROOT / "compaction_task.py", "/workspace-smoke/compaction_task.py", copy=True) .run_commands("/app/.venv/bin/python /workspace-smoke/compaction_task.py") .add_local_file(ROOT / "bash_recovery.py", "/workspace-smoke/bash_recovery.py", copy=True) .run_commands("/app/.venv/bin/python /workspace-smoke/bash_recovery.py") .add_local_file(ROOT / "train.toml", "/workspace-training/train.toml", copy=True) .add_local_file(ROOT / "training_lifecycle.py", "/workspace-smoke/training_lifecycle.py", copy=True) .add_local_file(ROOT / "final_training.py", "/workspace-smoke/final_training.py", copy=True) ) # Reuse the evaluation runtime; Harbor fetches tasks from the private Git repo. evaluation_image = (image .add_local_file(ROOT / "calibration/config.json", "/workspace-calibration/config.json", copy=True) .add_local_file(ROOT / "calibration/candidates.json", "/workspace-calibration/candidates.json", copy=True) .add_local_file(ROOT / "calibration/screening-selected100.json", "/workspace-calibration/screening-selected100.json", copy=True) .add_local_file(ROOT / "calibration/screening-all116-manifest.json", "/workspace-calibration/screening-all116-manifest.json", copy=True) .add_local_file(ROOT / "calibration/screening-round2-selected100.json", "/workspace-calibration/screening-round2-selected100.json", copy=True) .add_local_file(ROOT / "calibration/screening-round2-manifest.json", "/workspace-calibration/screening-round2-manifest.json", copy=True)) def calibration_config(): import hashlib import json base = ROOT / "calibration" if modal.is_local() else Path("/workspace-calibration") config = json.loads((base / "config.json").read_text()) config['experiment'].update(profile=ACTIVE_PROFILE, workspace=ACTIVE_WORKSPACE) taskset = config['evaluation']['source'][0]['env']['taskset'] assert taskset['repo'].endswith('@'+config['experiment']['task_git_commit']) runtime = ROOT if modal.is_local() else Path("/workspace-smoke") for name, expected in config["runtime_sha256"].items(): assert hashlib.sha256((runtime / name).read_bytes()).hexdigest() == expected, name experiment = config['experiment'] assert experiment['replicas'] == 2 and experiment['task_count'] == 16 assert experiment['episode_concurrency_per_replica'] == 32 assert experiment['total_episode_concurrency'] == 64 assert config['inference']['vllm']['max_num_seqs'] == 32 assert all(config['evaluation']['concurrency'][key] == 32 for key in ('initial_inflight', 'min_inflight', 'max_inflight')) assert config['evaluation']['source'][0]['serve']['max_concurrent'] == 32 assert config['evaluation']['group_size'] * experiment['replicas'] == 8 assert config['evaluation']['select']['limit'] == 16 assert len(set(config['evaluation']['source'][0]['env']['taskset']['tasks'])) == 16 from prime_rl.configs.inference import InferenceConfig from prime_rl.configs.eval import EvalConfig from copy import deepcopy parsed = InferenceConfig.model_validate(deepcopy(config['inference'])) assert parsed.router is None, 'One engine per replica uses native direct-engine mode' assert parsed.to_namespace().served_model_name == [config['evaluation']['model']] EvalConfig.model_validate(deepcopy(config['evaluation'])) return config ROLLOUT_COMPARISON_TASKS = ( 'ds2-task_12106_bd7f8d', 'task_00002_aa2b6f', 'task_00137_41c355', 'task_00158_a21b36', 'task_01019_af7e37', 'task_00991_47ea8b', ) def comparison_taskset(): from copy import deepcopy taskset = deepcopy(calibration_config()['evaluation']['source'][0]['env']['taskset']) taskset['tasks'] = list(ROLLOUT_COMPARISON_TASKS) return taskset def load_comparison_tasks(): import json import sys sys.path.insert(0, '/workspace-smoke') from task_source import git_credentials, task_manifest from verifiers.v1.tasksets.harbor import HarborConfig, HarborTaskset with git_credentials(): tasks = list(HarborTaskset(HarborConfig.model_validate(comparison_taskset())).load()) base = ROOT/'calibration' if modal.is_local() else Path('/workspace-calibration') expected = json.loads((base/'candidates.json').read_text())['task_manifest'] assert task_manifest(tasks) == {name:expected[name] for name in ROLLOUT_COMPARISON_TASKS} assert all(t.data.upload_environment for t in tasks) return tasks def load_evaluation_tasks(sources, expected_manifest): """One native Git/Harbor loading gate for CPU preflight and GPU startup.""" from copy import deepcopy from task_source import git_credentials, task_manifest from verifiers.v1.tasksets.harbor import HarborConfig, HarborTaskset with git_credentials(): tasks = [task for source in sources for task in HarborTaskset(HarborConfig.model_validate(deepcopy(source['env']['taskset']))).load()] names = [name for source in sources for name in source['env']['taskset']['tasks']] assert {task.data.name for task in tasks} == set(names), 'Loaded task selection differs' assert all(task.data.upload_environment for task in tasks), 'Prebuilt task setup must be uploaded by Harbor' assert task_manifest(tasks) == expected_manifest, 'Remote Git task bytes differ from pinned manifest' return tasks def configuration(directory, tunnel_url, eval_tunnel_url, max_steps=2, rollout_concurrency=16, comparison=False, validate_tasks=True): from copy import deepcopy import json import sys import tomllib from pathlib import Path sys.path.insert(0, "/workspace-smoke") from task_source import load_tasks, source_config from verifiers.v1.tasksets.harbor.taskset import HarborConfig from prime_rl.configs.rl import RLConfig config = tomllib.loads((ROOT/'train.toml' if modal.is_local() else Path('/workspace-training/train.toml')).read_text()) assert max_steps in (1, 2), "Only one or two bounded optimizer updates are allowed" assert rollout_concurrency in ((64, 128) if comparison else (16, 32)) config.update(output_dir=str(directory), run={"name": "training"}, dashboard=False, max_steps=max_steps) config["orchestrator"]["concurrency"].update( initial_inflight=rollout_concurrency, min_inflight=rollout_concurrency, max_inflight=rollout_concurrency) source = config["orchestrator"]["train"]["source"][0] source["env"]["taskset"] = (comparison_taskset() if comparison else source_config().model_dump(mode="json", exclude_none=True)) if validate_tasks: loaded = [task.data.name for task in (load_comparison_tasks() if comparison else load_tasks())] else: assert comparison loaded = list(ROLLOUT_COMPARISON_TASKS) assert len(loaded) == (6 if comparison else 4) # Keep worker/server capacity unchanged; the native dispatcher caps rollouts. source["serve"] = {"pool": {"type": "static", "num_workers": 1}, "max_concurrent": rollout_concurrency if comparison else 32} source["env"]["interception"] = {"type": "server", "tunnel": { "type": "custom", "url": tunnel_url, "port": 8001}} evaluation = deepcopy(source) evaluation["name"] = "workspace-final" evaluation["env"]["interception"]["tunnel"].update(url=eval_tunnel_url, port=8002) config["orchestrator"]["eval"]["source"] = [evaluation] if comparison: config['inference'].update(router=None) config['inference']['vllm'].update(max_num_seqs=rollout_concurrency, max_num_batched_tokens=8192) config['orchestrator']['eval']['select']['limit'] = 6 parsed = RLConfig.model_validate(deepcopy(config)) assert parsed.trainer.model.compile is not None assert parsed.trainer.model.compile.model_dump() == {"fullgraph": False, "mode": None} assert parsed.max_steps == max_steps and parsed.orchestrator.batch_size == 16 assert parsed.orchestrator.concurrency.max_inflight == rollout_concurrency assert parsed.trainer.model.lora.alpha == 32 and parsed.trainer.model.lora.rank == 16 assert parsed.weight_broadcast.type == "filesystem" assert parsed.orchestrator.train.sampling.max_completion_tokens == 8192 assert "thinking_token_budget" not in parsed.orchestrator.train.source[0].sampling.extra_body assert source["env"]["agent"]["max_turns"] == 50 return config, loaded @app.function(image=evaluation_image, gpu="H100:2", cpu=16, memory=131072, timeout=7200, max_containers=1, scaledown_window=2, secrets=[modal.Secret.from_name("workspace-official-harbor-controller"), modal.Secret.from_name("workspace-task-registry-readonly")], volumes={"/outputs": outputs, "/root/.cache/huggingface": cache, "/root/.cache/harbor": task_cache}) async def train(run_id: str, max_steps: int = 2, rollout_concurrency: int = 16, comparison: bool = False, tiny: dict | None = None, final: dict | None = None): import asyncio import json import os import signal import sys import contextlib from pathlib import Path from huggingface_hub import snapshot_download sys.path.insert(0, "/workspace-smoke") from training_lifecycle import stop_launcher root = Path("/outputs/prime") if final is not None: from final_training import validate validate(final) assert max_steps == 10 and rollout_concurrency == 128 and tiny is None and not comparison else: assert max_steps in (1, 2), "Only one or two bounded optimizer updates are allowed" assert rollout_concurrency in ((8,) if tiny is not None else (64, 128) if comparison else (16, 32)) if tiny is not None: assert max_steps == 1 and not comparison validate_tiny_training(tiny) assert Path(run_id).name == run_id and run_id not in ("", ".", "..") directory = root / run_id directory.mkdir(parents=True, exist_ok=False) receipt = {"status": "starting", "contract_sha256": os.environ["WORKSPACE_CONTRACT_SHA256"], "inference_gpus": 1, "trainer_gpus": 1, "gpu": "H100:2", "max_steps": max_steps, "batch_size": 16, "group_size": 4, "concurrency": rollout_concurrency, "lora_rank": 16, "lora_alpha": 32, "revision": "c202236235762e1c871ad0ccb60c8ee5ba337b9a", "profile": "baseline", "comparison": comparison, "initialization": "same pinned base model; new LoRA and optimizer"} if tiny is not None: receipt.update(batch_size=8, group_size=8, profile='tiny-training', expected_updates=1, online_eval=False, recovery_per_episode=1) if final is not None: from final_training import digest import time receipt.update(batch_size=64, group_size=8, profile='final-training', inference_gpus=2, gpu='H100:3', expected_updates=10, online_eval=False, recovery_per_episode=1, frozen_sha256=digest(final), started_unix=time.time(), function_call_id=modal.current_function_call_id()) (directory/'frozen.json').write_text(json.dumps(final,indent=2)+'\n') watchdog = final['watchdog_seconds'] if final is not None else 1800 if tiny is not None else 6600 async def save(): (directory / "receipt.json").write_text(json.dumps(receipt, indent=2) + "\n") await asyncio.wait_for(outputs.commit.aio(), 90) async def persist(): while True: await asyncio.sleep(30) await asyncio.wait_for(outputs.commit.aio(), 90) process = None validation = None waiter = None persistence = asyncio.create_task(persist()) try: await save() # The trainer has no revision field: resolve one immutable snapshot for all # native components so training and serving cannot load different revisions. snapshot = await asyncio.to_thread(snapshot_download, "Qwen/Qwen3.5-9B", revision=receipt["revision"]) async with modal.forward(8001) as tunnel, modal.forward(8002) as eval_tunnel: if final is not None: from copy import deepcopy from final_training import verify_runtime receipt['runtime'] = verify_runtime(final) config = deepcopy(final['training']) selected = config['orchestrator']['train']['source'] tasks = load_evaluation_tasks(selected, {name:final['task_manifest'][name] for name in final['train_tasks']}) loaded = [task.data.name for task in tasks] assert len(selected) == 2 for source, selected_tunnel in zip(selected, (tunnel, eval_tunnel)): source['env']['interception']['tunnel']['url'] = selected_tunnel.url config['output_dir'] = str(directory) await task_cache.commit.aio() elif tiny is None: config, loaded = configuration(directory, tunnel.url, eval_tunnel.url, max_steps, rollout_concurrency, comparison=comparison) else: from copy import deepcopy from bash_recovery import verify_runtime config = deepcopy(tiny['training']) receipt['recovery_runtime'] = verify_runtime(tiny['recovery_sha256']) tasks = load_evaluation_tasks(config['orchestrator']['train']['source'], tiny['task_manifest']) loaded = [task.data.name for task in tasks] config['output_dir'] = str(directory) config['orchestrator']['train']['source'][0]['env']['interception']['tunnel']['url'] = tunnel.url await task_cache.commit.aio() config["model"]["name"] = snapshot config["inference"]["vllm"].pop("revision", None) path = directory / "launch.json" path.write_text(json.dumps(config, indent=2) + "\n") receipt.update(status="training_starting", loaded_tasks=loaded, model_snapshot=snapshot) await save() with (directory / "launcher.log").open("w") as log: # An OS watchdog still runs if Python or mounted-file I/O stalls. # Prime retains responsibility for its components and DCP writes. process = await asyncio.create_subprocess_exec( "/usr/bin/timeout", "--signal=TERM", "--kill-after=30s", f"{watchdog}s", "/app/.venv/bin/rl", "@", str(path), cwd="/app", env={**os.environ, "PATH": "/app/.venv/bin:" + os.environ["PATH"], "WANDB_MODE": "disabled", "VLLM_[REDACTED_CREDENTIAL_ASSIGNMENT]}, stdout=log, stderr=log, start_new_session=True) receipt["launcher_pid"] = process.pid await save() waiter = asyncio.create_task(process.wait()) done, _ = await asyncio.wait((waiter, persistence), timeout=watchdog+70, return_when=asyncio.FIRST_COMPLETED) if persistence in done: await persistence if waiter not in done: raise TimeoutError("Official RL launcher exceeded its bounded walltime") receipt["exit_code"] = waiter.result() assert receipt["exit_code"] == 0, "Official RL process failed; inspect launcher/component logs" checkpoint_steps = (5, 10) if final is not None else (max_steps,) receipt.update(status="validating_checkpoint") await save() for step in checkpoint_steps: step_dir = directory / "training" / "checkpoints" / f"step_{step}" with (directory / (f"checkpoint-validation-{step}.log" if final is not None else "checkpoint-validation.log")).open("w") as log: validation = await asyncio.create_subprocess_exec( "/usr/bin/timeout", "--signal=TERM", "--kill-after=5s", "180s", "/app/.venv/bin/python", "/workspace-smoke/training_lifecycle.py", str(step_dir), str(step), str(step + 1 if step < max_steps else step), stdout=log, stderr=log, start_new_session=True) await asyncio.wait_for(validation.wait(), 195) assert validation.returncode == 0, f"Native checkpoint {step} validation failed" receipt.update(status="completed", checkpoints=[f"training/checkpoints/step_{step}" for step in checkpoint_steps], checkpoint_metadata_verified=True, checkpoint_progress_loaded=True, full_resume_tested=False) except BaseException as error: receipt.update(status="failed", error=repr(error)) raise finally: persistence.cancel() original_error = sys.exception() cleanup_errors = [] for child in (validation, process): if child is not None: try: await stop_launcher(child) except Exception as error: cleanup_errors.append(repr(error)) if waiter is not None: waiter.cancel() with contextlib.suppress(asyncio.CancelledError): await waiter try: await persistence except asyncio.CancelledError: pass except Exception as error: cleanup_errors.append(f"periodic persistence: {error!r}") receipt["launcher_stopped"] = process is None or process.returncode is not None if cleanup_errors: receipt.update(status="failed", cleanup_errors=cleanup_errors) # Always emit the final outcome to Modal logs, even when Volume commit fails. print(json.dumps(receipt, sort_keys=True), flush=True) try: await save() except Exception as error: print(f"Final receipt persistence failed: {error!r}", flush=True) if original_error is None: raise if cleanup_errors and original_error is None: raise RuntimeError("Training cleanup failed; inspect final receipt and Modal logs") if final is not None: import time receipt['ended_unix'] = time.time() # Only submit the short CPU handoff after native processes are stopped. # It waits for this FunctionCall to return, then lets this GPU container scale down. call = await final_evaluation_handoff.spawn.aio(run_id, final, modal.current_function_call_id()) receipt['evaluation_handoff_call_id'] = call.object_id await save() return receipt @app.function(image=evaluation_image, gpu="H100", cpu=8, memory=65536, timeout=21600, max_containers=4, retries=0, scaledown_window=2, secrets=[modal.Secret.from_name("workspace-official-harbor-controller"), modal.Secret.from_name("workspace-task-registry-readonly")], volumes={"/outputs": outputs, "/root/.cache/huggingface": cache, "/root/.cache/harbor": task_cache}) async def evaluate(run_id: str, adapter_run: str = "", calibration: bool = False, replica: int = 0, benchmark: str = "", startup_only: bool = False, screening64: bool = False, screening116: bool = False, screening100: bool = False, validation: dict | None = None, adapter_step: int = 2): """Official Prime inference + eval CLIs; no trainer or optimizer is started.""" import asyncio import contextlib import hashlib import json import os import signal import sys import time import tomllib from copy import deepcopy import httpx from prime_rl.configs.eval import EvalConfig from prime_rl.configs.inference import InferenceConfig sys.path.insert(0, "/workspace-smoke") from task_source import load_tasks, source_config final_heldout = validation is not None and validation['experiment'].get('purpose') == 'final_heldout' assert adapter_step == (10 if final_heldout else 2) multi_screen = screening116 or screening100 assert not (screening116 and screening100) assert Path(run_id).name == run_id and run_id not in ("", ".", "..") assert calibration or (Path(adapter_run).name == adapter_run and adapter_run not in ("", ".", "..")) assert benchmark in ("", "baseline", "candidate") assert not calibration or (replica in (range(4) if multi_screen else (0, 1)) and (not adapter_run or benchmark or final_heldout)) frozen = calibration_config() if calibration else None if screening64: assert calibration and replica == 0 and not adapter_run and not benchmark and not startup_only frozen = screening64_config() if multi_screen: assert calibration and not adapter_run and not benchmark and not startup_only and not screening64 frozen = screening116_config(replica, "screening-round2-selected100.json" if screening100 else "screening-selected100.json") if validation is not None: assert calibration and replica == 0 and not any((benchmark, startup_only, screening64, multi_screen)) assert not adapter_run or final_heldout frozen = deepcopy(validation) _validate_evaluation_budget(frozen) assert frozen['evaluation']['group_size'] == 8 and frozen['experiment']['replicas'] == 1 EvalConfig.model_validate(deepcopy(frozen['evaluation'])) if benchmark or final_heldout: await outputs.reload.aio() directory = Path('/outputs/prime') / run_id if calibration: directory = directory / f"replica-{replica}" directory.mkdir(parents=True, exist_ok=False) adapter = (Path('/outputs/prime') / adapter_run / f'training/broadcasts/step_{adapter_step}') if adapter_run else None receipt = {'status': 'starting', 'training_updates': 0, 'trainer_gpus': 0, 'inference_gpus': 1, 'adapter': str(adapter) if adapter else None, 'planned_attempts': 64 if calibration else 4, 'contract_sha256': os.environ['WORKSPACE_CONTRACT_SHA256']} if calibration: receipt.update(replica=replica, concurrency=32, attempts_per_task=4, calibration_config_sha256=hashlib.sha256(Path('/workspace-calibration/config.json').read_bytes()).hexdigest()) if screening64: receipt.update(concurrency=64, attempts_per_task=8, planned_attempts=128, experiment='single-H100 terminal screening, fresh cohort', task_git_commit=frozen['experiment']['task_git_commit']) if multi_screen: receipt.update(concurrency=64, attempts_per_task=8, planned_attempts=frozen["experiment"]["shard_task_count"] * 8, experiment='four-H100 fresh screening100 round2' if screening100 else 'four-H100 fresh screening116', task_git_commit=frozen['experiment']['task_git_commit']) (directory/'frozen-config.json').write_text(json.dumps(frozen,indent=2)+'\n') if validation is not None: receipt.update(concurrency=64, attempts_per_task=8, planned_attempts=frozen['experiment']['total_attempts'], experiment=frozen['experiment'].get('purpose', 'base model validation only'), output_token_limit=frozen['evaluation']['sampling']['max_tokens'], temperature=frozen['evaluation']['sampling']['temperature'], started_unix=time.time(), task_git_commits=frozen['experiment']['task_git_commits']) (directory/'frozen-config.json').write_text(json.dumps(frozen,indent=2)+'\n') server = job = None logs = [] started = time.monotonic() if benchmark: receipt.update(benchmark=benchmark, startup_only=startup_only, planned_attempts=0 if startup_only else 64, weight_updates_tested=False, training_acceptance_tested=False) async def save(): (directory/'receipt.json').write_text(json.dumps(receipt, indent=2)+'\n') await asyncio.wait_for(outputs.commit.aio(), 90) async def persist(): while True: await asyncio.sleep(30) await asyncio.wait_for(outputs.commit.aio(), 90) persistence = asyncio.create_task(persist()) try: if validation is not None and frozen['experiment'].get('purpose') in ('output_limit_comparison', 'temperature_probe', 'length_recovery_comparison', 'final_heldout'): from importlib.metadata import version receipt['versions'] = {name: version(name) for name in ('prime-rl','vllm','torch','verifiers','harbor','modal','renderers')} hardware = await asyncio.create_subprocess_exec('nvidia-smi', '--query-gpu=name,uuid', '--format=csv,noheader', stdout=asyncio.subprocess.PIPE) stdout, _ = await asyncio.wait_for(hardware.communicate(), 30) assert hardware.returncode == 0 receipt['gpu_hardware'] = stdout.decode().strip() if final_heldout: from final_training import verify_runtime receipt['runtime'] = verify_runtime(frozen) if frozen['experiment']['purpose'] == 'length_recovery_comparison': from bash_recovery import ENVIRONMENT_VARIABLE, verify_runtime receipt['recovery_runtime'] = verify_runtime(frozen['runtime_sha256']['bash_recovery.py']) receipt['length_recovery_per_episode'] = int(frozen['evaluation']['source'][0]['env']['agent']['harness']['env'][ENVIRONMENT_VARIABLE]) receipt['recovery_patch_sha256'] = frozen['runtime_sha256']['bash_recovery.py'] if calibration: from huggingface_hub import snapshot_download model_path = await asyncio.to_thread(snapshot_download, frozen['experiment']['model'], revision=frozen['experiment']['model_revision']) else: assert (adapter/'.finished').exists() from safetensors import safe_open with safe_open(adapter/'adapter_model.safetensors', framework='numpy') as tensors: assert len(tensors.keys()) > 0 receipt['adapter_sha256'] = hashlib.sha256((adapter/'adapter_model.safetensors').read_bytes()).hexdigest() original = json.loads((Path('/outputs/prime')/adapter_run/'launch.json').read_text()) model_path = original['model']['name'] if final_heldout and adapter is not None: assert Path(adapter_run).name == adapter_run and adapter_run not in ('', '.', '..') prior = json.loads((Path('/outputs/prime')/adapter_run/'receipt.json').read_text()) if prior['status'] != 'completed': # Preserve the original failed postflight receipt. A separately # recorded CPU revalidation may authorize only this saved adapter. verified = json.loads((Path('/outputs/prime')/(adapter_run+'-heldout')/'verification.json').read_text()) prior_path = Path('/outputs/prime')/adapter_run/'receipt.json' assert verified['original_receipt_sha256'] == hashlib.sha256(prior_path.read_bytes()).hexdigest() assert verified['status']=='checkpoint_verified' and verified['full_resume_tested'] is False assert verified['frozen_sha256']==prior['frozen_sha256'] assert verified['adapter_sha256']==hashlib.sha256((adapter/'adapter_model.safetensors').read_bytes()).hexdigest() assert prior['exit_code']==0 and prior['launcher_stopped'] assert [c['step'] for c in verified['checkpoints']]==[5,10] else: assert prior['checkpoint_metadata_verified'] and prior['launcher_stopped'] assert prior['max_steps']==10 and (adapter/'.finished').is_file() from safetensors import safe_open with safe_open(adapter/'adapter_model.safetensors', framework='numpy') as tensors: assert len(tensors.keys()) > 0 receipt['adapter_sha256'] = hashlib.sha256((adapter/'adapter_model.safetensors').read_bytes()).hexdigest() if benchmark: assert adapter is not None and (adapter/'.finished').is_file() digest = hashlib.sha256((adapter/'adapter_model.safetensors').read_bytes()).hexdigest() assert digest == BENCHMARK_ADAPTER_SHA256, 'Adapter changed' adapter_config = json.loads((adapter/'adapter_config.json').read_text()) assert adapter_config['r'] == 16 and adapter_config['lora_alpha'] == 32 receipt.update(adapter_sha256=digest, adapter_config=adapter_config) assert Path(model_path).is_dir() config = tomllib.loads(Path('/workspace-training/train.toml').read_text()) if calibration: selected_sources = frozen['evaluation']['source'] expected = json.loads(Path('/workspace-calibration/candidates.json').read_text())['task_manifest'] if multi_screen: expected = json.loads((Path('/workspace-calibration') / ('screening-round2-manifest.json' if screening100 else 'screening-all116-manifest.json')).read_text()) expected = {name:expected[name] for source in selected_sources for name in source['env']['taskset']['tasks']} if validation is not None: expected = frozen['task_manifest'] tasks = load_evaluation_tasks(selected_sources, expected) else: tasks = load_tasks() assert len(tasks) == 4 await task_cache.commit.aio() model_name = 'workspace-step-2' serving = {'deployment': {'type': 'single_node', 'gpus_per_node': 1}, 'output_dir': str(directory/'inference'), 'vllm': {**config['inference']['vllm'], 'model': model_path, 'enable_lora': True, 'max_lora_rank': 16, 'max_num_seqs': 4, 'served_model_name': 'workspace-base', 'tool_call_parser': 'qwen3_coder', 'enable_auto_tool_choice': True}} serving['vllm'].pop('revision', None) if calibration: serving = deepcopy(frozen['inference']) serving['output_dir'] = str(directory/'inference') serving['vllm'].update(model=model_path, seed=frozen['experiment']['inference_seeds'][replica]) model_name = 'workspace-final-step10' if final_heldout and adapter is not None else frozen['evaluation']['model'] if benchmark: serving = benchmark_serving(serving, benchmark) model_name = 'workspace-step-2-benchmark' parsed = InferenceConfig.model_validate(deepcopy(serving)) namespace = parsed.to_namespace() assert namespace.tool_call_parser == 'qwen3_coder' and namespace.enable_auto_tool_choice (directory/'inference.json').write_text(json.dumps(serving)) log = (directory/'inference.log').open('w');logs.append(log) env = {**os.environ, 'PATH': '/app/.venv/bin:'+os.environ['PATH'], 'VLLM_[REDACTED_CREDENTIAL_ASSIGNMENT], 'VLLM_ALLOW_RUNTIME_LORA_UPDATING': 'true'} if benchmark: # Baseline namespaces are unique per pass; candidate reuses its first-pass cache. if benchmark == 'candidate': cache_root = Path('/outputs/prime/native-compile-cache') / run_id.removesuffix('-startup').removesuffix('-eval') / benchmark else: cache_root = Path('/tmp') / run_id / 'vllm-cache' env.update(VLLM_CACHE_ROOT=str(cache_root)) receipt['cache_root'] = str(cache_root) from importlib.metadata import version receipt['versions'] = {name: version(name) for name in ('prime-rl', 'vllm', 'torch', 'verifiers', 'harbor', 'modal', 'renderers')} engine_started = time.monotonic() server = await asyncio.create_subprocess_exec('/usr/bin/timeout', '--signal=TERM', '--kill-after=30s', '21000s' if multi_screen else '6600s', '/app/.venv/bin/inference','@',str(directory/'inference.json'), cwd='/app',env=env,stdout=log,stderr=log,start_new_session=True) receipt['status'] = 'inference_starting';await save() async with httpx.AsyncClient(timeout=30,headers={'[REDACTED_CREDENTIAL_ASSIGNMENT]}) as client: deadline = time.monotonic()+1500 while time.monotonic() < deadline: if server.returncode is not None: raise RuntimeError('Inference exited; inspect inference.log') try: response = await client.get('http://127.0.0.1:8000/health') if response.status_code == 200: break except httpx.HTTPError: pass await asyncio.sleep(5) else: raise TimeoutError('Inference startup exceeded 1500s') if adapter is not None: response = await client.post('http://127.0.0.1:8000/load_lora_adapter', json={'lora_name':model_name,'lora_path':str(adapter)},timeout=180) response.raise_for_status() response = await client.get('http://127.0.0.1:8000/v1/models');response.raise_for_status() advertised_models = [m['id'] for m in response.json()['data']] receipt['advertised_models'] = advertised_models assert model_name in advertised_models, f'Expected {model_name!r}; server advertised {advertised_models!r}' if calibration: unauthorized = await client.get('http://127.0.0.1:8000/v1/models', headers={'[REDACTED_CREDENTIAL_ASSIGNMENT]}) assert unauthorized.status_code == 401, 'Inference must reject invalid API keys' receipt['authentication_verified'] = True smoke = await client.post('http://127.0.0.1:8000/v1/chat/completions', json={'model': model_name, 'messages': [{'role': 'user', 'content': 'Reply OK.'}], 'temperature': 1.0 if benchmark else 0.0, 'max_tokens': 32, **({'top_k': 20, 'top_p': 0.95, 'min_p': 0.0, 'seed': 9001} if benchmark else {}), 'chat_template_kwargs': {'enable_thinking': bool(benchmark)}}, timeout=180) smoke.raise_for_status() assert smoke.json().get('choices'), 'Readiness generation returned no choices' receipt['generation_verified'] = True if benchmark: receipt['training_inference_probe'] = await benchmark_probe(model_path, model_name, directory) receipt['ready_seconds'] = time.monotonic() - engine_started await save() if startup_only: receipt['status'] = 'startup_probe_completed' return receipt receipt['adapter_loaded'] = adapter is not None async with contextlib.AsyncExitStack() as tunnels: tunnel = await tunnels.enter_async_context(modal.forward(8001)) source = deepcopy(config['orchestrator']['train']['source'][0]) source['name'] = 'workspace-final' source['env']['taskset'] = source_config().model_dump(mode='json',exclude_none=True) source['env']['interception'] = {'type':'server','tunnel':{'type':'custom','url':tunnel.url,'port':8001}} source['serve'] = {'pool':{'type':'static','num_workers':1},'max_concurrent':4} evaluation = {'model':model_name,'client':{'base_url':'http://127.0.0.1:8000/v1','api_key_var':'VLLM_API_KEY'}, 'concurrency':{'initial_inflight':4,'min_inflight':4,'max_inflight':4}, 'group_size':1,'select':{'limit':4,'shuffle':False}, 'sampling':config['orchestrator']['eval']['sampling'], 'source':[source], 'output_dir':str(directory),'run':{'name':'evaluation'},'dashboard':False} if calibration: evaluation = deepcopy(frozen['evaluation']) evaluation['output_dir'] = str(directory) if final_heldout: evaluation['model'] = model_name for index, eval_source in enumerate(evaluation['source']): source_tunnel = tunnel if index == 0 else await tunnels.enter_async_context(modal.forward(8001+index)) eval_source['env']['interception']['tunnel'].update(url=source_tunnel.url, port=8001+index) if benchmark: evaluation['model'] = model_name evaluation['sampling']['extra_body']['cache_salt'] = 'benchmark-step2-' + BENCHMARK_ADAPTER_SHA256 EvalConfig.model_validate(deepcopy(evaluation)) (directory/'eval.json').write_text(json.dumps(evaluation,indent=2)) log = (directory/'eval.log').open('w');logs.append(log) receipt['status']='evaluating';await save() eval_started = time.monotonic() job = await asyncio.create_subprocess_exec('/usr/bin/timeout', '--signal=TERM', '--kill-after=60s', '18000s' if multi_screen else '5100s', '/app/.venv/bin/eval','@',str(directory/'eval.json'), cwd='/app',env=env,stdout=log,stderr=log,start_new_session=True) receipt['eval_exit_code'] = await asyncio.wait_for(job.wait(),18060 if multi_screen else (5100 if calibration else 3000)) receipt['eval_seconds'] = time.monotonic() - eval_started assert receipt['eval_exit_code']==0, 'Official eval failed; inspect eval.log' receipt['status']='eval_process_completed_results_pending_review' except BaseException as error: receipt.update(status='failed',error=repr(error)) raise finally: for process in (job,server): if process is not None and process.returncode is None: from training_lifecycle import stop_launcher await stop_launcher(process, grace=60) for log in logs: log.close() persistence.cancel() try: await persistence except asyncio.CancelledError: pass receipt['function_seconds'] = time.monotonic() - started receipt['ended_unix'] = time.time() receipt['processes_stopped']=all(p is None or p.returncode is not None for p in (server,job)) await save() return receipt @app.local_entrypoint() def calibrate(run_id: str = "calibration-sixteen-v1", launch: bool = False): """Submit both evaluation replicas only when explicitly requested.""" import json config = calibration_config() print(json.dumps(config['experiment'], indent=2)) if not launch: print("Prepared only. No GPU functions submitted.") return assert Path(run_id).name == run_id and run_id not in ('', '.', '..') import subprocess assert modal.Workspace.from_context().hydrate().name == ACTIVE_WORKSPACE, 'Use --profile rl-next for this project' assert not any(entry.path.strip('/') == 'prime/'+run_id for entry in outputs.iterdir('/prime', recursive=False)), 'Run ID already exists' calls = [evaluate.spawn(run_id, calibration=True, replica=i) for i in range(2)] receipt = {'run_id': run_id, 'app_id': app.app_id, 'function_call_ids': [c.object_id for c in calls], 'output': 'workspace-agent-training:/prime/'+run_id} (ROOT/'calibration'/('launch-'+run_id+'.json')).write_text(json.dumps(receipt, indent=2)+'\n') print(json.dumps(receipt, indent=2), flush=True) for call in calls: print(call.get()) BENCHMARK_ADAPTER_SHA256 = 'd33033f3755bd14e90a945dcf104a89b86a32505e7835040609bb77e03a30d96' def benchmark_serving(serving, arm): """One supported knob comparison, with the real training inference contract.""" from copy import deepcopy result = deepcopy(serving) result.update(router=None, enable_return_sampling_mask=True) result['vllm'].update(enable_lora=True, max_lora_rank=16, max_num_seqs=32, served_model_name=['workspace-benchmark-base'], seed=4100, logprobs_mode='processed_logprobs', max_num_batched_tokens=8192 if arm == 'baseline' else 16384) if arm == 'candidate': result['vllm']['safetensors_load_strategy'] = 'prefetch' assert result['vllm']['quantization'] == 'fp8_per_block' return result async def benchmark_probe(model_path, model_name, directory): """Use the installed official renderer client to verify sampled-token evidence.""" import asyncio import json import math from openai import AsyncOpenAI from renderers import create_renderer, Qwen35RendererConfig from renderers.base import load_tokenizer from renderers.client import generate from verifiers.v1.types import SamplingMask renderer = await asyncio.to_thread(lambda: create_renderer( load_tokenizer(model_path), Qwen35RendererConfig(enable_thinking=True))) async with AsyncOpenAI(base_url='http://127.0.0.1:8000/v1', [REDACTED_CREDENTIAL_ASSIGNMENT], timeout=180, max_retries=0) as client: result = await generate(client=client, renderer=renderer, model=model_name, messages=[{'role': 'user', 'content': 'Reply OK.'}], sampling_params={'temperature': 1.0, 'top_k': 20, 'top_p': 0.95, 'min_p': 0.0, 'max_tokens': 32, 'seed': 9002}, cache_salt='benchmark-step2-' + BENCHMARK_ADAPTER_SHA256) tokens = result['completion_ids']; logprobs = result['completion_logprobs'] assert tokens and len(tokens) == len(logprobs) and all(math.isfinite(x) and x > -9999 for x in logprobs) mask = SamplingMask.from_sampling_mask(result['sampling_mask']) assert len(mask.counts) == len(tokens) and all(0 < int(c) <= 20 for c in mask.counts) offset = 0 for token, count in zip(tokens, mask.counts): assert token in mask.ids[offset:offset+int(count)] offset += int(count) evidence = {'completion_ids': tokens, 'completion_logprobs': logprobs, 'sampling_mask_counts': mask.counts.tolist(), 'sampling_mask_ids': mask.ids.tolist(), 'cache_salt': 'benchmark-step2-' + BENCHMARK_ADAPTER_SHA256, 'weight_transition_tested': False, 'policy_attribution_in_training_tested': False} (directory/'training-inference-probe.json').write_text(json.dumps(evidence, indent=2)+'\n') return {'tokens': len(tokens), 'finite_logprobs': True, 'sampled_token_in_every_mask': True, 'cache_salt_sent': True, 'weight_transition_tested': False} @app.function(image=evaluation_image, cpu=1, memory=2048, timeout=15000, max_containers=1, scaledown_window=2, retries=0, volumes={'/outputs': outputs}) async def benchmark_campaign(run_id: str, submitted): """A single remote parent owns all child calls after the local client exits.""" import asyncio import hashlib import json import time assert Path(run_id).name == run_id and run_id not in ('', '.', '..') directory = Path('/outputs/prime') / run_id directory.mkdir(parents=True, exist_ok=False) receipt = {'run_id': run_id, 'status': 'preflight', 'app_id': app.app_id, 'profile': ACTIVE_PROFILE, 'workspace': ACTIVE_WORKSPACE, 'trainer_gpus': 0, 'max_concurrent_inference_gpus': 2, 'training_updates': 0, 'calls': [], 'started_unix': time.time(), 'output': 'workspace-agent-training:/prime/'+run_id} calls = [] async def save(): (directory/'campaign.json').write_text(json.dumps(receipt, indent=2)+'\n') await asyncio.wait_for(outputs.commit.aio(), 90) try: adapter = Path('/outputs/prime/training4-20261028-02/training/broadcasts/step_2') assert (adapter/'.finished').is_file() digest = hashlib.sha256((adapter/'adapter_model.safetensors').read_bytes()).hexdigest() assert digest == BENCHMARK_ADAPTER_SHA256 cfg = json.loads((adapter/'adapter_config.json').read_text()) assert cfg['r'] == 16 and cfg['lora_alpha'] == 32 receipt.update(adapter=str(adapter), adapter_sha256=digest) frozen = calibration_config() (directory/'frozen-calibration.json').write_text(json.dumps(frozen, indent=2)+'\n') configs = {arm: benchmark_serving(frozen['inference'], arm) for arm in ('baseline', 'candidate')} (directory/'benchmark-configs.json').write_text(json.dumps(configs, indent=2)+'\n') receipt['configuration_changes'] = { 'common': {'adapter': digest, 'enable_return_sampling_mask': True, 'logprobs_mode': 'processed_logprobs', 'seed': 4100, 'max_num_seqs': 32, 'stochastic_readiness': True}, 'candidate_vs_baseline': {'max_num_batched_tokens': [8192, 16384], 'safetensors_load_strategy': [None, 'prefetch'], 'cache': ['fresh /tmp namespace each pass', 'same persistent Volume namespace both passes']}} await save() for phase in ('startup', 'eval'): calls = [] for replica, arm in enumerate(('baseline', 'candidate')): call = await evaluate.spawn.aio(run_id+'-'+phase, adapter_run='training4-20261028-02', calibration=True, replica=replica, benchmark=arm, startup_only=phase == 'startup') calls.append(call) receipt['calls'].append({'phase': phase, 'arm': arm, 'function_call_id': call.object_id, 'output': f'workspace-agent-training:/prime/{run_id}-{phase}/replica-{replica}'}) receipt['status'] = phase+'_submitted' await save() if phase == 'startup': try: await submitted.put.aio(receipt) except Exception as exc: receipt['submission_ack_error'] = repr(exc) await save() results = await asyncio.wait_for( asyncio.gather(*(c.get.aio() for c in calls), return_exceptions=True), 2100 if phase == 'startup' else 7000) receipt[phase+'_results'] = [repr(r) if isinstance(r, BaseException) else r for r in results] if any(isinstance(r, BaseException) for r in results): raise RuntimeError(f'{phase} failed; no further phases will be launched') await save() receipt['status'] = 'completed_results_pending_review' except BaseException as exc: receipt.update(status='failed', error=repr(exc)) # Explicit cancellation is only needed if the remote parent itself is interrupted. await asyncio.gather(*(c.cancel.aio() for c in calls), return_exceptions=True) raise finally: receipt['finished_unix'] = time.time() print(json.dumps(receipt), flush=True) await save() return receipt @app.local_entrypoint() def optimize(run_id: str, launch: bool = False): """Run with modal run --detach; wait only for remote submission, never results.""" import json import subprocess from copy import deepcopy from prime_rl.configs.inference import InferenceConfig frozen = calibration_config() configs = {arm: benchmark_serving(frozen['inference'], arm) for arm in ('baseline', 'candidate')} for config in configs.values(): parsed = InferenceConfig.model_validate(deepcopy(config)); ns = parsed.to_namespace() assert parsed.router is None and ns.enable_lora and ns.max_lora_rank == 16 assert ns.return_sampling_mask and ns.logprobs_mode == 'processed_logprobs' path = ROOT/'calibration'/('launch-'+run_id+'.json') assert not path.exists(), 'Local launch receipt already exists' if not launch: print(json.dumps(configs, indent=2)); return assert modal.Workspace.from_context().hydrate().name == ACTIVE_WORKSPACE, 'Use --profile rl-next for this project' assert not any(e.path.strip('/') == 'prime/'+run_id for e in outputs.iterdir('/prime', recursive=False)) with modal.Queue.ephemeral() as submitted: call = benchmark_campaign.spawn(run_id, submitted) local_receipt = {'run_id': run_id, 'app_id': app.app_id, 'controller_call_id': call.object_id, 'status': 'controller_submitted', 'configs': configs, 'output': 'workspace-agent-training:/prime/'+run_id} path.write_text(json.dumps(local_receipt, indent=2)+'\n') try: remote_receipt = submitted.get(timeout=120) local_receipt.update(remote_submission=remote_receipt, status='gpu_calls_submitted') except Exception as exc: local_receipt['submission_ack_error'] = repr(exc) path.write_text(json.dumps(local_receipt, indent=2)+'\n') print(json.dumps(local_receipt, indent=2), flush=True) # The remote controller remains active and owns the awaited child calls. def rollout_comparison_plan(): """Freeze a two-update systems comparison, not a ten-epoch training run.""" from copy import deepcopy configs = {} for concurrency in (64, 128): cfg, _ = configuration(Path('/validation'), 'https://train.invalid', 'https://eval.invalid', 2, concurrency, comparison=True, validate_tasks=False) configs[str(concurrency)] = cfg def differences(a, b, path=''): if isinstance(a, dict) and isinstance(b, dict): return sum((differences(a.get(k), b.get(k), path+'.'+k) for k in sorted(set(a)|set(b))), []) if isinstance(a, list) and isinstance(b, list) and len(a)==len(b): return sum((differences(x,y,path+'.'+str(i)) for i,(x,y) in enumerate(zip(a,b))), []) return [] if a==b else [{'path':path.lstrip('.'),'c64':a,'c128':b}] diff = differences(configs['64'], configs['128']) expected = { 'orchestrator.concurrency.initial_inflight', 'orchestrator.concurrency.min_inflight', 'orchestrator.concurrency.max_inflight', 'orchestrator.train.source.0.serve.max_concurrent', 'orchestrator.eval.source.0.serve.max_concurrent', 'inference.vllm.max_num_seqs', } assert {d['path'] for d in diff} == expected, diff from prime_rl.configs.rl import RLConfig for c, cfg in configs.items(): parsed=RLConfig.model_validate(deepcopy(cfg)) ns=parsed.inference.to_namespace() assert parsed.inference.router is None assert ns.return_sampling_mask and ns.max_num_seqs==int(c) assert ns.tool_call_parser=='qwen3_coder' and ns.enable_auto_tool_choice assert parsed.orchestrator.model.client.api_key_var=='VLLM_API_KEY' assert parsed.orchestrator.max_off_policy_steps==1 assert parsed.orchestrator.monitors.file is not None and parsed.trainer.monitors.file is not None return { 'concurrencies':[64,128], 'order':'sequential, one H100 trainer + one H100 inference per arm', 'max_steps_per_arm':2, 'batch_size':16, 'group_size':4, 'task_group_slots_per_update':4, 'tasks':list(ROLLOUT_COMPARISON_TASKS), 'taskset':comparison_taskset(), 'selection':'same Qwen3.5-9B/bash calibration: 2-6 passes inclusive out of 8; six qualify', 'initialization':'same immutable base revision; fresh LoRA and optimizer per arm; no resume', 'config_diff':diff, 'configs':configs, 'metrics':{ 'usable_batch_time':'native orchestrator time/step plus shipment timestamp; first/second step separately', 'accepted_samples_per_second':'effective shipped episodes, attributed to a completed trainer step, divided by matching wall interval', 'trainer_idle_time':'native trainer time/wait_for_batch; fraction=sum(wait)/sum(time/step)', 'acceptance':'use effective cohort annotations, not all arrivals or trainer packed microbatch counts', 'additional':['optimizer steps','stale drops','policy lag','trainable fraction','task distribution', 'reward','truncation','provider errors','checkpoint and cleanup'], }, 'limits':['two-update pilot, one run per arm; no learning-quality or steady-state certification', 'same seeds/order do not guarantee identical asynchronous accepted cohorts', 'passes and failures can be usable; zero-advantage traces reported separately', 'checkpoint save remains native and may hit existing watchdog if finalization stalls'], } @app.function(image=evaluation_image,cpu=2,memory=8192,timeout=15000, max_containers=1,retries=0, secrets=[modal.Secret.from_name("workspace-task-registry-readonly")], volumes={'/outputs':outputs,'/root/.cache/harbor':task_cache}) async def rollout_comparison_controller(run_id: str, submitted): import asyncio import json import os import time from copy import deepcopy directory=Path('/outputs/prime')/run_id directory.mkdir(parents=True,exist_ok=False) receipt={'run_id':run_id,'app_id':app.app_id,'status':'cpu_preflight', 'started_unix':time.time(),'arms':[], 'output':'workspace-agent-training:/prime/'+run_id} async def save(): (directory/'campaign.json').write_text(json.dumps(receipt,indent=2)+'\n') await asyncio.wait_for(outputs.commit.aio(),90) active=None try: await save() plan=rollout_comparison_plan() (directory/'plan.json').write_text(json.dumps(plan,indent=2)+'\n') tasks=await asyncio.to_thread(load_comparison_tasks) assert {t.data.name for t in tasks}==set(ROLLOUT_COMPARISON_TASKS) receipt['native_git_manifest_verified']=True await task_cache.commit.aio() for concurrency in (64,128): cfg=deepcopy(plan['configs'][str(concurrency)]) cfg['output_dir']=str(directory/f'cpu-c{concurrency}') cfg['run']['name']='validation' path=directory/f'cpu-c{concurrency}.json' path.write_text(json.dumps(cfg,indent=2)+'\n') with (directory/f'cpu-c{concurrency}.log').open('w') as log: proc=await asyncio.create_subprocess_exec('/usr/bin/timeout','180s', '/app/.venv/bin/rl','@',str(path),'--dry-run',cwd='/app', env={**os.environ,'WANDB_MODE':'disabled','VLLM_[REDACTED_CREDENTIAL_ASSIGNMENT]}, stdout=log,stderr=log) code=await asyncio.wait_for(proc.wait(),195) assert code==0, f'Official CPU dry-run c{concurrency} failed: {code}' receipt.update(status='cpu_preflight_passed',cpu_dry_runs_passed=[64,128]) await save() for concurrency in (64,128): arm_id=f'{run_id}-c{concurrency}' active=await train.spawn.aio(arm_id,max_steps=2,rollout_concurrency=concurrency,comparison=True) arm={'concurrency':concurrency,'run_id':arm_id,'call_id':active.object_id, 'status':'submitted','submitted_unix':time.time(), 'output':'workspace-agent-training:/prime/'+arm_id} receipt['arms'].append(arm);receipt['status']='training_comparison_running' await save() if concurrency==64: await submitted.put.aio(receipt) try: result=await active.get.aio() arm.update(status=result['status'],result=result) except Exception as exc: arm.update(status='failed',error=repr(exc)) arm['finished_unix']=time.time() active=None await save() receipt['status']='completed' if all(a['status']=='completed' for a in receipt['arms']) else 'completed_with_failures' except BaseException as exc: receipt.update(status='failed',error=repr(exc)) if active is not None:await active.cancel.aio() try:await submitted.put.aio(receipt) except Exception:pass raise finally: receipt['updated_unix']=time.time() await save() return receipt @app.local_entrypoint() def compare_rollouts(run_id: str, launch: bool=False): import json import subprocess plan=rollout_comparison_plan() path=ROOT/'calibration'/('launch-'+run_id+'.json') assert not path.exists(), 'Existing launch receipt; do not duplicate' if not launch: print(json.dumps(plan,indent=2));return assert modal.Workspace.from_context().hydrate().name == ACTIVE_WORKSPACE, 'Use --profile rl-next for this project' assert Path(run_id).name==run_id and run_id not in ('','.','..') assert not any(e.path.strip('/')=='prime/'+run_id for e in outputs.iterdir('/prime',recursive=False)) with modal.Queue.ephemeral() as queue: call=rollout_comparison_controller.spawn(run_id,queue) receipt={'run_id':run_id,'app_id':app.app_id,'controller_call_id':call.object_id, 'status':'controller_submitted','plan':plan} path.write_text(json.dumps(receipt,indent=2)+'\n') try: receipt['remote_submission']=queue.get(timeout=420) receipt['status']=receipt['remote_submission']['status'] except Exception as exc:receipt['submission_ack_error']=repr(exc) path.write_text(json.dumps(receipt,indent=2)+'\n') print(json.dumps({k:v for k,v in receipt.items() if k!='plan'},indent=2),flush=True) def screening64_config(): from copy import deepcopy from prime_rl.configs.eval import EvalConfig from prime_rl.configs.inference import InferenceConfig frozen=deepcopy(calibration_config()) frozen['evaluation']['group_size']=8 frozen['evaluation']['concurrency']={k:64 for k in ('initial_inflight','min_inflight','max_inflight')} frozen['evaluation']['source'][0]['serve']['max_concurrent']=64 frozen['inference']['vllm']['max_num_seqs']=64 frozen['experiment'].update(replicas=1,attempts_per_task_per_replica=8, episode_concurrency_per_replica=64,total_episode_concurrency=64) EvalConfig.model_validate(deepcopy(frozen['evaluation'])) parsed=InferenceConfig.model_validate(deepcopy(frozen['inference'])) assert parsed.router is None and parsed.to_namespace().max_num_seqs==64 assert frozen['evaluation']['group_size']*frozen['evaluation']['select']['limit']==128 return frozen @app.function(image=evaluation_image,cpu=2,memory=8192,timeout=7500, max_containers=1,retries=0, secrets=[modal.Secret.from_name("workspace-task-registry-readonly")], volumes={'/outputs':outputs,'/root/.cache/harbor':task_cache}) async def screening64_controller(run_id: str, submitted): import asyncio import json import time import sys sys.path.insert(0,'/workspace-smoke') from task_source import git_credentials,task_manifest from verifiers.v1.tasksets.harbor import HarborConfig,HarborTaskset directory=Path('/outputs/prime')/run_id directory.mkdir(parents=True,exist_ok=False) receipt={'run_id':run_id,'app_id':app.app_id,'status':'cpu_preflight', 'started_unix':time.time(),'output':'workspace-agent-training:/prime/'+run_id} async def save(): (directory/'campaign.json').write_text(json.dumps(receipt,indent=2)+'\n') await asyncio.wait_for(outputs.commit.aio(),90) call=None try: await save() frozen=screening64_config() (directory/'frozen-config.json').write_text(json.dumps(frozen,indent=2)+'\n') def validate_git(): with git_credentials(): tasks=list(HarborTaskset(HarborConfig.model_validate( frozen['evaluation']['source'][0]['env']['taskset'])).load()) expected=json.loads(Path('/workspace-calibration/candidates.json').read_text())['task_manifest'] assert task_manifest(tasks)==expected and len(tasks)==16 assert all(t.data.upload_environment for t in tasks) await asyncio.to_thread(validate_git) await task_cache.commit.aio() receipt['native_git_manifest_verified']=True call=await evaluate.spawn.aio(run_id,calibration=True,replica=0,screening64=True) receipt.update(status='worker_submitted',worker_call_id=call.object_id) await save() await submitted.put.aio(receipt) result=await call.get.aio() receipt.update(status=result['status'],worker_receipt=result) except BaseException as exc: receipt.update(status='failed',error=repr(exc)) if call is not None:await call.cancel.aio() try:await submitted.put.aio(receipt) except Exception:pass raise finally: receipt['updated_unix']=time.time() await save() return receipt @app.local_entrypoint() def screen64(run_id: str, launch: bool=False): import json import subprocess frozen=screening64_config() assert Path(run_id).name==run_id and run_id not in ('','.','..') receipt_path=ROOT/'calibration'/('launch-'+run_id+'.json') assert not receipt_path.exists() if not launch: print(json.dumps(frozen,indent=2));return assert modal.Workspace.from_context().hydrate().name == ACTIVE_WORKSPACE, 'Use --profile rl-next for this project' assert not any(e.path.strip('/')=='prime/'+run_id for e in outputs.iterdir('/prime',recursive=False)) with modal.Queue.ephemeral() as queue: call=screening64_controller.spawn(run_id,queue) receipt={'run_id':run_id,'app_id':app.app_id,'controller_call_id':call.object_id, 'status':'controller_submitted','planned_attempts':128,'concurrency':64, 'inference_gpus':1,'trainer_gpus':0} receipt_path.write_text(json.dumps(receipt,indent=2)+'\n') try: receipt['remote_submission']=queue.get(timeout=180) receipt['status']=receipt['remote_submission']['status'] except Exception as exc:receipt['submission_ack_error']=repr(exc) receipt_path.write_text(json.dumps(receipt,indent=2)+'\n') print(json.dumps(receipt,indent=2),flush=True) STEADY_CONCURRENCIES = (16, 32, 64, 128) def steady_capacities(concurrency=0): assert concurrency in (0, 16, 32, 64, 98, 128) return (concurrency,) if concurrency else STEADY_CONCURRENCIES STEADY_CASES = ( {'name': 'uncached-long-prefill', 'input': 16384, 'prefix': 0, 'output': 2048, 'seed': 7101}, {'name': 'shared-prefix-long-decode', 'input': 4096, 'prefix': 24576, 'output': 8192, 'seed': 7102}, ) def steady_serving(frozen, model_path, directory, concurrency): from copy import deepcopy assert concurrency in steady_capacities(concurrency) serving = benchmark_serving(frozen['inference'], 'baseline') serving['output_dir'] = str(directory/'inference') serving['vllm'].update(model=model_path, max_num_seqs=concurrency, max_num_batched_tokens=8192) assert 'safetensors_load_strategy' not in serving['vllm'] and 'env_vars' not in serving return serving def steady_command(case, concurrency, model_path, directory): import json extra = {'temperature': 1.0, 'top_p': 0.95, 'top_k': 20, 'min_p': 0.0, 'chat_template_kwargs': {'enable_thinking': True}, 'logprobs': True, 'top_logprobs': 1, 'cache_salt': 'steady-step2-' + BENCHMARK_ADAPTER_SHA256} return ['/app/.venv/bin/vllm', 'bench', 'serve', '--backend', 'openai-chat', '--base-url', 'http://127.0.0.1:8000', '--endpoint', '/v1/chat/completions', '--model', model_path, '--tokenizer', model_path, '--served-model-name', 'workspace-step-2-benchmark', '--dataset-name', 'random', '--random-input-len', str(case['input']), '--random-prefix-len', str(case['prefix']), '--random-output-len', str(case['output']), '--random-range-ratio', '0', '--num-prompts', '64', '--max-concurrency', str(concurrency//2), '--request-rate', 'inf', '--seed', str(case['seed']), '--num-warmups', '0', '--ignore-eos', '--extra-body', json.dumps(extra), '--save-result', '--save-detailed', '--result-dir', str(directory), '--result-filename', case['name']+'.json', '--percentile-metrics', 'ttft,tpot,itl,e2el', '--metric-percentiles', '50,95,99', '--disable-tqdm'] @app.function(image=evaluation_image, gpu='H100', cpu=8, memory=65536, timeout=14400, max_containers=1, scaledown_window=2, retries=0, volumes={'/outputs': outputs, '/root/.cache/huggingface': cache}) async def steady_worker(run_id: str, concurrency: int = 0): """Official bench serve only; sequential capacities, no task servers/trainer.""" import asyncio import contextlib import hashlib import json import os import time from importlib.metadata import version import httpx from huggingface_hub import snapshot_download from prime_rl.configs.inference import InferenceConfig import sys sys.path.insert(0, '/workspace-smoke') from training_lifecycle import stop_launcher await outputs.reload.aio() directory = Path('/outputs/prime')/run_id/'worker' directory.mkdir(parents=True, exist_ok=False) receipt = {'status': 'starting', 'trainer_gpus': 0, 'gpu': 'H100', 'cases': STEADY_CASES, 'concurrencies': steady_capacities(concurrency), 'batch_token_budget': 8192, 'requests_per_case': 64, 'output_tokens_per_configuration': 655360, 'versions': {n: version(n) for n in ('prime-rl','vllm','torch','renderers','modal')}, 'phases': [], 'started_unix': time.time(), 'contract_sha256': os.environ['WORKSPACE_CONTRACT_SHA256'], 'limitations': ['synthetic fixed output lengths; no task scores', 'shared prefix is not a multi-turn/tool/compaction replay', 'OpenAI transport benchmark; Prime generate checked only by native probe', 'no distinct weight transitions or trainer acceptance tested']} async def save(): (directory/'receipt.json').write_text(json.dumps(receipt,indent=2)+'\n') await asyncio.wait_for(outputs.commit.aio(),90) env = {**os.environ, 'PATH': '/app/.venv/bin:'+os.environ['PATH'], 'VLLM_[REDACTED_CREDENTIAL_ASSIGNMENT], 'OPENAI_[REDACTED_CREDENTIAL_ASSIGNMENT], 'VLLM_ALLOW_RUNTIME_LORA_UPDATING': 'true'} adapter = Path('/outputs/prime/training4-20261028-02/training/broadcasts/step_2') processes = []; files = [] try: assert (adapter/'.finished').is_file() digest = hashlib.sha256((adapter/'adapter_model.safetensors').read_bytes()).hexdigest() assert digest == BENCHMARK_ADAPTER_SHA256 ac = json.loads((adapter/'adapter_config.json').read_text()) assert ac['r']==16 and ac['lora_alpha']==32 receipt['adapter_sha256'] = digest frozen = calibration_config() model = await asyncio.to_thread(snapshot_download, frozen['experiment']['model'], revision=frozen['experiment']['model_revision']) # Check installed native CLI before allocating any measured load. check = await asyncio.create_subprocess_exec('/app/.venv/bin/vllm','bench','serve','--help=all', env=env,stdout=asyncio.subprocess.PIPE,stderr=asyncio.subprocess.STDOUT) help_text = (await asyncio.wait_for(check.communicate(),90))[0].decode() (directory/'bench-help.txt').write_text(help_text) assert check.returncode==0 for flag in ('--random-prefix-len','--num-warmups','--save-detailed','--max-concurrency','--extra-body'): assert flag in help_text, flag await save() for concurrency in steady_capacities(concurrency): phase_dir = directory/f'c{concurrency}'; phase_dir.mkdir() phase = {'concurrency': concurrency, 'engine_max_num_seqs': concurrency, 'client_max_concurrency_total': concurrency, 'clients': 2, 'status': 'engine_starting', 'started_unix': time.time()} receipt['phases'].append(phase); processes=[]; files=[] try: serving = steady_serving(frozen,model,phase_dir,concurrency) parsed = InferenceConfig.model_validate(serving) ns = parsed.to_namespace() assert ns.return_sampling_mask and ns.logprobs_mode=='processed_logprobs' assert ns.max_num_seqs==concurrency and ns.max_num_batched_tokens==8192 (phase_dir/'inference.json').write_text(json.dumps(serving,indent=2)+'\n') log=(phase_dir/'inference.log').open('w');files.append(log) server=await asyncio.create_subprocess_exec('/usr/bin/timeout','--signal=TERM','--kill-after=30s', '3000s','/app/.venv/bin/inference','@',str(phase_dir/'inference.json'), cwd='/app',env=env,stdout=log,stderr=log,start_new_session=True) processes.append(server);await save() async with httpx.AsyncClient(timeout=30,headers={'[REDACTED_CREDENTIAL_ASSIGNMENT]}) as client: deadline=time.monotonic()+1000 while time.monotonic() 30: await asyncio.wait_for(outputs.commit.aio(),90);last_commit=time.monotonic() await asyncio.sleep(5) collector=asyncio.create_task(metrics()) gpu_log=(phase_dir/'nvidia-smi.csv').open('w');files.append(gpu_log) gpu=await asyncio.create_subprocess_exec('nvidia-smi','--query-gpu=timestamp,utilization.gpu,utilization.memory,memory.used,power.draw','--format=csv','-l','5',stdout=gpu_log,stderr=gpu_log,start_new_session=True) processes.append(gpu) phase['cpu_cgroup_before']={str(p):p.read_text() for p in (Path('/sys/fs/cgroup/cpu.stat'),) if p.exists()} commands=[steady_command(c,concurrency,model,phase_dir) for c in STEADY_CASES] (phase_dir/'commands.json').write_text(json.dumps(commands,indent=2)+'\n') phase.update(status='benchmarking',measured_launch_unix=time.time());await save() benches=[] try: for case,cmd in zip(STEADY_CASES,commands): out=(phase_dir/(case['name']+'.log')).open('w');files.append(out) job=await asyncio.create_subprocess_exec('/usr/bin/timeout','--signal=TERM','--kill-after=30s','1800s',*cmd, env=env,cwd='/app',stdout=out,stderr=out,start_new_session=True) processes.append(job);benches.append(job) codes=await asyncio.wait_for(asyncio.gather(*(p.wait() for p in benches)),1840) phase['bench_exit_codes']=codes assert codes==[0,0], 'native benchmark failed; inspect preserved logs' for case in STEADY_CASES: result=json.loads((phase_dir/(case['name']+'.json')).read_text()) assert result.get('completed')==64, 'not all requests completed' phase['status']='completed_results_pending_review' finally: collector.cancel() with contextlib.suppress(asyncio.CancelledError):await collector phase['cpu_cgroup_after']={str(p):p.read_text() for p in (Path('/sys/fs/cgroup/cpu.stat'),) if p.exists()} except Exception as exc: phase.update(status='failed',error=repr(exc)) # No retries or automatic relaxation; other explicitly authorized capacities still run. finally: for proc in reversed(processes): await stop_launcher(proc,grace=30) for stream in files:stream.close() phase.update(finished_unix=time.time(),processes_stopped=all(p.returncode is not None for p in processes)) await save() receipt['status']='completed_with_failures' if any(p['status']=='failed' for p in receipt['phases']) else 'completed_results_pending_review' except BaseException as exc: receipt.update(status='failed',error=repr(exc));raise finally: for proc in reversed(processes): if proc.returncode is None:await stop_launcher(proc,grace=30) for stream in files: if not stream.closed:stream.close() receipt['finished_unix']=time.time();await save() return receipt @app.function(image=evaluation_image,cpu=1,memory=2048, timeout=15000,max_containers=1,retries=0,volumes={'/outputs':outputs}) async def steady_controller(run_id: str, submitted, concurrency: int = 0): import json directory=Path('/outputs/prime')/run_id;directory.mkdir(parents=True,exist_ok=False) # Execute the pinned native argparse path on this CPU-only controller first. # No engine, model generation, or benchmark main() is invoked by parsing. import asyncio commands = [steady_command(case, c, '/runtime/model', directory) for c in steady_capacities(concurrency) for case in STEADY_CASES] command_file = directory/'cpu-validation-commands.json' command_file.write_text(json.dumps(commands,indent=2)+'\n') parser_code = ( 'import json,sys; from vllm.benchmarks.serve import add_cli_args; ' 'from vllm.utils.argparse_utils import FlexibleArgumentParser; ' 'commands=json.load(open(sys.argv[1])); ' 'p=FlexibleArgumentParser(); add_cli_args(p); ' 'parsed=[vars(p.parse_args(c[3:])) for c in commands]; ' 'print(json.dumps({"commands_validated":len(parsed),' '"commands":[{k:a[k] for k in ' '("backend","num_prompts","max_concurrency","random_input_len",' '"random_prefix_len","random_output_len")} for a in parsed]}))' ) with (directory/'cpu-command-validation.log').open('w') as log: validation = await asyncio.create_subprocess_exec('/app/.venv/bin/python','-c',parser_code, str(command_file),stdout=log,stderr=log) code = await asyncio.wait_for(validation.wait(),120) await outputs.commit.aio() if code != 0: failure={'run_id':run_id,'app_id':app.app_id,'status':'cpu_command_validation_failed', 'exit_code':code,'gpu_submitted':False,'output':'workspace-agent-training:/prime/'+run_id} (directory/'campaign.json').write_text(json.dumps(failure,indent=2)+'\n');await outputs.commit.aio() await submitted.put.aio(failure) return failure call=await steady_worker.spawn.aio(run_id, concurrency=concurrency) receipt={'run_id':run_id,'app_id':app.app_id,'worker_call_id':call.object_id,'status':'worker_submitted', 'output':'workspace-agent-training:/prime/'+run_id,'max_gpu_concurrency':1} (directory/'campaign.json').write_text(json.dumps(receipt,indent=2)+'\n');await outputs.commit.aio() try: await submitted.put.aio(receipt) except Exception as exc: receipt['submission_ack_error']=repr(exc) try: result=await call.get.aio();receipt['status']=result['status'] except BaseException as exc: await call.cancel.aio();receipt.update(status='failed',error=repr(exc));raise finally: (directory/'campaign.json').write_text(json.dumps(receipt,indent=2)+'\n');await outputs.commit.aio() return receipt @app.local_entrypoint() def steady(run_id: str, launch: bool=False, concurrency: int=0): import json import subprocess from copy import deepcopy from prime_rl.configs.inference import InferenceConfig frozen=calibration_config() capacities=steady_capacities(concurrency) plan={'run_id':run_id,'concurrencies':capacities,'cases':STEADY_CASES, 'requests_per_case':64,'batch_tokens':8192,'max_gpu_concurrency':1, 'output_tokens_per_configuration':655360,'total_output_tokens':655360*len(capacities), 'engine_limit_equals_total_client_limit':True,'cpu':8,'gpu':'H100', 'case_timeout_seconds':1800,'worker_timeout_seconds':14400, 'estimate':'~7-15minutes measured/config at700-1500tokens/s, plus long-prefill/queue variability; hard limits govern', 'observed5350calls':{'output_p50_p90_p95_p99_max':[204,1658,2689,5862,8192], 'cached_prompt_p50_p90_p95_p99_max':[12144,23232,25872,28512,29568]}, 'interpretation':'long-work stress mix, not empirical-frequency replay; no quality grades or nativeRLtransport certification'} for c in capacities: parsed=InferenceConfig.model_validate(deepcopy(steady_serving(frozen,'/runtime/model',Path('/runtime/out'),c))) assert parsed.to_namespace().max_num_seqs==c if not launch:print(json.dumps(plan,indent=2));return assert modal.Workspace.from_context().hydrate().name == ACTIVE_WORKSPACE, 'Use --profile rl-next for this project' path=ROOT/'calibration'/('launch-'+run_id+'.json');assert not path.exists() assert not any(e.path.strip('/')=='prime/'+run_id for e in outputs.iterdir('/prime',recursive=False)) with modal.Queue.ephemeral() as queue: call=steady_controller.spawn(run_id,queue,concurrency=concurrency) receipt={'plan':plan,'app_id':app.app_id,'controller_call_id':call.object_id,'status':'controller_submitted'} path.write_text(json.dumps(receipt,indent=2)+'\n') try:receipt.update(remote_submission=queue.get(timeout=180));receipt['status']=receipt['remote_submission']['status'] except Exception as exc:receipt['submission_ack_error']=repr(exc) path.write_text(json.dumps(receipt,indent=2)+'\n');print(json.dumps(receipt,indent=2),flush=True) def screening116_config(replica: int = 0, pin_filename: str = "screening-selected100.json"): """Four disjoint native Harbor selections; every task has eight fresh attempts.""" import json from copy import deepcopy from prime_rl.configs.eval import EvalConfig from prime_rl.configs.inference import InferenceConfig assert replica in range(4) base = ROOT/'calibration' if modal.is_local() else Path('/workspace-calibration') assert pin_filename in ('screening-selected100.json', 'screening-round2-selected100.json') pin = json.loads((base/pin_filename).read_text()) manifest = json.loads((base/pin.get('manifest_filename', 'screening-all116-manifest.json')).read_text()) task_count = pin.get('task_count', 116) assert task_count in (100,116) and (task_count == 116 or pin.get('status') == 'cpu_qualified') shard_size = task_count // 4 names = sorted(manifest) assert len(names) == len(set(names)) == task_count frozen = deepcopy(screening64_config()) taskset = deepcopy(pin['taskset']) taskset.update(dataset=pin['combined_dataset'], tasks=names[replica*shard_size:(replica+1)*shard_size]) frozen['evaluation']['source'][0]['env']['taskset'] = taskset frozen['evaluation']['source'][0]['name'] = pin['combined_dataset'].split('@')[0] frozen['evaluation']['select']['limit'] = shard_size frozen['experiment'].update(replicas=4, task_count=task_count, total_attempts=task_count*8, total_episode_concurrency=256, task_git_commit=pin['commit'], inference_seeds=[4100,4101,4102,4103], shard_index=replica, shard_task_count=shard_size) assert frozen['evaluation']['source'][0]['env']['agent']['runtime'] == {'type':'modal','cpu':0.125,'memory':0.125} EvalConfig.model_validate(deepcopy(frozen['evaluation'])) parsed = InferenceConfig.model_validate(deepcopy(frozen['inference'])) assert parsed.router is None and parsed.to_namespace().max_num_seqs == 64 return frozen @app.function(image=evaluation_image,cpu=2,memory=8192,timeout=22200, max_containers=1,retries=0, secrets=[modal.Secret.from_name('workspace-task-registry-readonly')], volumes={'/outputs':outputs,'/root/.cache/harbor':task_cache}) async def screening116_controller(run_id: str, cpu_gate: dict, original_gate: dict | None, pin_filename: str = "screening-selected100.json"): import asyncio,json,time,sys sys.path.insert(0,'/workspace-smoke') from task_source import git_credentials,task_manifest from verifiers.v1.tasksets.harbor import HarborConfig,HarborTaskset configs=[screening116_config(i,pin_filename) for i in range(4)] pin=json.loads((Path('/workspace-calibration')/pin_filename).read_text()) task_count=pin.get('task_count',116) directory=Path('/outputs/prime')/run_id directory.mkdir(parents=True,exist_ok=False) receipt={'run_id':run_id,'app_id':app.app_id,'status':'preflight', 'started_unix':time.time(),'planned_attempts':task_count*8,'inference_gpus':4, 'trainer_gpus':0,'concurrency_per_gpu':64,'worker_call_ids':[], 'output':'workspace-agent-training:/prime/'+run_id} calls=[] async def save(): (directory/'campaign.json').write_text(json.dumps(receipt,indent=2)+'\n') await asyncio.wait_for(outputs.commit.aio(),90) try: assert len({n for c in configs for n in c['evaluation']['source'][0]['env']['taskset']['tasks']}) == task_count assert cpu_gate['status']=='selected100' and cpu_gate['selected']==pin['tasks'] if task_count==116: assert original_gate is not None and original_gate['status']=='passed' and original_gate['package_base_commit']==pin['commit'] else: assert original_gate is None and cpu_gate['package_base_commit']==pin['cpu_gate_base_commit'] assert all(any(c['task']==n and c['mode']==m and c['status']=='passed' for c in cpu_gate['checks']) for n in pin['tasks'] for m in ('noop','oracle')) (directory/'original16-cpu-gate.json').write_text(json.dumps(original_gate,indent=2)+'\n') (directory/'cpu-gate.json').write_text(json.dumps(cpu_gate,indent=2)+'\n') (directory/'frozen-configs.json').write_text(json.dumps(configs,indent=2)+'\n') expected=json.loads((Path('/workspace-calibration')/pin.get('manifest_filename','screening-all116-manifest.json')).read_text()) import hashlib for n in pin['tasks']: digest=hashlib.sha256(json.dumps(expected[n],sort_keys=True).encode()).hexdigest() assert all(any(c['task']==n and c['mode']==m and c['status']=='passed' and c.get('task_manifest_sha256')==digest for c in cpu_gate['checks']) for m in ('noop','oracle')) old_names=set(expected)-set(pin['tasks']) if task_count==116: assert len(old_names)==16 assert all(any(c['task']==n and c['mode']==m and c['status']=='passed' for c in original_gate['checks']) for n in old_names for m in ('noop','oracle')) else: assert not old_names previous=json.loads(Path('/workspace-calibration/screening-all116-manifest.json').read_text()) assert not set(expected)&set(previous), 'Round2 must be disjoint from all previously evaluated116' def validate_git(): from copy import deepcopy conf=deepcopy(configs[0]['evaluation']['source'][0]['env']['taskset']) conf['tasks']=sorted(expected) with git_credentials(): tasks=list(HarborTaskset(HarborConfig.model_validate(conf)).load()) assert len(tasks)==task_count and task_manifest(tasks)==expected assert all(t.data.upload_environment for t in tasks) await asyncio.to_thread(validate_git) await task_cache.commit.aio() receipt['native_git_manifest_verified']=True await save() for i in range(4): call=await evaluate.spawn.aio(run_id,calibration=True,replica=i,screening116=task_count==116,screening100=task_count==100) calls.append(call);receipt['worker_call_ids'].append(call.object_id) receipt['status']='workers_submitting';await save() receipt['status']='evaluating';await save() receipt['workers']=await asyncio.gather(*(c.get.aio() for c in calls)) receipt['status']='eval_processes_completed_results_pending_review' except BaseException as exc: receipt.update(status='failed',error=repr(exc)) for c in calls: try:await c.cancel.aio() except Exception:pass raise finally: receipt['updated_unix']=time.time();await save() return receipt @app.local_entrypoint() def screen116(run_id: str, launch: bool=False): import json,subprocess assert Path(run_id).name==run_id and run_id not in ('','.','..') configs=[screening116_config(i) for i in range(4)] shards=[c['evaluation']['source'][0]['env']['taskset']['tasks'] for c in configs] assert all(len(s)==29 for s in shards) and len(set(sum(shards,[])))==116 path=ROOT/'calibration'/('launch-'+run_id+'.json') if not launch: print(json.dumps(configs,indent=2));return gate=json.loads((ROOT/'.state/screening-pool200-cpu-gate.json').read_text()) original_gate=json.loads((ROOT/'.state/screening-original16-cpu-gate.json').read_text()) assert gate['status']=='selected100' and original_gate['status']=='passed','Both CPU gates must pass before GPU submission' assert not path.exists(),'Run id already submitted; inspect its durable receipt' assert modal.Workspace.from_context().hydrate().name == ACTIVE_WORKSPACE, 'Use --profile rl-next for this project' assert not any(e.path.strip('/')=='prime/'+run_id for e in outputs.iterdir('/prime',recursive=False)) call=screening116_controller.spawn(run_id,gate,original_gate) receipt={'run_id':run_id,'app_id':app.app_id,'controller_call_id':call.object_id, 'status':'controller_submitted','planned_attempts':928,'inference_gpus':4, 'trainer_gpus':0,'concurrency_per_gpu':64, 'output':'workspace-agent-training:/prime/'+run_id} path.write_text(json.dumps(receipt,indent=2)+'\n') print(json.dumps(receipt,indent=2),flush=True) @app.local_entrypoint() def screen100(run_id: str, launch: bool=False): """Second disjoint100-task inference screen, using the existing four-worker pipeline.""" import json,subprocess assert Path(run_id).name==run_id and run_id not in ('','.','..') pin_name='screening-round2-selected100.json' configs=[screening116_config(i,pin_name) for i in range(4)] shards=[c['evaluation']['source'][0]['env']['taskset']['tasks'] for c in configs] assert all(len(s)==25 for s in shards) and len(set(sum(shards,[])))==100 path=ROOT/'calibration'/('launch-'+run_id+'.json') if not launch: print(json.dumps(configs,indent=2));return gate=json.loads((ROOT/'.state/screening-round2-cpu-gate.json').read_text()) pin=json.loads((ROOT/'calibration'/pin_name).read_text()) assert gate['status']=='selected100' and gate['selected']==pin['tasks'] assert not path.exists(),'Run id already submitted; inspect its durable receipt' assert modal.Workspace.from_context().hydrate().name == ACTIVE_WORKSPACE, 'Use --profile rl-next for this project' assert not any(e.path.strip('/')=='prime/'+run_id for e in outputs.iterdir('/prime',recursive=False)) call=screening116_controller.spawn(run_id,gate,None,pin_name) receipt={'run_id':run_id,'app_id':app.app_id,'controller_call_id':call.object_id, 'status':'controller_submitted','planned_attempts':800,'inference_gpus':4, 'trainer_gpus':0,'concurrency_per_gpu':64,'task_commit':pin['commit'], 'output':'workspace-agent-training:/prime/'+run_id} path.write_text(json.dumps(receipt,indent=2)+'\n') print(json.dumps(receipt,indent=2),flush=True) def validation11_config(): """Freeze the existing held-out selection without changing training settings.""" import json from copy import deepcopy plan = json.loads((ROOT/'plans/training103-plan.json').read_text()) names = plan['split']['validation'] assert len(names) == len(set(names)) == 11 assert not set(names) & (set(plan['split']['train']) | set(plan['split']['test'])) frozen = json.loads((ROOT/'calibration/config.json').read_text()) frozen['experiment'].update(profile=ACTIVE_PROFILE, workspace=ACTIVE_WORKSPACE) frozen['evaluation']['group_size'] = 8 frozen['evaluation']['concurrency'] = {k:64 for k in ('initial_inflight','min_inflight','max_inflight')} frozen['evaluation']['source'][0]['serve']['max_concurrent'] = 64 frozen['inference']['vllm']['max_num_seqs'] = 64 frozen['experiment'].update(episode_concurrency_per_replica=64,total_episode_concurrency=64) template = deepcopy(frozen['evaluation']['source'][0]) sources, manifest, commits = [], {}, [] for index, pin_name in enumerate(('screening-selected100.json', 'screening-round2-selected100.json')): pin = json.loads((ROOT/'calibration'/pin_name).read_text()) available = json.loads((ROOT/'calibration'/pin.get('manifest_filename', 'screening-all116-manifest.json')).read_text()) selected = [name for name in names if name in available] source = deepcopy(template) source['name'] = 'validation-round'+str(index+1) source['env']['taskset'] = deepcopy(pin['taskset']) source['env']['taskset'].update(dataset=pin['combined_dataset'], tasks=selected) source['select'] = {'limit':len(selected), 'shuffle':False} source['env']['interception']['tunnel']['port'] = 8001+index assert source['env']['taskset']['repo'].endswith('@'+pin['commit']) sources.append(source) manifest.update({name:available[name] for name in selected}) commits.append(pin['commit']) assert sum(len(s['env']['taskset']['tasks']) for s in sources) == len(manifest) == 11 frozen['evaluation']['source'] = sources frozen['evaluation']['select'] = {'limit':11, 'shuffle':False} frozen['experiment'].update(task_count=11, total_attempts=88, replicas=1, attempts_per_task=8, attempts_per_task_per_replica=8, inference_seeds=[4100], task_git_commits=commits, task_git_commit=None, split='validation', trainer_gpus=0) frozen['task_manifest'] = manifest frozen['split_note'] = plan['split_review_status'] assert frozen['evaluation']['group_size'] == 8 and frozen['evaluation']['concurrency']['max_inflight'] == 64 return frozen @app.function(image=evaluation_image,cpu=2,memory=8192,timeout=8100,retries=0, secrets=[modal.Secret.from_name('workspace-official-harbor-controller'), modal.Secret.from_name('workspace-task-registry-readonly')], volumes={'/outputs':outputs,'/root/.cache/harbor':task_cache}) async def validation_controller(run_id: str, frozen: dict, comparison: dict | None = None, submit_only: bool = False): """Native CPU loader and dry-run gate, then one existing inference-only worker.""" import asyncio,json,sys,time from copy import deepcopy from prime_rl.configs.eval import EvalConfig from prime_rl.configs.inference import InferenceConfig sys.path.insert(0,'/workspace-smoke') directory=Path('/outputs/prime')/(run_id+'-controller') recovery_comparison = comparison is not None and frozen['experiment'].get('purpose') == 'length_recovery_comparison' assert not submit_only or comparison is None or recovery_comparison directory.mkdir(parents=True,exist_ok=submit_only) if submit_only and (directory/'receipt.json').exists(): existing = json.loads((directory/'receipt.json').read_text()) if existing.get('gpu_call_id'): return existing # A restarted CPU submitter must reuse its saved worker. arms = [frozen] if comparison is None else [frozen, comparison] if comparison is not None: left, right = deepcopy(frozen), deepcopy(comparison) if recovery_comparison: _validate_recovery_arms(left, right) else: assert left['experiment']['purpose'] == right['experiment']['purpose'] == 'output_limit_comparison' assert [left['evaluation']['sampling']['max_tokens'], right['evaluation']['sampling']['max_tokens']] == [8192, 16384] right['evaluation']['sampling']['max_tokens'] = 8192 assert left == right, 'Only the output token limit may differ between arms' receipt={'run_id':run_id,'app_id':app.app_id,'status':'cpu_preflight', 'planned_attempts':sum(arm['experiment']['total_attempts'] for arm in arms), 'trainer_gpus':0,'inference_gpus':1,'started_unix':time.time()} async def save(): (directory/'receipt.json').write_text(json.dumps(receipt,indent=2)+'\n') await asyncio.wait_for(outputs.commit.aio(),90) try: await save() for arm in arms: _validate_evaluation_budget(arm) EvalConfig.model_validate(deepcopy(arm['evaluation'])) if recovery_comparison: from bash_recovery import verify_runtime receipt['recovery_runtime'] = verify_runtime(frozen['runtime_sha256']['bash_recovery.py']) receipt['opt_in_recovery_bundle_verified'] = True serving=InferenceConfig.model_validate(deepcopy(frozen['inference'])) assert serving.router is None and serving.to_namespace().max_num_seqs==64 load_evaluation_tasks(frozen['evaluation']['source'], frozen['task_manifest']) await task_cache.commit.aio() for arm in arms: suffix = ('-recovery'+arm['evaluation']['source'][0]['env']['agent']['harness']['env']['VF_BASH_LENGTH_RECOVERY'] if recovery_comparison else '' if comparison is None else '-'+str(arm['evaluation']['sampling']['max_tokens'])) config=deepcopy(arm['evaluation']);config['output_dir']=str(directory/('dry-run'+suffix)) path=directory/('eval'+suffix+'.json');path.write_text(json.dumps(config,indent=2)+'\n') with (directory/('dry-run'+suffix+'.log')).open('w') as log: process=await asyncio.create_subprocess_exec('/app/.venv/bin/eval','@',str(path),'--dry-run', cwd='/app',stdout=log,stderr=log,start_new_session=True) try:code=await asyncio.wait_for(process.wait(),120) except asyncio.TimeoutError: from training_lifecycle import stop_launcher await stop_launcher(process);raise assert code==0,'Native eval CPU dry-run failed' receipt.update(native_git_manifests_verified=True,native_eval_dry_run_passed=True,status='cpu_preflight_passed') (directory/'frozen-config.json').write_text(json.dumps(frozen,indent=2)+'\n') await save() if recovery_comparison: call = await recovery_comparison_worker.spawn.aio(run_id, frozen, comparison) receipt.update(status='gpu_submitted', gpu_call_id=call.object_id, arm_run_ids=[run_id+'-off', run_id+'-on'], comparison_output='/prime/'+run_id+'-comparison/receipt.json') await save() return receipt receipt['arms'] = [] for arm in arms: limit = arm['evaluation']['sampling']['max_tokens'] arm_id = run_id if comparison is None else run_id+'-limit'+str(limit) worker = evaluate.with_options(gpu='H100!') if comparison is not None or submit_only else evaluate call=await worker.spawn.aio(arm_id,calibration=True,replica=0,validation=arm) item = {'run_id':arm_id, 'output_token_limit':limit, 'gpu_call_id':call.object_id, 'status':'gpu_submitted', 'submitted_unix':time.time()} receipt['arms'].append(item) receipt.update(status='gpu_submitted',gpu_call_id=call.object_id);await save() if submit_only: return receipt # The detached GPU owns execution; no long-lived CPU waiter. result=await call.get.aio() assert result['authentication_verified'] and result['generation_verified'] assert result['eval_exit_code'] == 0 and result['processes_stopped'] item.update(status=result['status'], result=result, ended_unix=time.time()) receipt.update(status=result['status'],result=result);await save() except BaseException as error: receipt.update(status='failed',error_type=type(error).__name__,error=str(error));raise finally: receipt['ended_unix']=time.time();await save() return receipt @app.local_entrypoint() def validate11(run_id: str, launch: bool=False): import json,subprocess assert Path(run_id).name==run_id and run_id not in ('','.','..') frozen=validation11_config() path=ROOT/'calibration'/('launch-'+run_id+'.json') frozen_path=ROOT/'calibration'/(run_id+'-frozen.json') if not launch: print(json.dumps(frozen,indent=2));return assert modal.Workspace.from_context().hydrate().name == ACTIVE_WORKSPACE, 'Use --profile rl-next for this project' assert not path.exists() and not frozen_path.exists(),'Use the existing receipt; never duplicate-launch' frozen_path.write_text(json.dumps(frozen,indent=2)+'\n') call=validation_controller.spawn(run_id,frozen) receipt={'run_id':run_id,'app_id':app.app_id,'controller_call_id':call.object_id, 'status':'controller_submitted','planned_attempts':88,'task_count':11,'attempts_per_task':8, 'inference_gpus':1,'trainer_gpus':0,'concurrency':64,'model':frozen['experiment']['model'], 'model_revision':frozen['experiment']['model_revision'], 'task_git_commits':frozen['experiment']['task_git_commits'], 'output':'workspace-agent-training:/prime/'+run_id} path.write_text(json.dumps(receipt,indent=2)+'\n') print(json.dumps(receipt,indent=2),flush=True) @app.function(image=evaluation_image,cpu=1,memory=4096,timeout=600,retries=0, secrets=[modal.Secret.from_name(name) for name in ('workspace-official-harbor-controller','workspace-task-registry-readonly','wandb')], volumes={'/outputs':outputs,'/root/.cache/huggingface':cache,'/root/.cache/harbor':task_cache}) def account_cpu_check(run_id: str, frozen: dict): """Validate recreated account resources without a model, trainer or GPU.""" import json,os,subprocess,sys,time from copy import deepcopy import wandb from prime_rl.configs.eval import EvalConfig from prime_rl.configs.inference import InferenceConfig sys.path.insert(0,'/workspace-smoke') from task_source import git_credentials,task_manifest from verifiers.v1.tasksets.harbor import HarborConfig,HarborTaskset directory=Path('/outputs/prime')/run_id;directory.mkdir(parents=True,exist_ok=False) receipt={'run_id':run_id,'workspace':ACTIVE_WORKSPACE,'app_id':app.app_id, 'status':'checking','gpu_calls':0,'model_calls':0,'started_unix':time.time()} box=None try: assert modal.Workspace.from_context().hydrate().name==ACTIVE_WORKSPACE required=('TASK_REGISTRY_SSH_KEY','TASK_REGISTRY_KNOWN_HOSTS','WANDB_API_KEY','MODAL_TOKEN_ID','MODAL_TOKEN_SECRET') assert all(os.environ.get(key) for key in required) controller_client=modal.Client.from_credentials(os.environ['MODAL_TOKEN_ID'],os.environ['MODAL_TOKEN_SECRET']) assert modal.Workspace.from_context(client=controller_client).hydrate().name==ACTIVE_WORKSPACE receipt['controller_credentials_target_verified']=True api=wandb.Api(timeout=20);viewer=api.viewer username=viewer.get('username') if isinstance(viewer,dict) else viewer.username assert username=='susindrar' and api.project('workspace-agent-rl',entity='susindrar-university-of-houston') is not None receipt['wandb_authentication_verified']=True with git_credentials(): tasks=[task for source in frozen['evaluation']['source'] for task in HarborTaskset(HarborConfig.model_validate(deepcopy(source['env']['taskset']))).load()] assert task_manifest(tasks)==frozen['task_manifest'] and len(tasks)==11 assert all(task.data.upload_environment for task in tasks) receipt['native_git_manifests_verified']=11 EvalConfig.model_validate(deepcopy(frozen['evaluation'])) assert InferenceConfig.model_validate(deepcopy(frozen['inference'])).router is None cfg=deepcopy(frozen['evaluation']);cfg['output_dir']=str(directory/'dry-run') path=directory/'eval.json';path.write_text(json.dumps(cfg,indent=2)+'\n') with (directory/'dry-run.log').open('w') as log: check=subprocess.run(['/app/.venv/bin/eval','@',str(path),'--dry-run'],cwd='/app', stdout=log,stderr=log,timeout=120) assert check.returncode==0,'Native eval dry-run failed' receipt['native_eval_dry_run_passed']=True marker=json.dumps({'workspace':ACTIVE_WORKSPACE,'run_id':run_id}) for root in ('/outputs','/root/.cache/huggingface','/root/.cache/harbor'): probe=Path(root)/'.account-setup-check.json';probe.write_text(marker) assert probe.read_text()==marker cache.commit();task_cache.commit();outputs.commit() receipt['three_volumes_read_write_verified']=True box=modal.Sandbox.create('python','-c','print("ACCOUNT_CPU_OK")', image=modal.Image.debian_slim(python_version='3.12'),app=app, cpu=0.125,memory=128,timeout=60) receipt['sandbox_id']=box.object_id result=box.stdout.read();box.wait() assert box.returncode==0 and result.strip()=='ACCOUNT_CPU_OK' receipt.update(cpu_sandbox_verified=True,status='passed') except BaseException as error: receipt.update(status='failed',error_type=type(error).__name__) raise finally: if box is not None: box.terminate();receipt['sandbox_terminated']=True receipt['ended_unix']=time.time() (directory/'receipt.json').write_text(json.dumps(receipt,indent=2)+'\n');outputs.commit() print(json.dumps(receipt,indent=2),flush=True) return receipt @app.local_entrypoint() def prepare_account(run_id: str): """Submit the CPU-only account check; GPU functions are never called.""" import json assert Path(run_id).name==run_id and run_id not in ('','.','..') assert modal.Workspace.from_context().hydrate().name==ACTIVE_WORKSPACE,'Use --profile rl-next' receipt_path=ROOT/'.state'/('launch-'+run_id+'.json') assert not receipt_path.exists(),'Account check already submitted' frozen=validation11_config() call=account_cpu_check.spawn(run_id,frozen) receipt={'run_id':run_id,'app_id':app.app_id,'call_id':call.object_id,'status':'cpu_check_submitted', 'profile':ACTIVE_PROFILE,'workspace':ACTIVE_WORKSPACE,'gpu_calls':0, 'output':'workspace-agent-training:/prime/'+run_id} receipt_path.write_text(json.dumps(receipt,indent=2)+'\n');print(json.dumps(receipt,indent=2),flush=True) OUTPUT_LIMIT_TASKS = ('task_03964_fc89b9', 'task_02367_865b08', 'task_04253_b72253', 'task_04928_0f691a') def _validate_evaluation_budget(frozen: dict): experiment = frozen['experiment'] names = [name for source in frozen['evaluation']['source'] for name in source['env']['taskset']['tasks']] assert len(names) == len(set(names)) == len(frozen['task_manifest']) == experiment['task_count'] assert set(names) == set(frozen['task_manifest']) assert frozen['evaluation']['group_size'] == 8 assert experiment['total_attempts'] == len(names) * 8 if experiment.get('purpose') == 'output_limit_comparison': assert set(names) == set(OUTPUT_LIMIT_TASKS) and experiment['total_attempts'] == 32 assert frozen['evaluation']['sampling']['max_tokens'] in (8192, 16384) elif experiment.get('purpose') in ('temperature_probe', 'length_recovery_comparison'): assert set(names) == set(OUTPUT_LIMIT_TASKS[:2]) and experiment['total_attempts'] == 16 assert frozen['evaluation']['sampling']['max_tokens'] == 8192 assert frozen['evaluation']['sampling']['temperature'] == 0.6 if experiment['purpose'] == 'length_recovery_comparison': assert all(source['env']['agent']['harness']['env'].get('VF_BASH_LENGTH_RECOVERY') in ('0', '1') for source in frozen['evaluation']['source']) elif experiment.get('purpose') == 'final_heldout': assert experiment['task_count'] in (11, 12) assert frozen['evaluation']['sampling']['max_tokens'] == 8192 assert frozen['evaluation']['sampling']['temperature'] == 0.6 assert all(source['env']['agent']['harness']['env']['VF_BASH_LENGTH_RECOVERY']=='1' for source in frozen['evaluation']['source']) else: assert experiment['task_count'] == 11 and experiment['total_attempts'] == 88 def output_limit_configs(): """Subset the actual previous evaluation; alter only the per-turn output cap.""" import json from copy import deepcopy baseline = json.loads((ROOT/'calibration/validation11-c64-20261029-01-frozen.json').read_text()) selected = set(OUTPUT_LIMIT_TASKS) baseline['experiment'].update(profile=ACTIVE_PROFILE, workspace=ACTIVE_WORKSPACE, task_count=4, total_attempts=32, purpose='output_limit_comparison', gpu_per_replica='H100!', split='diagnostic_on_previously_evaluated_validation_tasks') baseline['diagnostic_note'] = ('Failure-enriched selection, not an unbiased evaluation or training task reassignment. ' 'Both arms rerun all 32 attempts fresh; no old attempts merged. ' 'Concurrency cap remains 64, with at most 32 attempts available per arm.') baseline['evaluation']['select'] = {'limit':4, 'shuffle':False} for source in baseline['evaluation']['source']: names = [name for name in source['env']['taskset']['tasks'] if name in selected] assert names source['env']['taskset']['tasks'] = names source['select'] = {'limit':len(names), 'shuffle':False} baseline['task_manifest'] = {name:baseline['task_manifest'][name] for name in OUTPUT_LIMIT_TASKS} candidate = deepcopy(baseline) candidate['evaluation']['sampling']['max_tokens'] = 16384 for arm in (baseline, candidate): _validate_evaluation_budget(arm) return baseline, candidate @app.local_entrypoint() def compare_output_limits(run_id: str, launch: bool = False): """Exactly two sequential inference-only arms, using the existing evaluator.""" import json assert Path(run_id).name == run_id and run_id not in ('', '.', '..') baseline, candidate = output_limit_configs() if not launch: print(json.dumps({'arms':[baseline,candidate]},indent=2));return assert modal.Workspace.from_context().hydrate().name == ACTIVE_WORKSPACE, 'Use --profile rl-next' path = ROOT/'calibration'/('launch-'+run_id+'.json') assert not path.exists(), 'Use the submitted controller; never duplicate-launch' frozen_path = ROOT/'calibration'/(run_id+'-frozen.json') frozen_path.write_text(json.dumps({'arms':[baseline,candidate]},indent=2)+'\n') call = validation_controller.with_options(timeout=14400).spawn(run_id,baseline,comparison=candidate) receipt = {'run_id':run_id, 'app_id':app.app_id, 'controller_call_id':call.object_id, 'status':'cpu_preflight_submitted', 'profile':ACTIVE_PROFILE, 'workspace':ACTIVE_WORKSPACE, 'planned_attempts':64, 'task_count':4, 'attempts_per_task_per_arm':8, 'output_token_limits':[8192,16384], 'concurrency_cap':64, 'inference_gpus_at_once':1, 'gpu_type':'H100!', 'trainer_gpus':0, 'tasks':list(OUTPUT_LIMIT_TASKS), 'output':'workspace-agent-training:/prime/'+run_id+'-controller', 'arm_outputs':['workspace-agent-training:/prime/'+run_id+'-limit'+str(limit)+'/replica-0' for limit in (8192,16384)]} path.write_text(json.dumps(receipt,indent=2)+'\n') print(json.dumps(receipt,indent=2),flush=True) def temperature_probe_config(): frozen, _ = output_limit_configs() selected = set(OUTPUT_LIMIT_TASKS[:2]) frozen['experiment'].update(task_count=2, total_attempts=16, purpose='temperature_probe', reference_baseline_run='output-limit4-20261030-01-limit8192') frozen['diagnostic_note'] = ('Two previously cutoff-affected tasks, eight fresh attempts each. ' 'Keep output8192/thinkingtrue; change temperature1.0 to0.6. ' 'Failure-enriched diagnostic; at most16 active attempts under the unchanged64 cap. ' 'Historical baseline used a larger4-task cohort, so time comparisons are descriptive.') frozen['evaluation']['sampling']['temperature'] = 0.6 frozen['evaluation']['select']['limit'] = 2 sources = [] for source in frozen['evaluation']['source']: names = [name for name in source['env']['taskset']['tasks'] if name in selected] if not names: continue source['env']['taskset']['tasks'] = names source['select']['limit'] = len(names) source['env']['interception']['tunnel']['port'] = 8001+len(sources) sources.append(source) frozen['evaluation']['source'] = sources frozen['task_manifest'] = {name:frozen['task_manifest'][name] for name in OUTPUT_LIMIT_TASKS[:2]} _validate_evaluation_budget(frozen) return frozen @app.local_entrypoint() def probe_temperature(run_id: str, launch: bool = False): import json assert Path(run_id).name == run_id and run_id not in ('', '.', '..') frozen = temperature_probe_config() if not launch: print(json.dumps(frozen,indent=2));return assert modal.Workspace.from_context().hydrate().name == ACTIVE_WORKSPACE, 'Use --profile rl-next' path = ROOT/'calibration'/('launch-'+run_id+'.json') assert not path.exists(), 'Use the existing submitted worker; never duplicate-launch' (ROOT/'calibration'/(run_id+'-frozen.json')).write_text(json.dumps(frozen,indent=2)+'\n') call = validation_controller.spawn(run_id,frozen,submit_only=True) receipt = {'run_id':run_id, 'app_id':app.app_id, 'controller_call_id':call.object_id, 'status':'cpu_preflight_submitted', 'profile':ACTIVE_PROFILE, 'workspace':ACTIVE_WORKSPACE, 'planned_attempts':16, 'tasks':list(OUTPUT_LIMIT_TASKS[:2]), 'attempts_per_task':8, 'temperature':0.6, 'max_tokens':8192, 'thinking':True, 'concurrency_cap':64, 'inference_gpus':1, 'gpu_type':'H100!', 'trainer_gpus':0, 'output':'workspace-agent-training:/prime/'+run_id, 'reference_baseline_run':frozen['experiment']['reference_baseline_run']} path.write_text(json.dumps(receipt,indent=2)+'\n') print(json.dumps(receipt,indent=2),flush=True) def _validate_recovery_arms(baseline: dict, candidate: dict): from copy import deepcopy left, right = deepcopy(baseline), deepcopy(candidate) assert left['experiment']['purpose'] == right['experiment']['purpose'] == 'length_recovery_comparison' for arm, setting in ((left, '0'), (right, '1')): _validate_evaluation_budget(arm) for source in arm['evaluation']['source']: assert source['env']['agent']['harness']['env']['VF_BASH_LENGTH_RECOVERY'] == setting source['env']['agent']['harness']['env']['VF_BASH_LENGTH_RECOVERY'] = '0' assert left == right, 'Only the per-episode recovery setting may differ' def recovery_comparison_configs(): import hashlib from copy import deepcopy baseline = temperature_probe_config() baseline['experiment'].update(purpose='length_recovery_comparison', reference_baseline_run='temperature2-t06-8k-20261030-01') baseline['diagnostic_note'] = ('Two cutoff-affected tasks x8 fresh attempts per arm; ' '32 total, sequential arms on one H100. Only opt-in no-tool length recovery differs. ' 'One corrective request per episode; failed raw generation remains in native traces ' 'but is omitted from the next model prompt. Thinking and all other budgets unchanged. ' 'Failure-enriched diagnostic, not a blind evaluation; later arm may benefit from warm caches.') baseline['runtime_sha256']['bash_recovery.py'] = hashlib.sha256((ROOT/'bash_recovery.py').read_bytes()).hexdigest() for source in baseline['evaluation']['source']: source['env']['agent']['harness'].setdefault('env', {})['VF_BASH_LENGTH_RECOVERY'] = '0' candidate = deepcopy(baseline) for source in candidate['evaluation']['source']: source['env']['agent']['harness']['env']['VF_BASH_LENGTH_RECOVERY'] = '1' _validate_recovery_arms(baseline, candidate) return baseline, candidate @app.function(image=evaluation_image, gpu='H100!', cpu=8, memory=65536, timeout=14400, retries=0, scaledown_window=2, max_containers=1, secrets=[modal.Secret.from_name('workspace-official-harbor-controller'), modal.Secret.from_name('workspace-task-registry-readonly')], volumes={'/outputs':outputs, '/root/.cache/huggingface':cache, '/root/.cache/harbor':task_cache}) async def recovery_comparison_worker(run_id: str, baseline: dict, candidate: dict): """Reuse the existing native evaluator twice on the same allocated GPU.""" import asyncio, json, time _validate_recovery_arms(baseline, candidate) directory = Path('/outputs/prime')/(run_id+'-comparison') directory.mkdir(parents=True, exist_ok=False) receipt = {'run_id':run_id, 'app_id':app.app_id, 'status':'starting', 'started_unix':time.time(), 'planned_attempts':32, 'inference_gpus':1, 'trainer_gpus':0, 'arms':[]} async def save(): (directory/'receipt.json').write_text(json.dumps(receipt,indent=2)+'\n') await asyncio.wait_for(outputs.commit.aio(), 90) try: for label, frozen in (('off', baseline), ('on', candidate)): receipt['status'] = 'running_'+label await save() result = await evaluate.local(run_id+'-'+label, calibration=True, replica=0, validation=frozen) receipt['arms'].append({'arm':label, 'result':result}) await save() assert result['authentication_verified'] and result['generation_verified'] assert result['eval_exit_code'] == 0 and result['processes_stopped'] receipt['status'] = 'both_eval_processes_completed_results_pending_review' except BaseException as error: receipt.update(status='failed', error_type=type(error).__name__, error=str(error)) raise finally: receipt['ended_unix'] = time.time() await save() return receipt @app.local_entrypoint() def compare_recovery(run_id: str, launch: bool = False): import json baseline, candidate = recovery_comparison_configs() if not launch: print(json.dumps({'arms':[baseline,candidate]},indent=2));return assert Path(run_id).name == run_id and run_id not in ('', '.', '..') assert modal.Workspace.from_context().hydrate().name == ACTIVE_WORKSPACE, 'Use --profile rl-next' path = ROOT/'calibration'/('launch-'+run_id+'.json') frozen_path = ROOT/'calibration'/(run_id+'-frozen.json') assert not path.exists() and not frozen_path.exists(), 'Use existing submitted call; never duplicate-launch' frozen_path.write_text(json.dumps({'arms':[baseline,candidate]},indent=2)+'\n') call = validation_controller.spawn(run_id, baseline, comparison=candidate, submit_only=True) receipt = {'run_id':run_id, 'app_id':app.app_id, 'controller_call_id':call.object_id, 'status':'cpu_preflight_submitted', 'profile':ACTIVE_PROFILE, 'workspace':ACTIVE_WORKSPACE, 'planned_attempts':32, 'tasks':list(OUTPUT_LIMIT_TASKS[:2]), 'attempts_per_task_per_arm':8, 'temperature':0.6, 'max_tokens':8192, 'thinking':True, 'concurrency_cap':64, 'recovery_budget_per_episode':[0,1], 'inference_gpus':1, 'gpu_type':'H100!', 'trainer_gpus':0, 'output':'workspace-agent-training:/prime/'+run_id+'-comparison', 'arm_outputs':['workspace-agent-training:/prime/'+run_id+'-'+label+'/replica-0' for label in ('off','on')]} path.write_text(json.dumps(receipt,indent=2)+'\n') print(json.dumps(receipt,indent=2),flush=True) def tiny_training_config(): import hashlib,json,tomllib from copy import deepcopy task = 'task_00376_dc3706' assert task in json.loads((ROOT/'plans/training103-plan.json').read_text())['split']['train'] source = deepcopy(json.loads((ROOT/'calibration/temperature2-t06-8k-20261030-01-frozen.json').read_text())['evaluation']['source'][0]) source['name'] = 'tiny-training' source['env']['taskset']['tasks'] = [task] source['select'] = {'limit':1, 'shuffle':False} source['serve']['max_concurrent'] = 8 source['env']['agent']['harness']['env'] = {'VF_BASH_LENGTH_RECOVERY':'1'} config = tomllib.loads((ROOT/'train.toml').read_text()) config.update(max_steps=1, output_dir='/outputs/prime/TINY', dashboard=False, run={'name':'training'}) config['ckpt'] = {'interval':1} orch = config['orchestrator'] orch.update(batch_size=8, max_off_policy_steps=0, eval=None, concurrency={'initial_inflight':8,'min_inflight':8,'max_inflight':8}) orch['train'].update(group_size=8, source=[source]) orch['train']['sampling']['temperature'] = 0.6 config['inference'].update(router=None) config['inference']['vllm']['max_num_seqs'] = 64 manifest = json.loads((ROOT/'calibration/screening-round2-manifest.json').read_text()) result = {'training':config, 'task_manifest':{task:manifest[task]}, 'recovery_sha256':hashlib.sha256((ROOT/'bash_recovery.py').read_bytes()).hexdigest(), 'purpose':'one-update-small-batch-smoke', 'profile':ACTIVE_PROFILE, 'workspace':ACTIVE_WORKSPACE} validate_tiny_training(result) return result def validate_tiny_training(frozen): from copy import deepcopy from prime_rl.configs.rl import RLConfig config = deepcopy(frozen['training']) parsed = RLConfig.model_validate(config) assert parsed.max_steps == 1 and parsed.orchestrator.batch_size == 8 assert parsed.orchestrator.train.group_size == 8 and parsed.orchestrator.eval is None assert parsed.orchestrator.concurrency.max_inflight == 8 assert parsed.orchestrator.max_off_policy_steps == 0 assert parsed.inference.vllm.max_num_seqs == 64 and parsed.inference.router is None assert parsed.deployment.gpus_per_node == 2 assert parsed.orchestrator.train.sampling.temperature == 0.6 assert parsed.orchestrator.train.sampling.max_completion_tokens == 8192 sources = frozen['training']['orchestrator']['train']['source'] assert len(sources)==1 and sources[0]['env']['taskset']['tasks'] == ['task_00376_dc3706'] assert sources[0]['env']['agent']['harness']['env'] == {'VF_BASH_LENGTH_RECOVERY':'1'} assert config['ckpt']['interval'] == 1 @app.function(image=evaluation_image,cpu=2,memory=8192,timeout=600,retries=0, secrets=[modal.Secret.from_name('workspace-task-registry-readonly')], volumes={'/outputs':outputs,'/root/.cache/harbor':task_cache}) async def tiny_training_controller(run_id: str, frozen: dict): import asyncio,json,os,sys from copy import deepcopy sys.path.insert(0,'/workspace-smoke') from bash_recovery import verify_runtime validate_tiny_training(frozen) directory = Path('/outputs/prime')/(run_id+'-preflight') directory.mkdir(parents=True,exist_ok=False) receipt = {'run_id':run_id,'app_id':app.app_id,'status':'cpu_preflight','trainer_gpus':1,'inference_gpus':1} try: receipt['recovery_runtime'] = verify_runtime(frozen['recovery_sha256']) tasks = load_evaluation_tasks(frozen['training']['orchestrator']['train']['source'],frozen['task_manifest']) assert len(tasks)==1 await task_cache.commit.aio() config = deepcopy(frozen['training']);config['output_dir']=str(directory/'dry-run') path=directory/'training.json';path.write_text(json.dumps(config,indent=2)+'\n') with (directory/'dry-run.log').open('w') as log: process=await asyncio.create_subprocess_exec('/usr/bin/timeout','180s','/app/.venv/bin/rl','@',str(path),'--dry-run', cwd='/app',env={**os.environ,'WANDB_MODE':'disabled','VLLM_[REDACTED_CREDENTIAL_ASSIGNMENT]},stdout=log,stderr=log) code=await asyncio.wait_for(process.wait(),195) assert code==0,'Native RL CPU dry-run failed; GPU not submitted' receipt.update(native_cpu_dry_run_passed=True,native_task_manifest_verified=True) (directory/'frozen.json').write_text(json.dumps(frozen,indent=2)+'\n') (directory/'receipt.json').write_text(json.dumps(receipt,indent=2)+'\n');await outputs.commit.aio() call=await train.with_options(timeout=2400,retries=0).spawn.aio(run_id,max_steps=1,rollout_concurrency=8,tiny=frozen) receipt.update(status='training_submitted',gpu_call_id=call.object_id) except BaseException as error: receipt.update(status='failed',error=repr(error));raise finally: (directory/'receipt.json').write_text(json.dumps(receipt,indent=2)+'\n');await outputs.commit.aio() return receipt @app.local_entrypoint() def tiny_train(run_id: str, launch: bool = False): import json frozen=tiny_training_config() if not launch: print(json.dumps(frozen,indent=2));return assert Path(run_id).name==run_id and run_id not in ('','.','..') assert modal.Workspace.from_context().hydrate().name==ACTIVE_WORKSPACE,'Use --profile rl-next' path=ROOT/'calibration'/('launch-'+run_id+'.json') frozen_path=ROOT/'calibration'/(run_id+'-frozen.json') assert not path.exists() and not frozen_path.exists(),'Never duplicate-launch' frozen_path.write_text(json.dumps(frozen,indent=2)+'\n') call=tiny_training_controller.spawn(run_id,frozen) receipt={'run_id':run_id,'app_id':app.app_id,'controller_call_id':call.object_id, 'status':'cpu_preflight_submitted','profile':ACTIVE_PROFILE,'workspace':ACTIVE_WORKSPACE, 'trainer_gpus':1,'inference_gpus':1,'updates':1,'batch_size':8,'group_size':8, 'output':'workspace-agent-training:/prime/'+run_id} path.write_text(json.dumps(receipt,indent=2)+'\n');print(json.dumps(receipt,indent=2),flush=True) @app.function(image=evaluation_image,cpu=2,memory=8192,timeout=1800,retries=0, secrets=[modal.Secret.from_name('workspace-task-registry-readonly')], volumes={'/outputs':outputs,'/root/.cache/harbor':task_cache}) async def final_training_controller(run_id: str, frozen: dict): """Verify all 103 task manifests and native schemas before submitting 3 GPUs.""" import asyncio,json,os,sys from copy import deepcopy sys.path.insert(0,'/workspace-smoke') from final_training import validate,verify_runtime,digest validate(frozen) directory=Path('/outputs/prime')/(run_id+'-preflight') directory.mkdir(parents=True,exist_ok=False) # Never replay an ambiguous paid submission. receipt={'run_id':run_id,'app_id':app.app_id,'status':'cpu_preflight', 'frozen_sha256':digest(frozen),'gpu_submissions':0,'dry_runs':[]} async def save(): (directory/'receipt.json').write_text(json.dumps(receipt,indent=2)+'\n') await asyncio.wait_for(outputs.commit.aio(),90) try: (directory/'frozen.json').write_text(json.dumps(frozen,indent=2)+'\n') await save() receipt['runtime']=verify_runtime(frozen) sources=deepcopy(frozen['training']['orchestrator']['train']['source']) sources += [source for shard in frozen['evaluation_shards'] for source in shard['evaluation']['source']] tasks=load_evaluation_tasks(sources,frozen['task_manifest']) assert len(tasks)==103 receipt['verified_task_count']=103 await task_cache.commit.aio() checks=[('training','rl',deepcopy(frozen['training']))] for index, shard in enumerate(frozen['evaluation_shards']): for arm in ('base','final'): config=deepcopy(shard['evaluation']) if arm=='final':config['model']='workspace-final-step10' checks.append((f'eval-{index}-{arm}','eval',config)) for label,command,config in checks: config['output_dir']=str(directory/label) path=directory/(label+'.json');path.write_text(json.dumps(config,indent=2)+'\n') with (directory/(label+'.log')).open('w') as log: process=await asyncio.create_subprocess_exec('/usr/bin/timeout','--signal=TERM','--kill-after=10s','180s', '/app/.venv/bin/'+command,'@',str(path),'--dry-run',cwd='/app', env={**os.environ,'WANDB_MODE':'disabled','VLLM_[REDACTED_CREDENTIAL_ASSIGNMENT]}, stdout=log,stderr=log,start_new_session=True) try: code=await asyncio.wait_for(process.wait(),195) finally: if process.returncode is None: from training_lifecycle import stop_launcher await stop_launcher(process) assert code==0,f'Native {label} CPU dry-run failed; no GPUs submitted' receipt['dry_runs'].append(label) await save() receipt.update(status='cpu_preflight_passed',native_cpu_dry_runs_passed=True,native_task_manifests_verified=True) await save() # Persist intent before spawn. On interrupted submission, inspect Modal rather than retrying. receipt['status']='training_submission_started';await save() call=await train.with_options(gpu='H100:3',timeout=frozen['function_timeout_seconds'],retries=0).spawn.aio( run_id,max_steps=10,rollout_concurrency=128,final=frozen) receipt.update(status='training_submitted',gpu_call_id=call.object_id,gpu_submissions=1) except BaseException as error: receipt.update(status='failed',error=repr(error));raise finally: await save() return receipt @app.function(image=evaluation_image,cpu=1,memory=2048,timeout=900,retries=0, volumes={'/outputs':outputs}) async def final_evaluation_handoff(run_id: str, frozen: dict, training_call_id: str): """Short continuation: start eval only after the training FunctionCall returned.""" import asyncio,json,sys sys.path.insert(0,'/workspace-smoke') from final_training import validate,digest validate(frozen) directory=Path('/outputs/prime')/(run_id+'-heldout') directory.mkdir(parents=True,exist_ok=False) receipt={'run_id':run_id,'status':'waiting_for_training_return','training_call_id':training_call_id, 'frozen_sha256':digest(frozen),'evaluation_calls':[],'planned_attempts':368} async def save(): (directory/'receipt.json').write_text(json.dumps(receipt,indent=2)+'\n') await asyncio.wait_for(outputs.commit.aio(),90) try: await save() result=await modal.FunctionCall.from_id(training_call_id).get.aio(timeout=300) assert result['status']=='completed' and result['launcher_stopped'] and result['checkpoint_metadata_verified'] # The trainer input is finished; its configured idle scale-down is two seconds. await asyncio.sleep(10) await outputs.reload.aio() for shard in (0,1): receipt.update(status='evaluation_submission_started',submitting_shard=shard) await save() call=await final_heldout_worker.spawn.aio(run_id,frozen,shard) receipt['evaluation_calls'].append({'shard':shard,'call_id':call.object_id}) await save() receipt.update(status='heldout_submitted',trainer_function_returned=True) except BaseException as error: receipt.update(status='failed',error=repr(error));raise finally: await save() return receipt @app.function(image=evaluation_image,gpu='H100',cpu=8,memory=65536,timeout=14400,retries=0, max_containers=2,scaledown_window=2, secrets=[modal.Secret.from_name('workspace-official-harbor-controller'), modal.Secret.from_name('workspace-task-registry-readonly')], volumes={'/outputs':outputs,'/root/.cache/huggingface':cache,'/root/.cache/harbor':task_cache}) async def final_heldout_worker(run_id: str, frozen: dict, shard: int): """Matched base/final arms per shard, after trainer GPU release.""" import asyncio,json,sys,time sys.path.insert(0,'/workspace-smoke') from final_training import validate,audit_evaluation,digest validate(frozen);assert shard in (0,1) selected=frozen['evaluation_shards'][shard] directory=Path('/outputs/prime')/(run_id+'-heldout')/f'shard-{shard}' directory.mkdir(parents=True,exist_ok=False) receipt={'run_id':run_id,'shard':shard,'status':'starting','frozen_sha256':digest(frozen), 'started_unix':time.time(),'planned_attempts':selected['experiment']['total_attempts']*2,'arms':[]} async def save(): (directory/'receipt.json').write_text(json.dumps(receipt,indent=2)+'\n') await asyncio.wait_for(outputs.commit.aio(),90) try: for arm in ('base','final'): receipt['status']='running_'+arm;await save() arm_run=f'{run_id}-heldout-{shard}-{arm}' result=await evaluate.local(arm_run,adapter_run=run_id if arm=='final' else '', calibration=True,replica=0,validation=selected,adapter_step=10) assert result['eval_exit_code']==0 and result['processes_stopped'] assert result['authentication_verified'] and result['generation_verified'] assert result['adapter_loaded']==(arm=='final') audit=audit_evaluation(Path('/outputs/prime')/arm_run/'replica-0',selected['task_manifest']) receipt['arms'].append({'arm':arm,'run_id':arm_run,'result':result,'audit':audit}) await save() receipt['status']='completed_and_graded' except BaseException as error: receipt.update(status='failed',error=repr(error));raise finally: receipt['ended_unix']=time.time();await save() return receipt @app.local_entrypoint() def final_train(run_id: str, launch: bool=False): """Freeze the authorized run, then detach one CPU gate; no duplicate submission.""" import json from final_training import freeze,digest frozen=freeze() if not launch: print(json.dumps(frozen,indent=2));return assert Path(run_id).name==run_id and run_id not in ('','.','..') assert modal.Workspace.from_context().hydrate().name==ACTIVE_WORKSPACE,'Use --profile rl-next' path=ROOT/'calibration'/('launch-'+run_id+'.json') frozen_path=ROOT/'calibration'/(run_id+'-frozen.json') assert not path.exists() and not frozen_path.exists(),'Never duplicate-launch; inspect existing receipts' frozen_path.write_text(json.dumps(frozen,indent=2)+'\n') receipt={'run_id':run_id,'app_id':app.app_id,'status':'controller_submission_started', 'profile':ACTIVE_PROFILE,'workspace':ACTIVE_WORKSPACE,'frozen_sha256':digest(frozen), 'trainer_gpus':1,'inference_gpus':2,'updates':10,'batch_size':64,'group_size':8, 'concurrency_per_inference_gpu':64,'global_episode_concurrency':128, 'checkpoint_steps':[5,10],'post_training_eval_attempts':368, 'output':'workspace-agent-training:/prime/'+run_id, 'preflight_output':'workspace-agent-training:/prime/'+run_id+'-preflight', 'heldout_output':'workspace-agent-training:/prime/'+run_id+'-heldout'} path.write_text(json.dumps(receipt,indent=2)+'\n') call=final_training_controller.spawn(run_id,frozen) receipt.update(status='cpu_preflight_submitted',controller_call_id=call.object_id) path.write_text(json.dumps(receipt,indent=2)+'\n');print(json.dumps(receipt,indent=2),flush=True) @app.function(image=evaluation_image,cpu=2,memory=8192,timeout=900,retries=0, volumes={'/outputs':outputs}) async def final_checkpoint_continuation(run_id: str, frozen: dict): """Revalidate saved native state on CPU, then submit the authorized eval once.""" import asyncio,hashlib,json,sys,time sys.path.insert(0,'/workspace-smoke') from final_training import validate,verify_runtime,digest validate(frozen) assert run_id=='final-b64-g8-u10-20261030-01' assert digest(frozen)=='93653ca95cd33b08f054cd0ddb2e9f1d860878f09b42a4af43b3d660ede1b99b' root=Path('/outputs/prime')/run_id directory=root.with_name(run_id+'-heldout') directory.mkdir(exist_ok=False) receipt={'run_id':run_id,'app_id':app.app_id,'call_id':modal.current_function_call_id(), 'status':'cpu_checkpoint_verification','frozen_sha256':digest(frozen), 'evaluation_calls':[],'planned_attempts':368,'training_updates':0} async def save(): (directory/'receipt.json').write_text(json.dumps(receipt,indent=2)+'\n') await asyncio.wait_for(outputs.commit.aio(),90) try: await save() prior=json.loads((root/'receipt.json').read_text()) assert prior['exit_code']==0 and prior['launcher_stopped'] and prior['max_steps']==10 assert prior['status']=='failed' and prior['error']=="AssertionError('Native checkpoint 5 validation failed')" assert prior['frozen_sha256']==digest(frozen) assert json.loads((root/'frozen.json').read_text())==frozen assert not any((root.with_name(f'{run_id}-heldout-{s}-{arm}')).exists() for s in (0,1) for arm in ('base','final')) receipt['runtime']=verify_runtime(frozen) script=r''' import sys,json,hashlib,inspect,random from pathlib import Path import torch sys.path.insert(0,'/workspace-smoke') from training_lifecycle import verify_checkpoint import prime_rl.orchestrator.orchestrator as orch from safetensors import safe_open root=Path(sys.argv[1]) checks=[verify_checkpoint(root/'training/checkpoints'/f'step_{step}',step,nextstep) for step,nextstep in ((5,6),(10,10))] source=Path(orch.__file__).read_text() assert hashlib.sha256(source.encode()).hexdigest()=='ae72a9c7f01888f01d1aff786e70aed6d7587e0a8eb12b64b64ebd1425c7f77d' assert 'self.progress.step += 1' in source and 'self.progress.step -= 1' in source assert 'self.progress.step = self.resume_step + 1' in source for step in (5,10): saved=torch.load(root/'training/checkpoints'/f'step_{step}'/'orchestrator/progress.pt',weights_only=False,map_location='cpu') assert set(saved['train_source'])=={'rng','envs'} assert set(saved['train_source']['envs'])=={'final-train-1','final-train-2'} random.Random().setstate(saved['train_source']['rng']) a=root/'training/broadcasts/step_10' assert (a/'.finished').is_file() cfg=json.loads((a/'adapter_config.json').read_text()) assert cfg['r']==16 and cfg['lora_alpha']==32 and cfg['peft_type']=='LORA' assert cfg['base_model_name_or_path'].endswith('/c202236235762e1c871ad0ccb60c8ee5ba337b9a') with safe_open(a/'adapter_model.safetensors',framework='pt',device='cpu') as tensors: keys=list(tensors.keys());assert keys assert len(keys)==256 assert all(torch.isfinite(tensors.get_tensor(k)).all().item() for k in keys) assert hashlib.sha256((a/'adapter_model.safetensors').read_bytes()).hexdigest()=='a737d31c098ccdcc945a3d7b437ec72418e1d2aa6eca8986c69dc56f3eeb63d0' print(json.dumps({'checkpoints':checks,'adapter_sha256':hashlib.sha256((a/'adapter_model.safetensors').read_bytes()).hexdigest(),'adapter_config':cfg,'adapter_tensor_count':len(keys),'adapter_finite':True,'source_sha256':hashlib.sha256(source.encode()).hexdigest(),'full_resume_tested':False})) ''' process=await asyncio.create_subprocess_exec('/app/.venv/bin/python','-c',script,str(root), stdout=asyncio.subprocess.PIPE,stderr=asyncio.subprocess.PIPE) stdout,stderr=await asyncio.wait_for(process.communicate(),600) (directory/'checkpoint-verification.log').write_bytes(stderr+stdout) assert process.returncode==0,'CPU checkpoint verification failed; no evaluation submitted' verified=json.loads(stdout.decode().splitlines()[-1]) verified.update(status='checkpoint_verified',frozen_sha256=digest(frozen), original_receipt_sha256=hashlib.sha256((root/'receipt.json').read_bytes()).hexdigest()) (directory/'verification.json').write_text(json.dumps(verified,indent=2)+'\n') receipt['status']='checkpoint_verified';await save() for shard in (0,1): receipt.update(status='evaluation_submission_started',submitting_shard=shard);await save() call=await final_heldout_worker.spawn.aio(run_id,frozen,shard) receipt['evaluation_calls'].append({'shard':shard,'call_id':call.object_id});await save() receipt.update(status='heldout_submitted',ended_unix=time.time()) except BaseException as error: receipt.update(status='failed',error=repr(error));raise finally: await save() return receipt @app.local_entrypoint() def continue_final_checkpoint(run_id: str): import json assert run_id=='final-b64-g8-u10-20261030-01' assert modal.Workspace.from_context().hydrate().name==ACTIVE_WORKSPACE path=ROOT/'calibration'/('continue-'+run_id+'.json') assert not path.exists(),'Never repeat an ambiguous continuation submission' frozen=json.loads((ROOT/'calibration'/(run_id+'-frozen.json')).read_text()) receipt={'run_id':run_id,'app_id':app.app_id,'status':'continuation_submission_started', 'output':'workspace-agent-training:/prime/'+run_id+'-heldout'} path.write_text(json.dumps(receipt,indent=2)+'\n') call=final_checkpoint_continuation.spawn(run_id,frozen) receipt.update(status='cpu_verification_submitted',call_id=call.object_id) path.write_text(json.dumps(receipt,indent=2)+'\n') print(json.dumps(receipt),flush=True) def _final_only_base_fingerprint(run_id): """Provenance guard; read bytes only, including native logs and traces.""" import hashlib result={} for shard in (0,1): base=Path('/outputs/prime')/f'{run_id}-heldout-{shard}-base'/'replica-0' assert base.is_dir() for path in sorted(base.rglob('*')): if path.is_file(): h=hashlib.sha256() with path.open('rb') as f: for block in iter(lambda:f.read(1<<20),b''):h.update(block) result[str(path)]=h.hexdigest() return result @app.function(image=evaluation_image,cpu=2,memory=8192,timeout=1800,retries=0, volumes={'/outputs':outputs}) async def final_only_preflight(run_id: str, frozen: dict): import asyncio,json,sys,hashlib from copy import deepcopy sys.path.insert(0,'/workspace-smoke') from final_training import validate,verify_runtime,digest,audit_evaluation validate(frozen) assert run_id=='final-b64-g8-u10-20261030-01' assert digest(frozen)=='93653ca95cd33b08f054cd0ddb2e9f1d860878f09b42a4af43b3d660ede1b99b' root=Path('/outputs/prime') directory=root/(run_id+'-final-only-preflight') directory.mkdir(exist_ok=False) receipt={'run_id':run_id,'status':'cpu_preflight','app_id':app.app_id, 'call_id':modal.current_function_call_id(),'frozen_sha256':digest(frozen), 'planned_final_attempts':184,'base_attempts_to_run':0,'training_updates':0,'gpu_submissions':0,'base_audits':[],'dry_runs':[]} async def save(): (directory/'receipt.json').write_text(json.dumps(receipt,indent=2)+'\n') await asyncio.wait_for(outputs.commit.aio(),90) try: await save() receipt['runtime']=verify_runtime(frozen) before=await asyncio.to_thread(_final_only_base_fingerprint,run_id) for shard in (0,1): assert not (root/f'{run_id}-heldout-{shard}-final').exists(),'Final output already exists; do not duplicate' base=root/f'{run_id}-heldout-{shard}-base'/'replica-0' prior=json.loads((base/'receipt.json').read_text()) assert prior['eval_exit_code']==0 and prior['processes_stopped'] assert prior['authentication_verified'] and prior['generation_verified'] and not prior['adapter_loaded'] assert json.loads((base/'frozen-config.json').read_text())==frozen['evaluation_shards'][shard] audit=await asyncio.to_thread(audit_evaluation,base,frozen['evaluation_shards'][shard]['task_manifest']) assert audit['attempts']==(88,96)[shard] and audit['passed']==(37,54)[shard] receipt['base_audits'].append(audit);await save() config=deepcopy(frozen['evaluation_shards'][shard]['evaluation']) config['model']='workspace-final-step10';config['output_dir']=str(directory/f'dry-run-{shard}') path=directory/f'final-{shard}.json';path.write_text(json.dumps(config,indent=2)+'\n') with (directory/f'final-{shard}-dry-run.log').open('w') as log: process=await asyncio.create_subprocess_exec('/usr/bin/timeout','--signal=TERM','--kill-after=10s','180s', '/app/.venv/bin/eval','@',str(path),'--dry-run',cwd='/app',stdout=log,stderr=log,start_new_session=True) await asyncio.wait_for(process.wait(),195) assert process.returncode==0,'Native final eval dry-run failed' receipt['dry_runs'].append(shard);await save() adapter=root/run_id/'training/broadcasts/step_10' verify=json.loads((root/(run_id+'-heldout')/'verification.json').read_text()) assert verify['status']=='checkpoint_verified' and verify['frozen_sha256']==digest(frozen) assert (adapter/'.finished').is_file() receipt['adapter_sha256']=hashlib.sha256((adapter/'adapter_model.safetensors').read_bytes()).hexdigest() assert receipt['adapter_sha256']==verify['adapter_sha256']=='a737d31c098ccdcc945a3d7b437ec72418e1d2aa6eca8986c69dc56f3eeb63d0' receipt['base_files_sha256']=before assert before==await asyncio.to_thread(_final_only_base_fingerprint,run_id),'Base files changed' receipt.update(status='cpu_preflight_passed',base_attempts_preserved=184,base_files_unchanged=True) except BaseException as error: receipt.update(status='failed',error=repr(error));raise finally:await save() return receipt @app.function(image=evaluation_image,gpu='H100',cpu=8,memory=65536,timeout=14400,retries=0, max_containers=2,scaledown_window=2, secrets=[modal.Secret.from_name('workspace-official-harbor-controller'),modal.Secret.from_name('workspace-task-registry-readonly')], volumes={'/outputs':outputs,'/root/.cache/huggingface':cache,'/root/.cache/harbor':task_cache}) async def final_only_worker(run_id: str, frozen: dict, shard: int): import asyncio,json,sys,time sys.path.insert(0,'/workspace-smoke') from final_training import validate,audit_evaluation,digest validate(frozen);assert shard in (0,1) directory=Path('/outputs/prime')/(run_id+'-final-only')/f'shard-{shard}' directory.mkdir(exist_ok=False) receipt={'run_id':run_id,'shard':shard,'status':'running_final','call_id':modal.current_function_call_id(), 'frozen_sha256':digest(frozen),'planned_attempts':(88,96)[shard],'base_attempts_to_run':0,'training_updates':0} async def save(): (directory/'receipt.json').write_text(json.dumps(receipt,indent=2)+'\n') await asyncio.wait_for(outputs.commit.aio(),90) try: await save() selected=frozen['evaluation_shards'][shard] result=await evaluate.local(f'{run_id}-heldout-{shard}-final',adapter_run=run_id, calibration=True,replica=0,validation=selected,adapter_step=10) receipt['result']=result;await save() assert result['eval_exit_code']==0 and result['processes_stopped'] assert result['authentication_verified'] and result['generation_verified'] and result['adapter_loaded'] receipt['audit']=await asyncio.to_thread(audit_evaluation, Path('/outputs/prime')/f'{run_id}-heldout-{shard}-final'/'replica-0',selected['task_manifest']) receipt['status']='completed_and_graded' except BaseException as error: receipt.update(status='failed',error=repr(error));raise finally: receipt['ended_unix']=time.time();await save() return receipt @app.function(image=evaluation_image,cpu=1,memory=2048,timeout=900,retries=0,volumes={'/outputs':outputs}) async def final_only_submit(run_id: str, frozen: dict): import asyncio,json,sys sys.path.insert(0,'/workspace-smoke') from final_training import validate,digest validate(frozen) root=Path('/outputs/prime') gate=json.loads((root/(run_id+'-final-only-preflight')/'receipt.json').read_text()) assert gate['status']=='cpu_preflight_passed' and gate['frozen_sha256']==digest(frozen) assert gate['planned_final_attempts']==184 and gate['base_attempts_preserved']==184 assert gate['base_files_sha256']==await asyncio.to_thread(_final_only_base_fingerprint,run_id) assert all(not (root/f'{run_id}-heldout-{shard}-final').exists() for shard in (0,1)) directory=root/(run_id+'-final-only');directory.mkdir(exist_ok=False) receipt={'run_id':run_id,'status':'submission_started','app_id':app.app_id, 'call_id':modal.current_function_call_id(),'planned_attempts':184,'base_attempts_to_run':0, 'training_updates':0,'frozen_sha256':digest(frozen),'evaluation_calls':[]} async def save(): (directory/'receipt.json').write_text(json.dumps(receipt,indent=2)+'\n') await asyncio.wait_for(outputs.commit.aio(),90) try: await save() for shard in (0,1): receipt.update(status='evaluation_submission_started',submitting_shard=shard);await save() call=await final_only_worker.spawn.aio(run_id,frozen,shard) receipt['evaluation_calls'].append({'shard':shard,'call_id':call.object_id});await save() receipt['status']='final_only_submitted' except BaseException as error: receipt.update(status='failed',error=repr(error));raise finally:await save() return receipt @app.local_entrypoint() def final_only(run_id: str, submit: bool=False): import json assert run_id=='final-b64-g8-u10-20261030-01' assert modal.Workspace.from_context().hydrate().name==ACTIVE_WORKSPACE stage='submit' if submit else 'preflight' path=ROOT/'calibration'/f'{run_id}-final-only-{stage}.json' assert not path.exists(),'Do not repeat ambiguous submission' frozen=json.loads((ROOT/'calibration'/(run_id+'-frozen.json')).read_text()) receipt={'run_id':run_id,'app_id':app.app_id,'stage':stage,'status':'submission_started'} path.write_text(json.dumps(receipt,indent=2)+'\n') call=(final_only_submit if submit else final_only_preflight).spawn(run_id,frozen) receipt.update(status='submitted',call_id=call.object_id) path.write_text(json.dumps(receipt,indent=2)+'\n');print(json.dumps(receipt),flush=True)