envloop-cli-experiment 1.23.0__py3-none-any.whl

envloop_cli_experiment-1.23.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.5
+Name: envloop-cli-experiment
+Version: 1.23.0
+Summary: EnvLoop experiment client functionality installed with the base client
+Requires-Python: >=3.12
+Requires-Dist: envloop-cli==1.23.0
+Description-Content-Type: text/markdown
+
+# envloop-cli-experiment
+
+Experiment implementation installed by default with envloop-cli 1.23.0. This project is a source candidate, not a claim that this version has been published. Install with its matching base wheel. Only the base owns the el/envloop scripts.

envloop_cli_experiment-1.23.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+envloop_experiment/__init__.py,sha256=nKDGmzFNAQv2mq16YijiI3Q-gDL_smNyZD-AQaqoz7Y,68
+envloop_experiment/cli.py,sha256=salxVeXhoVhaK4m2nk-5f4g9KxV12q-A3eaLkCvpctU,28393
+envloop_experiment/cli_output.py,sha256=QAKQqH9ZTRNLwNbG6K0KLOpnQ_jbsUZWZcYlAdx_KYY,2689
+envloop_experiment/client.py,sha256=cYtL1uM3Cc6yTOi9Rwfi79mv1ontrbyyay-o_4w98KU,25094
+envloop_experiment/decision.py,sha256=apsds-9tXmn-xN8IU3IU-Ye9E2P32jpN49DcVgc_JnM,917
+envloop_experiment/http.py,sha256=Mjhp6KojeFEUGBSMIDw8SFKE4v_h6_gEseBZs4S61iM,5600
+envloop_experiment/inference.py,sha256=74MZDs0lqqqNwgdvj58rs-D3emDj4iHv1W-copc5PYA,2134
+envloop_experiment/job_cost.py,sha256=-h4tYQo3wm6W4ZRRa-_HeGsaBzRoDqRi5mo6_iNrfD4,1910
+envloop_experiment/job_logs.py,sha256=RLipbj89e5hQdBeXtszsxSYYw7By1hscwSTGFQzQ3Qw,1340
+envloop_experiment/job_spec_cli.py,sha256=brVAFud0D0TQ_e80t1kSswztG-AE02eZI3iO-Uxi5sA,7909
+envloop_experiment/navigation_resources.py,sha256=xoI4VFmd0dzviKvzndwKAoWdfbaL_f50cnXRxPkfoo4,1832
+envloop_experiment/resource_cli.py,sha256=YLa5-mOxxx0uonDN-dY5oE_fvrhN7g9ea4NAg6LY8kg,1604
+envloop_experiment/resources.py,sha256=Ss_dW2J4lDRB-3aVnOnUwQgUAYOK49_GvF5NO2_Zlhs,7167
+envloop_experiment/runtime_params.py,sha256=ITF6hDuhfdChnWo3e8NW27WxEoNoCuOTww-Hz60zqQU,3608
+envloop_experiment/sandbox.py,sha256=sTpAWbcs2jAPfb7gILK4MTJSmcpSeZG3anFkLA5TgdQ,1274
+envloop_experiment/train.py,sha256=yNrSguzd7phjhRQsrHo0fQ1gruzmjKqAKrs2HHai_Ig,4940
+envloop_experiment/train_log_cli.py,sha256=fsmt9I6Hyntnj_rdqEe4YBnJsAPYsfFAsW-xRCSC6nM,5838
+envloop_experiment/train_progress.py,sha256=Cln8NPWfmSH9Mnlml-78dOXqwZTqWVeJ8ArDWFAQv-A,2536
+envloop_experiment/train_runner_cli.py,sha256=v8a1ibI5ymf994_F6kHCiidNaxibRAZMF9tqDY4HBWA,3135
+envloop_experiment/training/__init__.py,sha256=IEQWbCHe-zZ2e7JQxOrFOdYlSQxMfOceCZUf_KeszBk,221
+envloop_cli_experiment-1.23.0.dist-info/METADATA,sha256=eCslEmA5tmCFqrQtliCWoqLqXiwi8lnuwQeLLwJcyYE,512
+envloop_cli_experiment-1.23.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+envloop_cli_experiment-1.23.0.dist-info/RECORD,,

