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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.2.96
+Version: 1.2.98
 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.98}/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.98}/flash/cli/commands/train_cost.py

@@ -61,21 +61,30 @@ def _cmd_train_cost(args) -> int:
 
 def _cmd_train_cost_offline(spec) -> int:
     """Catalog-only quote for the algorithms that do not need workload evidence yet (grpo, opd)."""
+    from dataclasses import replace
+
     from flash.cost import estimate_cost
+    from flash.schema import MIN_LORA_RANK
 
+    config = runconfig_from_spec(spec)
     if spec.train.init_from_adapter:
-        # --cost is offline/catalog-only and cannot read the source adapter, so the rank stays at the
-        # local default. Warm starts train and are priced at the SOURCE adapter's authoritative rank
-        # (resolved server-side at submit/dry-run), which can be higher — so this estimate may
-        # under-quote. stderr keeps stdout clean for machine-readable callers.
+        # --cost is offline/catalog-only and cannot read the source adapter's rank, and the parser
+        # rejects an authored `lora_rank` alongside `init_from_adapter`, so there is never an
+        # authored rank to quote at. stderr keeps stdout clean for machine-readable callers.
+        #
+        # quote at rank 1 rather than at the serialization placeholder. the placeholder is not a
+        # measurement of anything, and `estimate_cost` reads the rank for both the exact-card fit and
+        # cost-ranked hardware selection. rank 1 is a vram lower bound, but not a dollar lower bound:
+        # a higher source rank can move the run onto a cheaper multi-card shape.
+        config = replace(config, lora_rank=MIN_LORA_RANK)
         print(
-            "warning: warm-start (train.init_from_adapter) cost uses the default LoRA rank; the "
-            "source adapter's rank is authoritative and resolved at submit, so a higher-rank source "
-            f"may cost more than this estimate. Run `{_commands().CLI_NAME} train --dry-run` "
-            "for a source-rank quote.",
+            "warning: warm-start (train.init_from_adapter) cost is a provisional rank-1 estimate. "
+            "The authoritative source adapter rank is resolved server-side and can change the "
+            "selected hardware and cost in either direction. Run "
+            f"`{_commands().CLI_NAME} train --dry-run` for a quote using the resolved source rank.",
             file=sys.stderr,
         )
-    estimate = estimate_cost(runconfig_from_spec(spec))
+    estimate = estimate_cost(config)
     if render.styled():
         print(render.cost_panel(estimate))
     else:
@@ -114,8 +123,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 +145,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 +182,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 +258,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 +339,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.98}/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.98}/flash/engine/plan/kv_sizing.py

@@ -132,6 +132,26 @@ def _colocate_util_cap(weights_gb: float, total_vram_gb: float) -> float:
     return 0.55 if (big_weight_copy and leaves_room_for_trainer_copy) else 0.45
 
 
