freesolo-flash-dev 1.2.96__tar.gz → 1.2.97__tar.gz

{freesolo_flash_dev-1.2.96 → freesolo_flash_dev-1.2.97}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.2.96
+Version: 1.2.97
 Summary: Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI
 Project-URL: Homepage, https://github.com/freesolo-co/flash
 Project-URL: Repository, https://github.com/freesolo-co/flash

{freesolo_flash_dev-1.2.96 → freesolo_flash_dev-1.2.97}/flash/cli/commands/__init__.py

@@ -7,6 +7,7 @@ import os
 import sys
 import time
 import uuid
+from typing import NamedTuple
 
 from flash import __version__
 from flash._internal.channel import BRAND_NAME, CLI_NAME
@@ -424,6 +425,8 @@ def cmd_train(args) -> int:
             )
         else:
             print(json.dumps(status, indent=2))
+        if spec.algorithm == "sft":
+            _print_published_sft_environment_note(status, spec)
         _print_unpacked_batch_warning(status, spec)  # after the payload, so stdout stays parseable
         print_status_prompt_budget_warning(status)
         _print_reasoning_loss_warning(status)
@@ -599,12 +602,17 @@ def _log_follow_metric_rows(status: dict | None, seen_steps: set) -> list[str]:
     return rows
 
 
-def _poll_logs(client: ApiClient, run_id: str, interval: float) -> tuple[str, bool]:
-    """Stream offset-paged logs until the run reaches a terminal state.
+class _LogPollResult(NamedTuple):
+    state: str
+    printed_any: bool
+    live_attempt: int | None
 
-    Returns (terminal state, whether any log bytes were printed)."""
+
+def _poll_logs(client: ApiClient, run_id: str, interval: float) -> _LogPollResult:
+    """Stream logs until terminal and return the final state, output, and attempt snapshot."""
     offset = 0
     printed_any = False
+    attempt: int | None = None
     last_progress: str | None = None
     seen_metric_steps: set = set()
     spinner = _LogFollowSpinner(run_id)