envloop_cli_experiment-1.23.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

envloop_experiment/__init__.py

@@ -0,0 +1 @@
+"""Optional EnvLoop client functionality; loaded only on demand."""

envloop_experiment/cli.py

@@ -0,0 +1,467 @@
+import argparse
+import json
+import math
+import sys
+from pathlib import Path
+from typing import Any
+
+
+def dataset_reference(value: str):
+    name, separator, version = value.rpartition("@")
+    if (not value.strip() or (separator and (not name.strip() or not version.strip()))):
+        raise argparse.ArgumentTypeError(
+            "expected name or name@version with a non-empty name and version "
+            "(e.g. org/dataset@1.0)"
+        )
+    return value
+
+
+def profile_reference(value: str):
+    name, separator, version = value.partition("@")
+    if (not name.strip() or name != name.strip() or "/" not in name
+            or (separator and (not version.strip() or version != version.strip()))):
+        raise argparse.ArgumentTypeError("expected a Profile name org/name or org/name@version")
+    return value
+
+
+def nonnegative_seconds(value: str):
+    try:
+        seconds = int(value)
+    except ValueError:
+        raise argparse.ArgumentTypeError("expected a non-negative integer in seconds") from None
+    if seconds < 0:
+        raise argparse.ArgumentTypeError("expected a non-negative integer in seconds")
+    return seconds
+
+
+def max_cost_usd(value: str):
+    from envloop_experiment.client import job_budget
+    try:
+        return job_budget(float(value))['max_cost_usd']
+    except ValueError:
+        raise argparse.ArgumentTypeError("expected a USD amount from 0.000001 to 100000") from None
+
+
+def wait_seconds(value: str):
+    try:
+        seconds = float(value)
+    except ValueError:
+        raise argparse.ArgumentTypeError("seconds must be finite and non-negative") from None
+    if not math.isfinite(seconds) or seconds < 0:
+        raise argparse.ArgumentTypeError("seconds must be finite and non-negative")
+    return seconds
+
+
+def log_page_size(value: str):
+    try:
+        count = int(value)
+    except ValueError:
+        raise argparse.ArgumentTypeError("expected an integer from 1 to 1000") from None
+    if not 1 <= count <= 1000:
+        raise argparse.ArgumentTypeError("expected an integer from 1 to 1000")
+    return count
+
+
+def runner_arguments(submit: argparse.ArgumentParser):
+    submit.add_argument("--runner", metavar="NAME[@REVISION]",
+                        help="Agent/Train/Inference: namespace/name@REVISION; Sandbox: registered Runner name (for example base)")
+    submit.add_argument("--job-id", help="Agent/Sandbox: caller-selected Job ID")
+    submit.add_argument("--tag", help="Agent/Sandbox: run label")
+    submit.add_argument("--priority", type=int, help="Agent/Sandbox/Train recipe: waiting priority; explicit value overrides spec (server default: 0)")
+    submit.add_argument("--command", help="Agent/Sandbox: shell override; Train: declared run_command parameter passed to the published Runner entrypoint; preserves multiline text")
+
+
+def submission_options(args: argparse.Namespace):
+    options = {}
+    for key in ("runner", "job_id", "tag", "command", "image"):
+        value = getattr(args, key, None)
+        if value is not None:
+            options[key] = value
+    options["priority"] = args.priority if args.priority is not None else 0
+    if args.params is not None:
+        options["params"] = args.params
+    if args.max_cost_usd is not None:
+        options["max_cost_usd"] = args.max_cost_usd
+    if args.profile:
+        if args.runner is not None:
+            options["profile_id"] = args.profile
+        else:
+            name, separator, version = args.profile.partition("@")
+            options["profile_name"] = name
+            if separator:
+                options["profile_version"] = version
+    if args.seed is not None:
+        if args.runner is not None:
+            options["profile"] = {"seed": args.seed}
+        else:
+            options["seed"] = args.seed
+    execution = {key: value for key, value in {"timeout_sec": args.timeout_sec,
+                                             "delete_delay_sec": args.delete_delay}.items() if value is not None}
+    if execution:
+        options["execution"] = execution
+    return options
+
+
+def add_commands(groups: "argparse._SubParsersAction[argparse.ArgumentParser]"):
+    jobs = groups.add_parser("job", help="Submit and manage Agent, Sandbox, Train and Inference Jobs").add_subparsers(dest="action", required=True)
+    job_submit = jobs.add_parser("submit", help="Submit an Agent, Sandbox, Train or Inference Job", allow_abbrev=False)
+    job_submit.add_argument("--type", choices=("agent", "sandbox", "train", "inference"), default=None, help="Job type (default: spec type, otherwise agent)")
+    job_submit.add_argument("--image", metavar="IMAGE", help="Sandbox image override (server default: python:3.11); Train Runner: public spelling of --docker")
+    from envloop_experiment.train_runner_cli import memory_mebibytes, positive_integer
+
+    job_submit.add_argument("--docker", metavar="IMAGE", help="Train Runner Docker image override; omitted uses the Runner declaration")
+    job_submit.add_argument("--trails", type=positive_integer, metavar="COUNT", help="Train Runner: 1–16 independent Trials (default: 1)")
+    job_submit.add_argument("--gput-type", metavar="MODEL", help="Train Runner: GPU model for each Trial (for example H100)")
+    job_submit.add_argument("--gpu", type=positive_integer, metavar="COUNT", help="Train Runner: positive GPU count per Trial")
+    job_submit.add_argument("--cpu", type=positive_integer, metavar="COUNT", help="Train Runner: positive CPU count per Trial")
+    for option in ('memory', 'disk', 'shm-size'):
+        job_submit.add_argument('--' + option, type=memory_mebibytes, metavar="SIZE",
+                                help="Train Runner: per-Trial size in Mi/Gi/Ti (for example 64Gi)")
+    job_submit.add_argument("--spec", type=Path, metavar="REQUEST.json", help="Job specification JSON; explicit submission options override file values (except --trails)")
+    job_submit.add_argument("--source", type=Path, help="two-file directory for a single-task Job")
+    job_submit.add_argument("--task-id", help="select one task within the dataset")
+    job_submit.add_argument(
+        "dataset", nargs="?", type=dataset_reference, metavar="NAME[@VERSION]",
+        help="dataset name; optional author version (legacy positional form)",
+    )
+    job_submit.add_argument("--dataset", dest="dataset_option", type=dataset_reference, metavar="NAME[@VERSION]",
+                            help="dataset name; default selection uses the platform's pinned snapshot")
+    job_submit.add_argument("--config", help="Agent: dataset subset; Train recipe: named preset; omitted preserves spec or server default")
+    job_submit.add_argument("--split", help="one complete split name; omitted selects all splits")
+    job_submit.add_argument("--revision", help="Git branch/tag/commit; must match the platform's pinned snapshot")
+    runner_arguments(job_submit)
+    job_submit.add_argument("--attempts", type=int)
+    job_submit.add_argument("--request-id", help="idempotency key; overrides request_id in --spec")
+    job_submit.add_argument("--profile", type=profile_reference, metavar="NAME[@VERSION]",
+                            help="named runtime Profile; omitted version prefers default, then newest unarchived creation")
+    from envloop_experiment.runtime_params import ParamsAction, parse_params
+    job_submit.add_argument("--params", type=parse_params, action=ParamsAction, metavar="JSON|KEY=VALUE",
+                            help="Repeatable highest-priority Agent/Sandbox runtime parameter patch; JSON preserves types, KV values are strings; later keys win")
+    job_submit.add_argument("--seed", type=int)
+    job_submit.add_argument("--timeout-sec", type=wait_seconds,
+                            help="Agent/Sandbox or Train Runner execution timeout (whole seconds); Train recipe --wait timeout (default: 600)")
+    job_submit.add_argument("--max-cost-usd", type=max_cost_usd, metavar="USD",
+                            help="Agent/Sandbox: Job spend cap in USD (model calls plus sandbox time); the Job stops "
+                                 "with error BUDGET_EXCEEDED once it is reached")
+    job_submit.add_argument("--delete-delay", type=nonnegative_seconds, metavar="SECONDS",
+                            help="keep each sandbox (E2B or Fly) after completion for SECONDS (default: 0); cancellation/timeout delete immediately")
+    job_submit.add_argument("--wait", action="store_true")
+    job_submit.add_argument("--json", action="store_true", help="Output the complete response as JSON (the default for submit; accepted for consistency with list commands)")
+    for action in ("get", "stop", "result", "pause", "resume", "wake", "event"):
+        command = jobs.add_parser(action)
+        command.add_argument("job_id")
+        if action == 'event':
+            command.add_argument('--json', action='store_true')
+            command.set_defaults(_list_view=True)
+    regrade = jobs.add_parser("regrade", help="Re-run only the verifier of sealed compose Trials, optionally with a reward set",
+                              allow_abbrev=False)
+    regrade_source = regrade.add_mutually_exclusive_group(required=True)
+    regrade_source.add_argument("--job", metavar="JOB_ID", help="regrade every sealed Trial of this Agent Job")
+    regrade_source.add_argument("--trial", action="append", metavar="TRIAL_ID",
+                                help="regrade this Trial (repeatable; every one must be eligible)")
+    regrade.add_argument("--reward-set", metavar="URI", help="envloop://reward-sets/NS/NAME@VERSION; omitted uses each Task's own tests")
+    regrade.add_argument("--reward-set-sha256", metavar="HEX", help="manifest SHA-256 pinned with --reward-set (required with it)")
+    regrade_runner = regrade.add_mutually_exclusive_group()
+    regrade_runner.add_argument("--runner", metavar="NAME@REVISION",
+                                help="Runner Revision with regrade support (revision, branch or tag); needed for Trials "
+                                     "sealed by a Revision without it")
+    regrade_runner.add_argument("--runner-ref", type=Path, metavar="RUNNER_REF.json",
+                                help="the same as --runner, as a five-field Revision pin file")
+    regrade.add_argument("--max-cost-usd", type=float, metavar="USD", help="Job spend cap in USD (needs platform Job budgets)")
+    regrade.add_argument("--request-id", help="idempotency key (default: derived from the request, so a retry returns the "
+                                              "same Job; give a new one to run the same regrade again)")
+    regrade.add_argument("--wait", action="store_true", help="poll until the regrade Job ends")
+    regrade.add_argument("--timeout-sec", type=wait_seconds, help="--wait timeout in whole seconds (default: 600)")
+    regrade.add_argument("--json", action="store_true", help="Output the complete response as JSON (the default)")
+    decision = jobs.add_parser("decision", help="Invoke the frozen decision plugin of an Inference Job")
+    decision.add_argument("job_id")
+    decision.add_argument("--model", required=True)
+    decision.add_argument("--spec", type=Path, required=True, metavar="PAYLOAD.json")
+    from envloop_experiment.resource_cli import add_job_resources
+    add_job_resources(jobs)
+    listing = jobs.add_parser("list")
+    listing.add_argument('--type', choices=['agent', 'sandbox', 'regrade', 'train', 'inference'],
+                         help='Select Agent, Sandbox, Regrade, Train or Inference Jobs')
+    listing.add_argument('--status', help='Filter by Job status')
+    listing.add_argument("--cursor")
+    listing.add_argument("--json", action="store_true", help="Output the complete response as JSON (default: table)")
+    listing.add_argument("--limit", type=int, default=25)
+    train_log = jobs.add_parser("log", help="Read or follow Agent, Sandbox or Train Job logs")
+    train_log.add_argument("job_id")
+    train_log.add_argument("--source", choices=("all", "system", "runtime"), default="all")
+    train_log.add_argument("--process", metavar="NAME",
+                           help="Only one recorded process, e.g. trainer (a Train Job's step metrics)")
+    position = train_log.add_mutually_exclusive_group()
+    position.add_argument("--tail", type=log_page_size, help="Start with the last N records (default: 200)")
+    position.add_argument("--cursor", help="Resume from a previously returned log cursor")
+    train_log.add_argument("--limit", type=log_page_size, default=200, help="Maximum records per page (default: 200)")
+    train_log.add_argument("--follow", action="store_true", help="Drain pages and poll until collection ends; Ctrl-C exits without stopping the Job")
+    train_log.add_argument("--json", action="store_true", help="Output the complete page as JSON; --follow emits one page per line (NDJSON)")
+    from envloop._optional import available
+    if available('rsi-loop'):
+        from envloop_rsi_loop.cli import add_commands as add_runs
+        add_runs(jobs)
+    tasks = groups.add_parser("trail", help="Inspect and control existing trials").add_subparsers(dest="action", required=True)
+    listing = tasks.add_parser("list", help="List Agent, Sandbox, Train and Inference worker Trials")
+    listing.add_argument("--type", choices=("agent", "sandbox", "train", "inference"), help="Filter by Trial type")
+    listing.add_argument("--job-id", help="Filter by parent Job ID")
+    listing.add_argument("--cursor")
+    listing.add_argument("--limit", type=int, default=25)
+    snapshot = tasks.add_parser("snapshot")
+    snapshot.add_argument("trial_id")
+    for action in ("get", "stop", "result"):
+        tasks.add_parser(action).add_argument("trial_id")
+    listing.add_argument("--json", action="store_true", help="Output the complete response as JSON")
+    artifacts = tasks.add_parser("artifact", help="List or download a trial's artifacts").add_subparsers(dest="artifact_action", required=True)
+    artifact_list = artifacts.add_parser("list", help="List one page of artifacts")
+    artifact_list.set_defaults(_list_view=True)
+    artifact_list.add_argument("trial_id")
+    artifact_list.add_argument("--cursor")
+    artifact_list.add_argument("--limit", type=int, default=25)
+    artifact_list.add_argument("--json", action="store_true")
+    download = artifacts.add_parser("download", help="Download all uploaded artifacts and verify their sizes and hashes")
+    download.add_argument("trial_id")
+    download.add_argument("directory", type=Path)
+
+def validate(args: argparse.Namespace, cli: argparse.ArgumentParser):
+    if args.group == "job" and args.action == "decision":
+        from envloop_experiment.decision import DecisionClient
+        try:
+            if args.spec.stat().st_size > 1024 * 1024:
+                raise ValueError("Decision payload exceeds 1 MiB")
+            args.payload = json.loads(args.spec.read_text(encoding="utf-8"))
+            DecisionClient.validate(args.job_id, args.model, args.payload)
+        except (OSError, ValueError):
+            cli.error("decision requires a readable JSON object of at most 1 MiB, without model")
+    if args.group == "job" and args.action == "regrade":
+        if (args.reward_set is None) != (args.reward_set_sha256 is None):
+            cli.error('--reward-set and --reward-set-sha256 must be given together')
+        args.reward_set_pin = ({'uri': args.reward_set, 'manifest_sha256': args.reward_set_sha256}
+                               if args.reward_set is not None else None)
+        import math
+        if args.max_cost_usd is not None and (not math.isfinite(args.max_cost_usd) or not 0.000001 <= args.max_cost_usd <= 100000):
+            cli.error('--max-cost-usd must be between 0.000001 and 100000')
+        if args.runner is not None and '@' not in args.runner:
+            cli.error('--runner must be NAME@REVISION, branch or tag')
+        args.runner_pin = None
+        if args.runner_ref is not None:
+            try:
+                args.runner_pin = json.loads(args.runner_ref.read_text(encoding='utf-8'))
+            except (OSError, UnicodeError, ValueError):
+                cli.error('--runner-ref must be a readable JSON Runner Revision pin')
+    if args.group == "job" and args.action == "submit":
+        from envloop_experiment.train_runner_cli import SHORTCUT_FIELDS, runner_request
+
+        if args.spec is not None:
+            from envloop_experiment.job_spec_cli import SpecFileError, spec_request
+
+            try:
+                args.job_request = spec_request(args)
+            except (OSError, UnicodeError, json.JSONDecodeError, SpecFileError) as exc:
+                from envloop.cli_errors import format_error
+
+                print(format_error(exc), file=sys.stderr)
+                return 1
+            except (ValueError, TypeError) as exc:
+                cli.error(str(exc) if isinstance(exc, ValueError) else 'Unable to merge Job spec')
+        else:
+            args.type = args.type or 'agent'
+        if args.params is not None and args.type not in {'agent', 'sandbox'}:
+            cli.error('--params applies to Agent/Sandbox declared Runner runtime parameters')
+        runner_mode = args.type == 'train' and args.spec is None
+        if args.spec is None and not runner_mode and any(getattr(args, key) is not None for key in SHORTCUT_FIELDS):
+            cli.error('Train Runner shortcuts require --type train --runner and cannot be combined with --spec')
+        if args.spec is not None:
+            pass  # The merged request was validated above; the platform owns final admission.
+        elif args.type in {"train", "inference"}:
+            if args.spec is None and not runner_mode:
+                cli.error(f"--type {args.type} requires --spec REQUEST.json")
+            if args.type == 'inference' and (args.wait or args.timeout_sec is not None):
+                cli.error('Inference is a continuous service; --wait and --timeout-sec do not apply')
+            agent_fields = ("dataset", "dataset_option", "source", "task_id", "config", "split", "revision",
+                            "job_id", "tag", "priority", "attempts", "profile", "seed", "delete_delay", "max_cost_usd")
+            if not runner_mode:
+                agent_fields += ('runner', 'command', 'request_id', 'image')
+            if any(getattr(args, key) is not None for key in agent_fields):
+                cli.error(f"--type {args.type} cannot be combined with Agent submission options or mixed --spec/Runner input")
+            if runner_mode:
+                try:
+                    args.train_request = runner_request(args)
+                except ValueError as exc:
+                    cli.error(str(exc))
+        elif args.type == 'sandbox':
+            from envloop_experiment.sandbox import (
+                sandbox_runner_selector,
+                validate_image,
+            )
+
+            if any(getattr(args, key) is not None for key in (
+                    'spec', 'dataset', 'dataset_option', 'source', 'task_id', 'config', 'split', 'revision', 'seed')):
+                cli.error('--type sandbox accepts --runner without Dataset, Task, Job spec or seed options')
+            try:
+                args.runner = sandbox_runner_selector(args.runner)
+                if args.image is not None:
+                    args.image = validate_image(args.image)
+            except ValueError as exc:
+                cli.error(str(exc))
+            if args.timeout_sec is not None:
+                if not args.timeout_sec.is_integer():
+                    cli.error('Sandbox --timeout-sec must be whole seconds')
+                args.timeout_sec = int(args.timeout_sec)
+        else:
+            if args.spec is not None:
+                cli.error("--spec requires --type train or inference")
+            if args.image is not None:
+                cli.error('--image requires --type sandbox')
+            if args.runner is not None:
+                from envloop_experiment.client import runner_selector
+
+                try:
+                    args.runner = runner_selector(args.runner)
+                except ValueError as exc:
+                    cli.error(str(exc))
+            selections = sum(value is not None for value in (args.dataset, args.dataset_option, args.source))
+            if selections != 1 and not (selections == 0 and args.profile):
+                cli.error("provide exactly one positional dataset, --dataset or --source")
+            args.dataset = args.dataset if args.dataset is not None else args.dataset_option
+            if args.source is not None and any(getattr(args, key) is not None for key in ("runner", "task_id", "config", "split", "revision")):
+                cli.error("dataset selection options require a dataset")
+            if args.timeout_sec is not None:
+                if not args.timeout_sec.is_integer():
+                    cli.error("Agent --timeout-sec must be whole seconds")
+                args.timeout_sec = int(args.timeout_sec)
+    return None
+
+def execute_job(args: argparse.Namespace, client: Any, cli: argparse.ArgumentParser):
+    from envloop._optional import CommandExit
+    if args.action == "submit":
+        if args.type == 'inference':
+            result = client.jobs.submit_inference(args.job_request)
+        elif args.type == "train":
+            request = args.train_request if args.spec is None else args.job_request
+            result = client.training_jobs.submit(request)
+        elif args.spec is not None:
+            result = client.jobs.submit_spec(args.job_request)
+        else:
+            result = client.jobs.submit(args.dataset, type=args.type, source=args.source, task_id=args.task_id,
+                                        attempts=args.attempts if args.attempts is not None else 1,
+                                        request_id=args.request_id, config=args.config, split=args.split,
+                                        revision=args.revision, **submission_options(args))
+        if args.wait:
+            wait_options = {"timeout": args.timeout_sec} if args.type == "train" and args.spec is not None and args.timeout_sec is not None else {}
+            result = client.jobs.wait(result["job_id"], **wait_options)
+            from envloop_experiment.job_cost import cost_line
+
+            line = cost_line(result)
+            if line:
+                print(line, file=sys.stderr)
+            if isinstance(result, dict) and result.get('status') == 'cancelled':
+                # A waited Job that did not complete (stopped, or its budget was reached) is not a
+                # success, like a failed one; the JSON on stdout says why (error, cost).
+                print(json.dumps(result, ensure_ascii=False))
+                raise CommandExit(1)
+    elif args.action == "regrade":
+        from envloop.http import RemoteError
+        try:
+            result = client.jobs.regrade(job_id=args.job, trial_ids=args.trial, reward_set=args.reward_set_pin,
+                                         runner_ref=args.runner_pin, runner=args.runner,
+                                         budget={'max_cost_usd': args.max_cost_usd}
+                                         if args.max_cost_usd is not None else None,
+                                         request_id=args.request_id)
+        except RemoteError as error:
+            hint = None
+            if error.code == 'JOB_REQUEST_CONFLICT' and args.request_id is None:
+                # The default request_id is derived from this command's options. A conflict means the
+                # same options resolved to another request, e.g. --runner NAME@BRANCH moved.
+                hint = ('The default request_id is derived from these options and was already used for a '
+                        'different request (for example --runner @branch now names another revision). '
+                        'Pass --request-id NEW to submit it as a new regrade, or pin --runner NAME@REVISION.')
+            elif error.code == 'REGRADE_RUNNER_UNSUPPORTED':
+                hint = ('The source Trials ran on a Runner Revision without regrade support. Pass '
+                        '--runner envhub/harbor-compose@REVISION (a Revision whose runner.toml declares '
+                        'capabilities = ["regrade"]; see el runner list) or --runner-ref FILE.json.')
+            if hint is None:
+                raise
+            raise RemoteError(error.code, error.status_code, retry_after=error.retry_after,
+                              message=error.message, hint=hint, request_id=error.request_id,
+                              details=error.details) from None
+        if args.wait:
+            result = client.jobs.wait(result["job_id"], **({"timeout": args.timeout_sec}
+                                                          if args.timeout_sec is not None else {}))
+            from envloop_experiment.job_cost import cost_line
+
+            line = cost_line(result)
+            if line:
+                print(line, file=sys.stderr)
+            if isinstance(result, dict) and result.get('status') == 'cancelled':
+                # A waited Job that did not complete (stopped, or its budget was reached) is not a
+                # success, like a failed one; the JSON on stdout says why (error, cost).
+                print(json.dumps(result, ensure_ascii=False))
+                raise CommandExit(1)
+    elif args.action == "decision":
+        result = client.decision.evaluate(args.job_id, model=args.model, payload=args.payload)
+    elif args.action == 'event':
+        result = client.jobs.events(args.job_id)
+    elif args.action in {'serving-profile', 'adapter'}:
+        from envloop_experiment.resource_cli import run_job_resource
+        result = run_job_resource(client, args)
+    elif args.action == "log":
+        from envloop_experiment.train_log_cli import read_logs
+
+        raise CommandExit(read_logs(client.jobs, args))
+    elif args.action == "run" and args.run_action in {"start", "live", "steer", "stop"}:
+        from envloop_rsi_loop.rsi_cli import run_rsi
+
+        result = run_rsi(client.agent_runs, args)
+        if result is None:
+            raise CommandExit(0)
+    elif args.action == "run":
+        result = client.agent_runs.list() if args.run_action == "list" else client.agent_runs.get(args.run)
+    elif args.action == "list":
+        options = {'cursor': args.cursor, 'limit': args.limit}
+        for field in ('type', 'status'):
+            if getattr(args, field) is not None:
+                options[field] = getattr(args, field)
+        result = client.jobs.list(**options)
+    else:
+        result = getattr(client.jobs, 'status' if args.action == 'get' else args.action)(args.job_id)
+        if args.action == 'get':
+            from envloop_experiment.train_progress import job_progress, progress_line
+
+            # The JSON on stdout is unchanged; a Train Job's live progress is a readable stderr line.
+            line = progress_line(job_progress(result))
+            if line:
+                print(line, file=sys.stderr)
+        if args.action in {'get', 'result'}:
+            from envloop_experiment.job_cost import cost_line
+
+            # An Agent/Sandbox Job's spend and budget as a readable stderr line; stdout stays JSON.
+            line = cost_line(result)
+            if line:
+                print(line, file=sys.stderr)
+            from envloop.cli_errors import failure_lines
+
+            for line in failure_lines(result):
+                print(line, file=sys.stderr)
+    return result
+
+def execute_trail(args: argparse.Namespace, client: Any, cli: argparse.ArgumentParser):
+    if args.action == "artifact":
+        if args.artifact_action == "download":
+            result = client.trials.download_artifacts(args.trial_id, args.directory)
+        else:
+            result = client.trials.artifacts(args.trial_id, cursor=args.cursor, limit=args.limit)
+    elif args.action == "list":
+        options = {'cursor': args.cursor, 'limit': args.limit}
+        for field in ('type', 'job_id'):
+            if getattr(args, field) is not None:
+                options[field] = getattr(args, field)
+        result = client.trials.list(**options)
+    else:
+        result = getattr(client.trials, 'status' if args.action == 'get' else args.action)(args.trial_id)
+        if args.action in {'get', 'result'}:
+            from envloop.cli_errors import failure_lines
+
+            for line in failure_lines(result):
+                print(line, file=sys.stderr)
+    return result