+def _capped_engine_util(
+    weights_gb: float,
+    adapter_gb: float,
+    requested_kv_gb: float,
+    total_vram_gb: float,
+    util_cap: float,
+) -> float:
+    """Fit weights, adapter, then KV into vllm's capped share of one card."""
+    card_gb = max(1.0, total_vram_gb)
+    max_engine_gb = util_cap * card_gb
+    # gpu_memory_utilization is vllm's whole allocation, and its lora weights live inside it. reserve
+    # weights plus adapter first; only a cap collision may reduce the requested kv pool. spelling out
+    # fitted_kv_gb makes that loss visible instead of incidentally subtracting adapter bytes from a
+    # weights-plus-kv fraction. if weights plus adapter alone exceed the cap, kv reaches zero and the
+    # returned cap truthfully exposes that this engine shape has no viable cache budget.
+    fitted_kv_gb = max(0.0, min(requested_kv_gb, max_engine_gb - weights_gb - adapter_gb))
+    fitted_engine_gb = weights_gb + adapter_gb + fitted_kv_gb
+    return min(util_cap, fitted_engine_gb / card_gb)
+
+
 def colocate_kv_util(
     params_b: float | None,
     vllm_max_len: int,
@@ -143,14 +163,19 @@ def colocate_kv_util(
     model_info=None,
     preserve_legacy_floor: bool = False,
     tensor_parallel: int = 1,
+    lora_rank: int = 0,
 ) -> float:
     """vllm_gpu_memory_utilization for one colocated rollout tensor-parallel rank.
 
-    Budget the rank's weight shard plus a conservative full KV cache. Catalog models use geometry
-    with measured overhead and an 8 GB floor; uncataloged models retain the legacy KV equation.
+    budget the rank's weight shard, rank-local bf16 lora footprint, and conservative full kv cache.
+    catalog models use geometry with measured overhead and an 8 gb floor; uncataloged models retain
+    the legacy kv equation and no unverified adapter margin.
     """
+    from flash.engine.plan.vram import _lora_weight_memory_gb
+
     total_weights_gb = max(0.5, float(params_b or 1.0)) * 2.0
     tp_size = max(1, int(tensor_parallel))
+    adapter_gb = _lora_weight_memory_gb(lora_rank, model_info, tensor_parallel=tp_size) or 0.0
     # tensor parallelism shards vllm's bf16 weights, but kv heads can replicate when tp is wider than
     # the model's kv-head count. shard only the weight term and keep the full kv budget on every rank.
     weights_gb = total_weights_gb if tp_size == 1 else total_weights_gb / tp_size
@@ -162,7 +187,7 @@ def colocate_kv_util(
     # but not H200. `_NvidiaSmiPeakSampler` verifies runtime headroom.
     _util_cap = _colocate_util_cap(weights_gb, total_vram_gb)
     if not sleep_mode:
-        # `gpu_memory_utilization` covers weights plus KV, so budget both. scale KV with
+        # `gpu_memory_utilization` covers weights, adapter, and kv, so budget all three. scale kv with
         # context and group, floor at `_KV_CAP`, and keep the 0.45 cap aligned with
         # `estimate_vram_gb(..., sleep_offload=False)`.
         kv_gb = max(
@@ -176,7 +201,8 @@ def colocate_kv_util(
                 preserve_legacy_floor=preserve_legacy_floor,
             ),
         )
-        return max(_MIN_ENGINE_UTIL, min(_util_cap, (weights_gb + kv_gb) / max(1.0, total_vram_gb)))
+        sized = _capped_engine_util(weights_gb, adapter_gb, kv_gb, total_vram_gb, _util_cap)
+        return max(_MIN_ENGINE_UTIL, sized)
     # Sleep mode keeps a larger pool (1.5x margin): the engine is offloaded during the backward, so a
     # bigger rollout-phase KV does not compete with the training peak.
     kv_pool_gb = max(
@@ -191,7 +217,7 @@ def colocate_kv_util(
             preserve_legacy_floor=preserve_legacy_floor,
         ),
     )
-    sized = min(_util_cap, (weights_gb + kv_pool_gb) / max(1.0, total_vram_gb))
+    sized = _capped_engine_util(weights_gb, adapter_gb, kv_pool_gb, total_vram_gb, _util_cap)
     # sharding the weight term can drive a small model's rank budget low enough that vllm has no
     # room left for its own runtime once the kv pool is carved out -- a 4B model on 2 cards prices
     # under this floor. single-rank sizing carries the whole weight copy and never gets that small,

{freesolo_flash_dev-1.2.96 → freesolo_flash_dev-1.2.98}/flash/engine/plan/vram.py

@@ -129,6 +129,33 @@ def _legacy_lora_floor_gb(lora_rank: int, effective_params_b: float) -> float:
     return (lora_rank / 16.0) * (0.3 + 0.04 * effective_params_b)
 
 
+def _lora_parameter_count(
+    lora_rank: int, model_info=None, *, tensor_parallel: int = 1
+) -> int | None:
+    """lora parameters resident on one tensor-parallel rank from concrete target geometry."""
+    shapes = tuple(getattr(model_info, "lora_target_shapes", ()) or ())
+    rank = int(lora_rank)
+    if not shapes or rank <= 0:
+        return None
+    tp_size = max(1, int(tensor_parallel))
+    if tp_size == 1:
+        return rank * sum((int(i) + int(o)) * int(count) for i, o, count in shapes)
+    # vllm shards one factor, except the current min-dim-1 gate keeps that factor whole. integer shard
+    # sizing covers that catalog shape exactly; this is not a general replicated-layer classifier.
+    return sum(
+        rank * int(count) * (max(int(i), int(o)) + math.ceil(min(int(i), int(o)) / tp_size))
+        for i, o, count in shapes
+    )
+
+
+def _lora_weight_memory_gb(
+    lora_rank: int, model_info=None, *, tensor_parallel: int = 1
+) -> float | None:
+    """rank-local resident bf16 lora weights, or none without catalog target geometry."""
+    params = _lora_parameter_count(lora_rank, model_info, tensor_parallel=tensor_parallel)
+    return None if params is None else params * _BYTES_PER_PARAM["bf16"] / 1e9
+
+
 def _lora_memory_gb(
     lora_rank: int,
     effective_params_b: float,
@@ -137,14 +164,9 @@ def _lora_memory_gb(
 ) -> float:
     """Adapter, gradient, and optimizer memory for the actual PEFT all-linear targets."""
     floor = _legacy_lora_floor_gb(lora_rank, effective_params_b)
-    shapes = tuple(getattr(model_info, "lora_target_shapes", ()) or ())
-    if not shapes:
+    trainable_params = _lora_parameter_count(lora_rank, model_info)
+    if trainable_params is None:
         return floor
-    target_dims = sum(
-        (int(in_features) + int(out_features)) * int(count)
-        for in_features, out_features, count in shapes
-    )
-    trainable_params = max(1, int(lora_rank)) * target_dims
     bytes_per_param = (
         _LORA_PAGED_BYTES_PER_PARAM
         if (algorithm or "").lower() in ("grpo", "rl")
@@ -225,15 +247,15 @@ def grpo_kv_floor_gb(
     fp8_kv: bool = False,
     model_info=None,
     preserve_legacy_floor: bool = False,
+    lora_rank: int = 0,
+    tensor_parallel: int = 1,
 ) -> int:
-    """Smallest card (GB) whose colocated vLLM executor budget still leaves a viable KV pool.
-
-    The 0.45/0.55 cap must hold the weight copy plus half the concurrent group's KV; otherwise
-    vLLM can fail with "No available memory for the cache blocks".
-    """
+    """Smallest card whose cap holds rank-local weights, adapter, and half the KV pool."""
     kv_params_b = float(active_params_b) if active_params_b else float(params_b)
-    weights_gb = max(0.5, float(params_b)) * 2.0
-    need = weights_gb + 0.5 * _resident_kv_gb(
+    tp_size = max(1, int(tensor_parallel))
+    weights_gb = max(0.5, float(params_b)) * 2.0 / tp_size
+    adapter_gb = _lora_weight_memory_gb(lora_rank, model_info, tensor_parallel=tp_size) or 0.0
+    kv_gb = _resident_kv_gb(
         kv_params_b,
         vllm_max_len,
         group_size,
@@ -241,6 +263,7 @@ def grpo_kv_floor_gb(
         model_info=model_info,
         preserve_legacy_floor=preserve_legacy_floor,
     )
+    need = weights_gb + adapter_gb + 0.5 * kv_gb
     lower = math.ceil(need / 0.55)
     upper = math.ceil(need / 0.45)
     for total_vram_gb in range(lower, upper + 1):
@@ -295,6 +318,7 @@ def _rollout_kv_floor_gb(
     model_info=None,
     model_id: str = "",
     preserve_legacy_floor: bool = False,
+    lora_rank: int = 0,
 ) -> int:
     floor = grpo_kv_floor_gb(
         params_b,
@@ -303,6 +327,7 @@ def _rollout_kv_floor_gb(
         active_params_b=active_params_b,
         model_info=model_info,
         preserve_legacy_floor=preserve_legacy_floor,
+        lora_rank=lora_rank,
     )
     from flash.providers.base import max_non_fp8_kv_vram_gb
 
@@ -323,6 +348,7 @@ def _rollout_kv_floor_gb(
         fp8_kv=True,
         model_info=model_info,
         preserve_legacy_floor=preserve_legacy_floor,
+        lora_rank=lora_rank,
     )
     return max(fp8_floor, ceiling + 1)
 
@@ -838,6 +864,7 @@ def _catalog_model_required_vram_gb(
                 model_info=sizing_info,
                 model_id=model_id,
                 preserve_legacy_floor=is_opd,
+                lora_rank=lora_rank,
             ),
         )
     return need

{freesolo_flash_dev-1.2.96 → freesolo_flash_dev-1.2.98}/flash/engine/worker/opd_train_runner.py

@@ -560,6 +560,7 @@ def _resolve_opd_gpu_mem_util(
             "model_id": model_id,
             "model_revision": str(getattr(request, "model_revision", "") or ""),
             "engine_len": int(prompt_state.max_model_len),
+            "lora_rank": int(workload.lora_rank),
             # opd submits prompts_per_step * group_size generations to the rollout engine together.
             # grpo's concurrency is group_size because its resolver receives one prompt group here.
             "group_size": int(workload.prompts_per_step) * int(request.knobs.group_size),

{freesolo_flash_dev-1.2.96 → freesolo_flash_dev-1.2.98}/flash/engine/worker/train/rl/verl_config.py

@@ -503,13 +503,16 @@ def resolve_gpu_mem_util(
 ) -> float:
     """size vllm's colocated executor budget from this run's geometry.
 
-    ``gpu_memory_utilization`` covers the second bf16 weight copy plus kv pool. using
+    ``gpu_memory_utilization`` covers the second bf16 weight copy, lora adapter, and kv pool. using
     ``colocate_kv_util`` keeps worker allocation aligned with preflight admission.
 
-    for multi-gpu runs, vllm shards its bf16 weight copy across tensor-parallel ranks. the kv term
-    remains unsharded here because vllm can replicate kv heads when tensor parallelism is wider than
-    the model's kv-head count. the result is explicitly capped at the old 0.5 constant, so this path
-    can only lower a rank's reservation and cannot create a new over-reservation.
+    for multi-gpu runs, vllm shards its bf16 weight copy across tensor-parallel ranks. its default
+    lora layout shards only one factor of each projection's a/b pair, so the rank-local adapter uses
+    the larger safe orientation from catalog geometry rather than dividing the full adapter evenly.
+    the kv term remains unsharded here because vllm can replicate kv heads when tensor parallelism is
+    wider than the model's kv-head count. the adapter lives inside vllm's reservation, and the result
+    is explicitly capped at the old 0.5 constant, so this path can only lower a rank's reservation
+    and cannot create a new over-reservation.
 
     the flat constant is kept where the model does not apply, because a wrong number is worse than
     a conservative one:
@@ -564,6 +567,7 @@ def resolve_gpu_mem_util(
             model_info=info,
             preserve_legacy_floor=preserve_legacy_floor,
             tensor_parallel=n_gpus,
+            lora_rank=int(inp["lora_rank"]),
         )
         # multi-rank sizing is strictly one-directional against the previous worker contract: it may
         # free memory but can never claim more than the flat reservation a working run already used.

{freesolo_flash_dev-1.2.96 → freesolo_flash_dev-1.2.98}/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)