@@ -620,6 +628,7 @@ def _poll_logs(client: ApiClient, run_id: str, interval: float) -> tuple[str, bo
             # from the run status endpoint. The log page's embedded state is only a fallback for
             # older servers or test doubles.
             status = client.get_run(run_id)
+            attempt = render.live_attempt(status) if isinstance(status, dict) else attempt
             state, progress = _log_follow_progress(status, str(page.get("state") or ""))
             metric_rows = _log_follow_metric_rows(status, seen_metric_steps)
             if metric_rows:
@@ -628,7 +637,7 @@ def _poll_logs(client: ApiClient, run_id: str, interval: float) -> tuple[str, bo
                     print(row, file=sys.stderr, flush=True)
             if state in _CLI_DONE_STATES:
                 spinner.clear()
-                return state, printed_any
+                return _LogPollResult(state, printed_any, attempt)
             if not spinner.enabled and progress != last_progress:
                 print(f"status: {progress}", file=sys.stderr, flush=True)
                 last_progress = progress
@@ -677,12 +686,12 @@ def _print_detached_note(run_id: str) -> None:
 def _follow_run(client: ApiClient, run_id: str) -> int:
     """Poll logs until the run reaches a terminal state, then print the final status."""
     try:
-        state, _ = _poll_logs(client, run_id, interval=2.0)
+        result = _poll_logs(client, run_id, interval=2.0)
     except KeyboardInterrupt:
         _print_detached_note(run_id)
         return 130
     print(_render_status(client.get_run(run_id)))
-    return 0 if state in _OK_STATES else 1
+    return 0 if result.state in _OK_STATES else 1
 
 
 def _follow_status(
@@ -710,16 +719,23 @@ def cmd_log(args) -> int:
     client = client_from_config()
     if getattr(args, "follow", False):
         try:
-            state, printed_any = _poll_logs(client, args.run_id, interval=2.0)
+            result = _poll_logs(client, args.run_id, interval=2.0)
         except KeyboardInterrupt:
             _print_detached_note(args.run_id)
             return 130
-        _print_worker_output(client, args.run_id, printed_any=printed_any)
-        return 0 if state in _OK_STATES else 1
+        sections = _worker_sections(client, args.run_id)
+        _print_worker_output(
+            sections,
+            printed_any=result.printed_any,
+            current_attempt=result.live_attempt,
+        )
+        return 0 if result.state in _OK_STATES else 1
     text = str(client.get_logs(args.run_id, offset=0).get("logs") or "")
     if text:
         print(text, end="" if text.endswith("\n") else "\n")
-    _print_worker_output(client, args.run_id, printed_any=bool(text))
+    sections = _worker_sections(client, args.run_id)
+    attempt = _snapshot_live_attempt(client, args.run_id) if sections else None
+    _print_worker_output(sections, printed_any=bool(text), current_attempt=attempt)
     return 0
 
 
@@ -953,6 +969,7 @@ from flash.cli.commands.train_cost import (  # noqa: E402,F401
     _cmd_train_cost,
     _cmd_train_cost_offline,
     _cmd_train_cost_sft,
+    _print_published_sft_environment_note,
     _print_reasoning_loss_warning,
     _print_sft_cost,
     _print_train_schema_compatibility,
@@ -961,9 +978,11 @@ from flash.cli.commands.train_cost import (  # noqa: E402,F401
     _warn_if_wandb_requested_without_key,
 )
 
-# re-exported so `commands._print_worker_output(...)` keeps resolving for `cmd_log` and the CLI tests.
+# re-exported because cmd_log and focused cli tests address these through the command package.
 from flash.cli.commands.worker_output import (  # noqa: E402,F401
     _artifact_attempt,
     _print_worker_output,
+    _snapshot_live_attempt,
     _worker_section_name,
+    _worker_sections,
 )

{freesolo_flash_dev-1.2.96 → freesolo_flash_dev-1.2.97}/flash/cli/commands/train_cost.py

@@ -114,8 +114,19 @@ def _client_train_schema(authored_train_keys: frozenset[str]) -> dict:
     }
 
 
+def _has_inline_records(spec) -> bool:
+    """Whether this config supplied its SFT rows inline rather than from the resolved package.
+
+    One predicate for every surface that attributes the counts -- the cost rows and the provenance
+    note sit within a few lines of each other, so disagreeing about where the data came from would
+    print two contradictory answers in one quote.
+    """
+    params = getattr(getattr(spec, "environment", None), "params", None)
+    return isinstance(params, dict) and params.get("records") is not None
+
+
 def _sft_cost_rows(spec, profile: dict) -> list[tuple[str, str | None]]:
-    """Rows describing the packaged-dataset estimate behind an SFT quote.
+    """Rows describing the published packaged-dataset estimate behind an SFT quote.
 
     Only aggregates the server actually returned are shown. A field that is absent is dropped
     rather than defaulted, so the panel never reports a count the profile did not compute.
@@ -125,19 +136,34 @@ def _sft_cost_rows(spec, profile: dict) -> list[tuple[str, str | None]]:
         value = profile.get(key)
         return value if isinstance(value, int) and not isinstance(value, bool) else None
 
+    def text(key: str) -> str:
+        value = profile.get(key)
+        return value.strip() if isinstance(value, str) else ""
+
     steps = count("authoritative_steps")
+    source = count("source_examples")
     retained, selected = count("retained_examples"), count("selected_examples")
     dropped = count("dropped_examples")
     compute, supervised = (
         count("authoritative_compute_tokens"),
         count("authoritative_supervised_tokens"),
     )
-    packing = str(profile.get("packing_mode") or "")
-    architecture = str(profile.get("architecture_mode") or "")
-    digest = str(profile.get("content_digest") or "")
+    packing = text("packing_mode")
+    architecture = text("architecture_mode")
+    environment_id = text("environment_id")
+    environment_revision = text("environment_revision")
+    digest = text("content_digest")
+    # inline `[environment.params] records` supply the rows from the request body, so the resolved
+    # package contributed the environment but not the dataset. labelling those counts "published
+    # copy" names a source they did not come from. one adjective decides all three rows, so they
+    # cannot describe the same quote two different ways.
+    inline_records = _has_inline_records(spec)
+    origin = "inline records" if inline_records else "published copy"
+    resolved = "resolved" if inline_records else "published"
     examples = None
     if retained is not None and selected is not None:
-        examples = f"{retained:,} trained of {selected:,} selected"
+        examples = f"{retained:,} trained of {selected:,} selected from "
+        examples += f"{source:,} source rows in {origin}" if source is not None else origin
         if dropped:
             examples += f" ({dropped:,} dropped)"
     tokens = None
@@ -147,10 +173,15 @@ def _sft_cost_rows(spec, profile: dict) -> list[tuple[str, str | None]]:
             tokens += f", {supervised:,} supervised"
     return [
         ("run", f"{spec.model}  [SFT{f', {steps} steps' if steps is not None else ''}]"),
+        ("env", f"{resolved} environment {environment_id}" if environment_id else None),
+        (
+            "revision",
+            f"{environment_revision[:12]} ({resolved} commit)" if environment_revision else None,
+        ),
         ("workload", f"{packing} ({architecture})" if packing and architecture else None),
         ("examples", examples),
         ("tokens", tokens),
-        ("profile", digest[:12] or None),
+        ("digest", digest[:12] or None),
     ]
 
 
@@ -218,6 +249,71 @@ def _print_reasoning_loss_warning(status: object) -> None:
     print(render.warn(message) if render.styled() else f"warning: {message}", file=sys.stderr)
 
 
+def _print_published_sft_environment_note(status: object, spec) -> None:
+    """Warn when SFT counts came from a published managed or GitHub environment."""
+    if _has_inline_records(spec):
+        return
+
+    profile = status.get("workload_profile") if isinstance(status, dict) else None
+    if not isinstance(profile, dict):
+        return
+    environment_id = profile.get("environment_id")
+    revision = profile.get("environment_revision")
+    if not isinstance(environment_id, str) or not environment_id.strip():
+        return
+    if not isinstance(revision, str) or not revision.strip():
+        return
+
+    environment_id = environment_id.strip()
+    advice = _republish_advice(environment_id)
+    if advice is None:
+        return
+
+    source = profile.get("source_examples")
+    source_suffix = (
+        f" ({source:,} source rows)"
+        if isinstance(source, int) and not isinstance(source, bool)
+        else ""
+    )
+    message = (
+        f"published environment: {environment_id} @ {revision.strip()[:12]}{source_suffix}. "
+        "SFT dataset counts come from this resolved published copy, not local files. "
+        f"{advice}"
+    )
+    print(render.note(message) if render.styled() else message, file=sys.stderr)
+
+
+def _republish_advice(environment_id: str) -> str | None:
+    """Return conditional remediation for a managed or GitHub environment id."""
+    from flash.envs.identity import (
+        canonical_managed_environment_slug,
+        github_environment_ref_is_pinned,
+        is_github_environment_ref,
+    )
+
+    prefix = "If you expected local dataset edits to be included, "
+    try:
+        managed_slug = canonical_managed_environment_slug(environment_id)
+    except ValueError:
+        return None
+    if managed_slug is not None:
+        return (
+            f"{prefix}run `{_commands().CLI_NAME} env push --name NAME "
+            "--project PROJECT_UUID [path]` again for this managed environment."
+        )
+    if not is_github_environment_ref(environment_id):
+        return None
+    if github_environment_ref_is_pinned(environment_id):
+        return (
+            f"{prefix}publish the new commit, then update [environment] id to the full new commit "
+            "SHA; the existing immutable SHA cannot move."
+        )
+    return (
+        f"{prefix}make the named remote branch or tag point at the new commit. A tag may instead "
+        "need a new tag and an updated [environment] id rather than moving the existing tag."
+    )
+
+
 def _print_sft_cost(status: dict, spec) -> None:
     total = status.get("estimated_cost_usd") if isinstance(status, dict) else None
     if not isinstance(total, (int, float)) or isinstance(total, bool):
@@ -234,6 +330,7 @@ def _print_sft_cost(status: dict, spec) -> None:
             if value is not None:
                 print(f"{key.ljust(8)}: {value}")
         print(f"{'TOTAL'.ljust(8)}: ${float(total):.2f}")
+    _print_published_sft_environment_note(status, spec)
     print(
         "tokens, retained rows, truncation, and optimizer steps are estimated from packaged "
         "input/output fields plus contract_text, contract_path, or TRAINING_CONTRACT.md. other "

{freesolo_flash_dev-1.2.96 → freesolo_flash_dev-1.2.97}/flash/cli/commands/worker_output.py

@@ -17,8 +17,11 @@ import re
 from typing import TYPE_CHECKING
 
 from flash.cli.ui import render
+from flash.client import ClientError
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
+
     from flash.client import ApiClient
 
 
@@ -42,18 +45,24 @@ def _worker_section_name(name: str, current_attempt: int | None) -> str:
     return f"{name} (attempt={attempt}, current attempt)"
 
 
-def _print_worker_output(client: ApiClient, run_id: str, *, printed_any: bool = False) -> bool:
-    worker_output = client.get_worker_output(run_id) or {}
-    if not worker_output:
-        return printed_any
+def _worker_sections(client: ApiClient, run_id: str) -> dict[str, str]:
+    """Fetch only worker artifacts with printable text."""
+    return {name: text for name, text in (client.get_worker_output(run_id) or {}).items() if text}
+
+
+def _snapshot_live_attempt(client: ApiClient, run_id: str) -> int | None:
+    """Read the live attempt without letting a heading lookup hide diagnostic artifacts."""
     try:
-        current_attempt = render.live_attempt(client.get_run(run_id) or {})
-    except Exception:
-        # artifact text is best-effort diagnostic output; a status refresh failure must not hide it.
-        current_attempt = None
-    for name, text in worker_output.items():
-        if not text:
-            continue
+        return render.live_attempt(client.get_run(run_id) or {})
+    except ClientError:
+        return None
+
+
+def _print_worker_output(
+    sections: Mapping[str, str], *, printed_any: bool = False, current_attempt: int | None = None
+) -> bool:
+    """Print worker artifacts under headings naming the attempt that produced them."""
+    for name, text in sections.items():
         # label provenance from the filename rather than letting the final section, which is merely
         # the last one appended, read as the live attempt's output.
         section_name = _worker_section_name(name, current_attempt)

{freesolo_flash_dev-1.2.96 → freesolo_flash_dev-1.2.97}/flash/envs/identity.py

@@ -255,3 +255,13 @@ def _is_safe_github_path_parts(parts: list[str] | tuple[str, ...]) -> bool:
 def is_commit_sha(value: str) -> bool:
     """True when value is a full 40-hex-char git commit id (an immutable ref)."""
     return _COMMIT_SHA_RE.fullmatch(value) is not None
+
+
+def github_environment_ref_is_pinned(value: str) -> bool:
+    """True when a ``github:`` environment id names an immutable commit.
+
+    Only the SHA case is decidable from the id. Branches and tags share one string shape, so callers
+    must give symbolic-ref advice that is valid for either rather than assuming the ref is movable.
+    """
+    parsed = _parse_github_environment_ref(value)
+    return parsed is not None and is_commit_sha(parsed.ref)

{freesolo_flash_dev-1.2.96 → freesolo_flash_dev-1.2.97}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "freesolo-flash-dev"
-version = "1.2.96"
+version = "1.2.97"
 description ="Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI"
 readme = "README.md"
 # RunPod Flash supports Python 3.11-3.12 (not 3.13 yet).
@@ -137,7 +137,7 @@ artifacts = ["flash/py.typed"]
 # auto-published by .github/workflows/publish-dev.yml: a push to `dev` whose version isn't yet on
 # PyPI publishes it; pushes that don't change it find it already published and no-op. So cutting a
 # dev-channel release = bump this (and [project].version) and merge to `dev`.
-version = "1.2.96"
+version = "1.2.97"
 
 [tool.pytest.ini_options]
 pythonpath = ["."]

{freesolo_flash_dev-1.2.96 → freesolo_flash_dev-1.2.97}/tests/test_cli_commands.py

@@ -1322,6 +1322,129 @@ def test_train_dry_run_keeps_compatibility_on_stderr(
     assert call[1]["train"] == {"epochs": 1, "max_examples": 2}
 
 
+def test_train_dry_run_attributes_sft_counts_to_the_managed_environment(
+    fake_client, tmp_path, capsys, monkeypatch
+) -> None:
+    original_create_run = fake_client.create_run
+
+    def create_run_with_profile(*args, **kwargs):
+        response = original_create_run(*args, **kwargs)
+        response["workload_profile"] = {
+            "environment_id": "owner/project/env",
+            "environment_revision": "a" * 40,
+            "source_examples": 125,
+        }
+        return response
+
+    monkeypatch.setattr(fake_client, "create_run", create_run_with_profile)
+
+    assert _run(["train", str(_train_config(tmp_path)), "--dry-run"]) == 0
+    captured = capsys.readouterr()
+    payload = json.loads(captured.out)
+
+    assert payload["workload_profile"]["environment_id"] == "owner/project/env"
+    assert payload["workload_profile"]["environment_revision"] == "a" * 40
+    assert (
+        "published environment: owner/project/env @ aaaaaaaaaaaa (125 source rows)" in captured.err
+    )
+    assert "dataset counts come from this resolved published copy, not local files" in captured.err
+    assert "If you expected local dataset edits to be included" in captured.err
+    assert (
+        "run `flash env push --name NAME --project PROJECT_UUID [path]` again for this managed "
+        "environment"
+    ) in captured.err
+
+
+def test_train_dry_run_keeps_inline_records_off_the_published_environment_note(
+    fake_client, tmp_path, capsys, monkeypatch
+) -> None:
+    """inline rows are already authoritative, so the published-copy warning does not apply."""
+    original_create_run = fake_client.create_run
+
+    def create_run_with_profile(*args, **kwargs):
+        response = original_create_run(*args, **kwargs)
+        response["workload_profile"] = {
+            "environment_id": "owner/project/env",
+            "environment_revision": "a" * 40,
+            "source_examples": 2,
+        }
+        return response
+
+    monkeypatch.setattr(fake_client, "create_run", create_run_with_profile)
+    config = tmp_path / "inline.toml"
+    config.write_text(
+        'model = "Qwen/Qwen3.5-4B"\n'
+        'project = "11111111-1111-4111-8111-111111111111"\n'
+        'algorithm = "sft"\n'
+        '[environment]\nid = "owner/project/env"\n'
+        '[environment.params]\nrecords = [{ input = "a", output = "b" }]\n'
+        "[train]\nepochs = 1\nmax_examples = 2\n"
+    )
+
+    assert _run(["train", str(config), "--dry-run"]) == 0
+    captured = capsys.readouterr()
+    payload = json.loads(captured.out)
+
+    assert payload["workload_profile"]["source_examples"] == 2
+    assert "published environment:" not in captured.err
+    assert "SFT dataset counts come from" not in captured.err
+    assert "env push" not in captured.err
+
+
+def test_inline_records_are_not_labelled_a_published_copy_in_cost_rows(monkeypatch) -> None:
+    """The cost panel and the provenance note sit within a few lines of each other.
+
+    If only the note learns that the rows came from the request body, the panel above it still
+    reads "source rows in published copy" and the quote contradicts itself in one screen.
+    """
+    from types import SimpleNamespace
+
+    from flash.cli.commands import train_cost
+
+    monkeypatch.setenv("FLASH_STYLE", "0")
+    profile = {
+        "environment_id": "owner/project/env",
+        "environment_revision": "d" * 40,
+        "source_examples": 9,
+        "retained_examples": 8,
+        "selected_examples": 9,
+    }
+    spec = SimpleNamespace(
+        model="Qwen/Qwen3.5-4B",
+        environment=SimpleNamespace(params={"records": [{"input": "x"}]}),
+    )
+
+    rows = dict(train_cost._sft_cost_rows(spec, profile))
+
+    assert "inline records" in rows["examples"]
+    assert "published copy" not in rows["examples"]
+    assert rows["env"] == "resolved environment owner/project/env"
+    assert "published" not in rows["revision"]
+
+
+def test_published_rows_keep_their_published_labels(monkeypatch) -> None:
+    """The inline branch must not relabel an ordinary published quote."""
+    from types import SimpleNamespace
+
+    from flash.cli.commands import train_cost
+
+    monkeypatch.setenv("FLASH_STYLE", "0")
+    profile = {
+        "environment_id": "owner/project/env",
+        "environment_revision": "e" * 40,
+        "source_examples": 9,
+        "retained_examples": 8,
+        "selected_examples": 9,
+    }
+    spec = SimpleNamespace(model="Qwen/Qwen3.5-4B", environment=SimpleNamespace(params={}))
+
+    rows = dict(train_cost._sft_cost_rows(spec, profile))
+
+    assert "source rows in published copy" in rows["examples"]
+    assert rows["env"] == "published environment owner/project/env"
+    assert "(published commit)" in rows["revision"]
+
+
 def test_train_dry_run_sends_declared_runtime_secrets(
     fake_client, tmp_path, capsys, monkeypatch
 ) -> None:
@@ -1413,13 +1536,16 @@ def test_status_runs_and_log_command(fake_client, capsys, monkeypatch) -> None:
             {"run_id": "flash-1", "state": "done"},
         ]
     )
-    monkeypatch.setattr(fake_client, "get_run", lambda _run_id: next(statuses))
-    monkeypatch.setattr(cli.commands.time, "sleep", lambda _seconds: None)
-    assert _run(["runs", "status", "flash-1", "--follow", "--json"]) == 0
-    assert [json.loads(line)["state"] for line in capsys.readouterr().out.splitlines()] == [
-        "running",
-        "done",
-    ]
+    with monkeypatch.context() as patched:
+        # scoped: this iterator holds exactly the two statuses this one assertion consumes, so
+        # letting it stay installed would starve every later command of a status it needs.
+        patched.setattr(fake_client, "get_run", lambda _run_id: next(statuses))
+        patched.setattr(cli.commands.time, "sleep", lambda _seconds: None)
+        assert _run(["runs", "status", "flash-1", "--follow", "--json"]) == 0
+        assert [json.loads(line)["state"] for line in capsys.readouterr().out.splitlines()] == [
+            "running",
+            "done",
+        ]
 
     assert _run(["runs", "log", "flash-1"]) == 0
     out = capsys.readouterr().out
@@ -1483,6 +1609,104 @@ def test_log_labels_previous_attempt_artifacts_after_the_live_attempt_log(
     assert 'HEARTBEAT {"stage":"rl_step","step":0,"attempt":0' in out
 
 
+def test_log_still_prints_artifacts_when_the_attempt_lookup_fails(
+    fake_client, capsys, monkeypatch
+) -> None:
+    """A failed status read costs the heading, never the artifacts.
+
+    The artifacts hold the traceback the user ran this command to read. Losing them to a lookup
+    that only decorates a section header would hide the failure behind an unrelated one.
+    """
+    from flash.client import ClientError
+
+    def unavailable(_run_id):
+        raise ClientError("freesolo is unreachable")
+
+    monkeypatch.setattr(fake_client, "get_run", unavailable)
+    monkeypatch.setattr(
+        fake_client,
+        "get_worker_output",
+        lambda _run_id: {"error_rl_attempt0.txt": "torch.OutOfMemoryError: CUDA OOM\n"},
+    )
+
+    assert _run(["runs", "log", "flash-1"]) == 0
+    out = capsys.readouterr().out
+    assert "torch.OutOfMemoryError: CUDA OOM" in out
+    # unlabelled against a live attempt, since none could be established -- but still attributed.
+    assert "----- error_rl_attempt0.txt (attempt=0) -----" in out
+
+
+def test_log_reads_no_status_when_there_are_no_artifacts_to_label(
+    fake_client, capsys, monkeypatch
+) -> None:
+    """The status only names a heading, so with no headings it is never worth a request."""
+    calls: list[str] = []
+
+    def get_run(_run_id):
+        calls.append("get_run")
+        return {"run_id": "flash-1", "state": "running", "remote": {"attempt": 0}}
+
+    monkeypatch.setattr(fake_client, "get_run", get_run)
+    monkeypatch.setattr(fake_client, "get_worker_output", lambda _run_id: {})
+
+    assert _run(["runs", "log", "flash-1"]) == 0
+    capsys.readouterr()
+    assert calls == []
+
+
+def test_log_reads_no_status_and_prints_nothing_when_all_artifacts_are_empty(
+    fake_client, capsys, monkeypatch
+) -> None:
+    """Empty artifact values are not printable sections and must not trigger a status read."""
+    fake_client.log_text = ""
+    calls: list[str] = []
+
+    def get_run(_run_id):
+        calls.append("get_run")
+        return {"run_id": "flash-1", "state": "running", "remote": {"attempt": 1}}
+
+    monkeypatch.setattr(fake_client, "get_run", get_run)
+    monkeypatch.setattr(
+        fake_client,
+        "get_worker_output",
+        lambda _run_id: {
+            "console_rl_attempt1.txt": "",
+            "error_rl_attempt1.txt": "",
+        },
+    )
+
+    assert _run(["runs", "log", "flash-1"]) == 0
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert captured.err == ""
+    assert calls == []
+
+
+def test_log_labels_artifacts_against_a_retry_that_starts_mid_command(
+    fake_client, capsys, monkeypatch
+) -> None:
+    """Artifact acquisition must precede the status snapshot used for its heading."""
+    events: list[str] = []
+
+    def get_worker_output(_run_id):
+        events.append("artifacts")
+        return {"error_rl_attempt0.txt": "torch.OutOfMemoryError: CUDA OOM\n"}
+
+    def get_run(_run_id):
+        events.append("status")
+        return {"run_id": "flash-1", "state": "running", "remote": {"attempt": 1}}
+
+    monkeypatch.setattr(fake_client, "get_worker_output", get_worker_output)
+    monkeypatch.setattr(fake_client, "get_run", get_run)
+
+    assert _run(["runs", "log", "flash-1"]) == 0
+    out = capsys.readouterr().out
+    assert events == ["artifacts", "status"]
+    assert (
+        "----- error_rl_attempt0.txt (attempt=0, previous attempt; current attempt=1) -----" in out
+    )
+
+
 def test_log_prints_partial_log_line_with_newline(fake_client, capsys) -> None:
     fake_client.log_text = "partial log line"
     fake_client.get_worker_output = lambda run_id: {}
@@ -1624,7 +1848,7 @@ def test_follow_logs_shows_tty_spinner_while_waiting(monkeypatch, capsys) -> Non
     monkeypatch.setattr(cli.commands.sys, "stderr", stderr)
     monkeypatch.setattr(cli.commands.time, "sleep", lambda _seconds: None)
 
-    state, printed_any = cli.commands._poll_logs(_WaitingClient(), "flash-spin", interval=0.2)
+    state, printed_any, _ = cli.commands._poll_logs(_WaitingClient(), "flash-spin", interval=0.2)
 
     assert state == "done"
     assert printed_any is True
@@ -1635,6 +1859,21 @@ def test_follow_logs_shows_tty_spinner_while_waiting(monkeypatch, capsys) -> Non
     assert err.endswith("\r")
 
 
+def test_poll_logs_returns_the_live_attempt_from_the_terminal_status(capsys) -> None:
+    class _AttemptClient(_FakeClient):
+        def get_logs(self, run_id: str, offset: int = 0) -> dict:
+            return {"run_id": run_id, "logs": "", "offset": 0, "state": "done"}
+
+        def get_run(self, run_id: str) -> dict:
+            return {"run_id": run_id, "state": "done", "remote": {"attempt": 1}}
+
+    result = cli.commands._poll_logs(_AttemptClient(), "flash-attempt", interval=0)
+
+    assert result == cli.commands._LogPollResult("done", False, 1)
+    assert result.live_attempt == 1
+    assert capsys.readouterr().out == ""
+
+
 def test_follow_logs_uses_status_progress_when_log_tail_lags(monkeypatch, capsys) -> None:
     class _TTYBuffer(io.StringIO):
         def isatty(self) -> bool:
@@ -1671,7 +1910,7 @@ def test_follow_logs_uses_status_progress_when_log_tail_lags(monkeypatch, capsys
     monkeypatch.setattr(cli.commands.sys, "stderr", stderr)
     monkeypatch.setattr(cli.commands.time, "sleep", lambda _seconds: None)
 
-    state, printed_any = cli.commands._poll_logs(_LaggingLogClient(), "flash-lag", interval=0.2)
+    state, printed_any, _ = cli.commands._poll_logs(_LaggingLogClient(), "flash-lag", interval=0.2)
 
     assert state == "done"
     assert printed_any is False
@@ -1744,7 +1983,7 @@ def test_follow_logs_prints_heartbeat_metrics_once_per_step(monkeypatch, capsys)
 
     monkeypatch.setattr(cli.commands.time, "sleep", lambda _seconds: None)
 
-    state, printed_any = cli.commands._poll_logs(_MetricClient(), "flash-metrics", interval=0.2)
+    state, printed_any, _ = cli.commands._poll_logs(_MetricClient(), "flash-metrics", interval=0.2)
 
     assert state == "done"
     assert printed_any is False