envloop_experiment/cli_output.py

@@ -0,0 +1,50 @@
+import argparse
+from collections.abc import Callable
+from typing import Any
+
+from envloop.cli_output import generic_layout, timestamp
+
+
+def job_row(item: dict[str, Any]):
+    ref = item.get("dataset_ref") or {}
+    dataset = ref.get("name")
+    if dataset is not None and ref.get("version") is not None:
+        dataset = f"{dataset}@{ref['version']}"
+    status = item.get("status")
+    known = {"pending", "running", "stopping", "completed", "failed", "cancelled"}
+    training = item.get("training") or {}
+    if item.get("type") == "inference":
+        dataset = (item.get("inference") or {}).get("model")
+    if item.get("type") == "train":
+        dataset = training.get("base_model") or (training.get("spec") or {}).get("base_model")
+    return (
+        item.get("job_id"), item.get("type", "agent"), dataset if dataset is not None else item.get("name"),
+        status.capitalize() if status in known else status,
+        None if item.get("type") in {"train", "sandbox", "inference"} else
+        item.get("total_tasks") if "total_tasks" in item else
+        len(item["members"]) if isinstance(item.get("members"), list) else None,
+        timestamp(item.get("created_at")), timestamp(item.get("finished_at")),
+    )
+
+
+def list_layout(items: Any, args: argparse.Namespace):
+    if args.group == 'job' and args.action == 'event':
+        headers = ('RESOURCE', 'STATUS', 'AT', 'SOURCE')
+        render: Callable[[dict[str, Any]], tuple[Any, ...]] = lambda item: (item.get('resource_id'), item.get('status'), timestamp(item.get('at')), item.get('source'))
+        empty = 'No events recorded.'
+    elif args.group == "job" and args.action not in {"adapter", "serving-profile", "event"}:
+        headers = ("JOB ID", "TYPE", "DATASET / MODEL", "STATUS", "TASKS", "CREATED AT", "ENDED AT")
+        render = job_row
+        empty = "No jobs found."
+    else:
+        return generic_layout(items, args, {'trail': ('artifact_id', 'name', 'state', 'size') if args.action == 'artifact' else ('trial_id', 'type', 'job_id', 'name', 'status', 'created_at'), 'job': ('adapter_id', 'name', 'status', 'model', 'serving_profile')})
+    return headers, render, empty
+
+def pagination(command: list[str], args: argparse.Namespace, cursor: object):
+    if args.group == 'trail' and getattr(args, 'trial_id', None) is not None:
+        command.append(str(args.trial_id))
+    command.extend(['--limit', str(args.limit), '--cursor=' + str(cursor)])
+    fields = {'job': ('type', 'status'), 'trail': ('type', 'job_id')}
+    for field in fields.get(args.group, ()):
+        if getattr(args, field, None) is not None:
+            command.extend(['--' + field.replace('_', '-'), str(getattr(args, field))])