freesolo-flash-dev 1.2.132__tar.gz → 1.2.134__tar.gz

{freesolo_flash_dev-1.2.132 → freesolo_flash_dev-1.2.134}/.github/workflows/ci.yml

@@ -60,8 +60,7 @@ jobs:
       - name: Function size check
         run: uv run python scripts/check_function_size.py
 
-      # Keep the source hierarchy reviewable: no directory may exceed ten tracked files, and package
-      # roots may mix subdirectories only with the three required marker files.
+      # Package roots may mix subdirectories only with semantic package marker files.
       - name: Source layout check
         run: uv run python scripts/check_source_layout.py
 

{freesolo_flash_dev-1.2.132 → freesolo_flash_dev-1.2.134}/.github/workflows/deploy-modal-dev.yml

@@ -114,7 +114,7 @@ jobs:
           # pinned to the exact client pyproject declares; see deploy-modal.yml for why an
           # unbounded range is unsafe for the deploy path.
           # exact pins keep the deploy client bootstrap reproducible across runner image changes.
-          uv pip install --system "modal==1.5.4" "python-dotenv==1.2.3"
+          uv pip install --system "modal==1.6.1" "python-dotenv==1.2.3"
 
       - name: Verify development deployment inputs
         if: steps.gate.outputs.deploy == 'true'

{freesolo_flash_dev-1.2.132 → freesolo_flash_dev-1.2.134}/.github/workflows/deploy-modal.yml

@@ -11,6 +11,7 @@ name: Deploy serving Modal app
 #   FREESOLO_INTERNAL_KEY                - shared platform internal key (backend + serving)
 #   PLATFORM_BACKEND_URL                 - platform backend base URL
 #   SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY - serving startup hydration (durable adapter registry)
+# required Actions variable: SERVING_CANARY_ORG_ID - existing internal organization billed for probes
 # modal_app.py reads these from the environment (load_dotenv only supplements os.environ), so no
 # .env file is written in CI. the "Verify required runtime secrets" step below hard-fails the deploy
 # if a required secret is absent, preventing a broken production config with external chat failures,
@@ -40,13 +41,13 @@ jobs:
     if: github.ref == 'refs/heads/main'
     runs-on: ubuntu-latest
     # the job's own bounded waits now sum well past the old 30: two 300s readiness polls, the remote
-    # image build, a 420s canary that pays a GPU cold start, a 180s accounting deadline, and on the
-    # failure path a SECOND `modal deploy` plus a 300s restore poll. 60 minutes clears that worst
+    # image build, a 3360s canary that pays a GPU cold start, a 180s accounting deadline, and on the
+    # failure path a SECOND `modal deploy` plus a 300s restore poll. 90 minutes clears that worst
     # case with room while keeping a wedged deploy from holding the runner for GitHub's 6-hour
     # default. the headroom is specifically for the rollback: a job killed partway through the
     # restore leaves the broken release live with no second attempt, which is the one outcome this
     # workflow exists to prevent.
-    timeout-minutes: 60
+    timeout-minutes: 90
     # serialize serving deploys across runs because each deploy mutates the live app. github can still
     # replace a pending run, so the gate compares against the sha reported by the deployed app rather
     # than assuming every push predecessor was deployed.
@@ -75,6 +76,7 @@ jobs:
       # (empty => default *.modal.run url), so non-prod/fork/local workspaces stay deployable. This
       # domain is verified in the production Modal workspace, so prod keeps serving on serve.freesolo.co.
       SERVING_CUSTOM_DOMAIN: serve.freesolo.co
+      SERVING_CANARY_ORG_ID: ${{ vars.SERVING_CANARY_ORG_ID }}
 
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -168,7 +170,7 @@ jobs:
           # pinned to the exact client pyproject declares and the provisioning path was validated
           # against: deploy behaviour (app lifecycle, tags, lookup) is client-version sensitive, so
           # an unbounded range lets a future release change deploys with no diff here.
-          python -m pip install "modal==1.5.4" "python-dotenv==1.2.3"
+          python -m pip install "modal==1.6.1" "python-dotenv==1.2.3"
 
       - name: Verify Modal auth is configured
         if: steps.gate.outputs.deploy == 'true'
@@ -198,7 +200,7 @@ jobs:
           if [ -z "$SUPABASE_SERVICE_ROLE_KEY" ]; then
             missing="$missing SUPABASE_SERVICE_ROLE_KEY"
           fi
-          required="FREESOLO_INTERNAL_KEY PLATFORM_BACKEND_URL"
+          required="FREESOLO_INTERNAL_KEY PLATFORM_BACKEND_URL SERVING_CANARY_ORG_ID"
           for name in $required; do
             # indirect expansion: the secrets are exported into the env via the job-level `env:` block.
             if [ -z "${!name}" ]; then
@@ -206,10 +208,21 @@ jobs:
             fi
           done
           if [ -n "$missing" ]; then
-            echo "::error::Refusing to deploy serving to prod: missing required secret(s):${missing}. Set them in repo Settings -> Secrets and variables -> Actions."
+            echo "::error::Refusing to deploy serving to prod: missing required setting(s):${missing}. Set them in repo Settings -> Secrets and variables -> Actions."
             exit 1
           fi
-          echo "All required serving runtime secrets are present."
+          # reject malformed attribution before replacing the live app.
+          python - <<'PY'
+          import os
+          import sys
+          import uuid
+
+          try:
+              uuid.UUID(os.environ["SERVING_CANARY_ORG_ID"].strip())
+          except ValueError:
+              sys.exit("::error::SERVING_CANARY_ORG_ID must be an existing internal organization UUID.")
+          PY
+          echo "All required serving runtime secrets and canary settings are present."
 
       - name: Wait for production adapter schema readiness
         if: steps.gate.outputs.deploy == 'true'
@@ -411,6 +424,7 @@ jobs:
           # durably. this step is the only thing standing between "the process booted" and "the
           # release can actually serve", so a failure here must not be promoted.
           SERVING_BASE_URL: https://serve.freesolo.co
+          SERVING_CANARY_ORG_ID: ${{ vars.SERVING_CANARY_ORG_ID }}
           FREESOLO_INTERNAL_KEY: ${{ secrets.FREESOLO_INTERNAL_KEY }}
           SUPABASE_URL: ${{ secrets.SUPABASE_URL }}
           SUPABASE_SERVICE_ROLE_KEY: ${{ secrets.SUPABASE_SERVICE_ROLE_KEY }}
@@ -456,10 +470,20 @@ jobs:
           echo "Promotion failed; restoring ${PREVIOUS_SHA}."
           git checkout --quiet --force "$PREVIOUS_SHA"
 
+          # resolve the entrypoint in the restored tree, including releases before the source move.
+          if [ -f flash/serving/app/modal_app.py ]; then
+            rollback_app=flash/serving/app/modal_app.py
+          elif [ -f flash/serving/modal_app.py ]; then
+            rollback_app=flash/serving/modal_app.py
+          else
+            echo "::error::Previous release has no supported serving entrypoint. Restore production manually."
+            exit 1
+          fi
+
           # the restored app must report the RESTORED sha, deployed from the restored tree.
           FREESOLO_DEPLOYMENT_SHA="$PREVIOUS_SHA" \
           FREESOLO_DEPLOYMENT_ID="$ROLLBACK_DEPLOYMENT_ID" \
-            modal deploy flash/serving/app/modal_app.py
+            modal deploy "$rollback_app"
 
           response_file="$(mktemp)"
           trap 'rm -f "$response_file"' EXIT

{freesolo_flash_dev-1.2.132 → freesolo_flash_dev-1.2.134}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.2.132
+Version: 1.2.134
 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.134/flash/adapters/config.py

@@ -0,0 +1,136 @@
+"""one strict reader for the bytes of an ``adapter_config.json``.
+
+Three boundaries admit an adapter by reading this one file, and all three are gated on the same
+question: do these exact bytes describe a LoRA adapter that the engine about to load them can
+actually serve? Answering it separately let them drift -- customer-owned resolution rejected a
+config that hosted admission accepted, so the same artifact was refused before provisioning on one
+path and refused inside the paid container on the other.
+
+Every rule here is decidable from the config alone. Nothing in this module reads the hub, the
+filesystem, or a provider, so a verdict costs a caller nothing beyond the bytes it already holds.
+That is why it sits beside the rank and target rules rather than under a deployment path: the
+GPU-side materializer revalidates a cache entry it already holds, and it needs the same verdict
+without importing anything that resolves or deploys.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+from flash.adapters.lora_rank import rank_from_adapter_config
+from flash.serve.contract.protocol import reject_non_finite_json_constant
+
+
+class AdapterConfigError(ValueError):
+    """these ``adapter_config.json`` bytes cannot describe a servable LoRA adapter."""
+
+
+@dataclass(frozen=True)
+class DeclaredAdapterConfig:
+    """what an adapter stamps about itself, after every deterministic rule has passed."""
+
+    config: dict[str, Any]
+    lora_rank: int
+    base_model: str
+    base_revision: str | None
+
+
+class _DuplicateConfigKey(AdapterConfigError):
+    """raised through ``json.loads``, so it stays a ValueError for any caller expecting one."""
+
+
+def parse_declared_adapter_config(raw: bytes, *, source: str) -> DeclaredAdapterConfig:
+    """read one adapter's declared provenance, or refuse the bytes.
+
+    ``source`` names the file in every message, so a caller that fetched the config from the hub and
+    one that read it off disk both report a location the reader can go look at.
+    """
+
+    config = _strict_object(raw, source=source)
+    try:
+        rank = rank_from_adapter_config(config, source=source)
+    except ValueError as exc:
+        raise AdapterConfigError(f"{source} declares no usable lora rank: {exc}") from exc
+
+    peft_type = config.get("peft_type")
+    if peft_type != "LORA":
+        raise AdapterConfigError(f"{source} peft_type must be LORA, not {peft_type!r}")
+    task_type = config.get("task_type")
+    if task_type not in {None, "CAUSAL_LM"}:
+        raise AdapterConfigError(
+            f"{source} task_type must be absent or CAUSAL_LM, not {task_type!r}"
+        )
+    modules_to_save = config.get("modules_to_save")
+    if modules_to_save is not None and modules_to_save != []:
+        raise AdapterConfigError(f"{source} modules_to_save adapters are not supported")
+
+    # the engine compares `base_model_name_or_path` for equality, so an absent, empty, or
+    # non-string one can never match and the deployment is already doomed. skipping the check
+    # instead deferred a certain failure until after a provider had allocated and started billing.
+    base_model = _text(config, "base_model_name_or_path", source=source)
+    if base_model is None:
+        raise AdapterConfigError(f"{source} declares no base_model_name_or_path")
+    revision = config.get("revision")
+    if revision is not None and not isinstance(revision, str):
+        raise AdapterConfigError(f"{source} revision must be a string when present")
+    return DeclaredAdapterConfig(
+        config=config,
+        lora_rank=rank,
+        base_model=base_model,
+        base_revision=_text(config, "revision", source=source),
+    )
+
+
+def _strict_object(raw: bytes, *, source: str) -> dict[str, Any]:
+    """decode exactly the way the gpu-side materializer does, from the same bytes.
+
+    handing the bytes straight to ``json.load`` instead lets it auto-detect utf-16 and accept a bom
+    (rfc 4627), so a config the container refuses outright parsed cleanly at admission -- and the
+    deployment failed only after the provider resources had been allocated. duplicate keys are the
+    same case: plain decoding takes the last value, so a config declaring ``r`` twice would be
+    admitted against one rank and then rejected inside the container this check exists to avoid
+    paying for.
+    """
+
+    try:
+        config = json.loads(
+            raw.decode("utf-8"),
+            object_pairs_hook=_reject_duplicate_keys,
+            parse_constant=reject_non_finite_json_constant,
+        )
+    except _DuplicateConfigKey as exc:
+        raise AdapterConfigError(f"{source} contains a duplicate key") from exc
+    except (UnicodeDecodeError, ValueError) as exc:
+        raise AdapterConfigError(f"{source} is not readable json") from exc
+    if not isinstance(config, dict):
+        raise AdapterConfigError(f"{source} must be a json object")
+    return config
+
+
+def _reject_duplicate_keys(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for key, value in pairs:
+        if key in result:
+            raise _DuplicateConfigKey(f"{key!r} appears twice")
+        result[key] = value
+    return result
+
+
+def _text(config: dict[str, Any], key: str, *, source: str) -> str | None:
+    """read a config string exactly as the engine will compare it.
+
+    the engine compares these raw bytes for equality, so a value that matches only after stripping
+    is admitted here and then rejected inside the paid container -- the outcome this reader exists
+    to prevent. normalizing the padding away instead would be worse for ``revision``, which the
+    resolver *adopts* into the immutable manifest: that would launder a padded string into the record
+    rather than surface it. rejecting keeps the admission-time and container-time verdicts identical.
+    """
+
+    value = config.get(key)
+    if not isinstance(value, str):
+        return None
+    if value != value.strip():
+        raise AdapterConfigError(f"{source} {key} has surrounding whitespace: {value!r}")
+    return value or None

{freesolo_flash_dev-1.2.132 → freesolo_flash_dev-1.2.134}/flash/core/spec.py

@@ -20,7 +20,6 @@ detail. See their docstrings before changing either.
 from __future__ import annotations
 
 import json
-import math
 import os
 from dataclasses import asdict, dataclass, field, fields
 from typing import Any, Literal
@@ -366,9 +365,6 @@ class TrainSpec:
     hf_repo: str = ""
     # None -> worker's tuned recipe default.
     learning_rate: float | None = field(default=None, metadata={"introduced_in": "0.2.0"})
-    # sft only: none preserves a legacy persisted run's 16x optimizer. new configs freeze the
-    # recipe default at parse time; 1 uses equal adapter learning rates.
-    loraplus_ratio: float | None = field(default=None, metadata={"introduced_in": "1.2.131"})
     # sft only. the packaged-dataset estimate resolves this against the selected row count into
     # examples_per_update (packed) or pins the optimizer batch to 1 (unpacked). grpo/opd have no
     # profile, so they take prompts_per_step instead and reject this key: the two are not the same
@@ -403,17 +399,6 @@ class TrainSpec:
     )
 
     def __post_init__(self) -> None:
-        if self.loraplus_ratio is not None:
-            ratio = self.loraplus_ratio
-            if isinstance(ratio, bool) or not isinstance(ratio, (int, float)):
-                raise TypeError("train.loraplus_ratio must be a number")
-            try:
-                ratio = float(ratio)
-            except OverflowError as exc:
-                raise ValueError("train.loraplus_ratio must be a finite number >= 1") from exc
-            if not math.isfinite(ratio) or ratio < 1:
-                raise ValueError("train.loraplus_ratio must be a finite number >= 1")
-            object.__setattr__(self, "loraplus_ratio", ratio)
         if not self.lora_alpha:
             object.__setattr__(self, "lora_alpha", 2 * self.lora_rank)
         max_steps = parse_max_steps(self.max_steps)
@@ -581,8 +566,6 @@ class JobSpec:
     project: str = ""
 
     def __post_init__(self) -> None:
-        if self.train.loraplus_ratio is not None and self.algorithm != "sft":
-            raise ValueError("train.loraplus_ratio only applies to sft")
         object.__setattr__(self, "seed", parse_seed(self.seed))
         object.__setattr__(self, "model_revision", _model_revision(self.model_revision))
         for field_name in ("model_revision_auto", "model_revision_force_pin"):
@@ -698,9 +681,6 @@ class JobSpec:
         differently, so removing either pop would break existing digests.
         """
         data = asdict(self)
-        # preserve historical preparation digests when the new option was not authored.
-        if data["train"]["loraplus_ratio"] is None:
-            data["train"].pop("loraplus_ratio")
         # missing and unset are the same internal state. omitting the empty value preserves that state
         # without serializing it into an explicit empty preference, which every parser rejects.
         if not data["gpu"].get("providers"):
@@ -806,7 +786,6 @@ class JobSpec:
                 init_from_adapter_revision=str(train.get("init_from_adapter_revision") or ""),
                 hf_repo=str(train.get("hf_repo") or ""),
                 learning_rate=opt_float(train.get("learning_rate")),
-                loraplus_ratio=train.get("loraplus_ratio"),
                 batch_size=opt_int(train.get("batch_size")),
                 prompts_per_step=opt_int(train.get("prompts_per_step")),
                 max_context_tokens=opt_int(train.get("max_context_tokens")),

{freesolo_flash_dev-1.2.132 → freesolo_flash_dev-1.2.134}/flash/engine/plan/recipe.py

@@ -170,7 +170,6 @@ class SFTConfig:
     max_seq_len: int = 1024
     max_seq_len_thinking: int = 2048
     learning_rate: float = 1e-4
-    loraplus_ratio: float = 1.0
     warmup_frac: float = 0.03
     effective_batch: int = 32
     num_epochs: int = 2

{freesolo_flash_dev-1.2.132 → freesolo_flash_dev-1.2.134}/flash/engine/profiling/dataset_profile.py

@@ -189,96 +189,64 @@ def _selected_dataset_path(base_dir: Path, params: dict[str, Any]) -> Path:
     )
 
 
-def _read_jsonl_rows(path: Path, *, max_examples: int) -> tuple[int, list[dict[str, Any]]]:
-    source_examples = 0
-    values = []
-    missing = []
-    with path.open(encoding="utf-8") as handle:
-        for line in handle:
-            if not line.strip():
-                continue
-            row = json.loads(line)
-            if not isinstance(row, dict):
-                raise TypeError("dataset row is not an object")
-            if _CANONICAL_INPUT_KEY not in row and len(missing) < 10:
-                missing.append(source_examples)
-            source_examples += 1
-            if max_examples <= 0 or len(values) < max_examples:
-                values.append(row)
-    if missing:
-        raise ValueError(
-            "Freesolo dataset records must contain an input field; missing at row indexes "
-            f"{missing}"
-        )
-    return source_examples, values
-
-
 def _validate_dataset_rows(
     values: object,
     *,
     invalid_message: str,
-    empty_message: str,
     max_examples: int,
+    empty_message: str | None = None,
 ) -> tuple[int, list[dict[str, Any]]]:
     if not isinstance(values, list) or not all(isinstance(row, dict) for row in values):
         raise PackagedDatasetUnavailable(invalid_message)
-    source_examples = len(values)
-    missing = [index for index, row in enumerate(values) if _CANONICAL_INPUT_KEY not in row]
+    rows = values
+    source_examples = len(rows)
+    missing = [
+        index
+        for index, row in enumerate(rows)
+        if _CANONICAL_INPUT_KEY not in row or row.get(_CANONICAL_INPUT_KEY) is None
+    ]
     if missing:
         raise ValueError(
             "Freesolo dataset records must contain an input field; missing at row indexes "
             f"{missing[:10]}"
         )
-    selected = values[:max_examples] if max_examples > 0 else values
-    if not selected:
+    selected = rows[:max_examples] if max_examples > 0 else rows
+    if not selected and empty_message is not None:
         raise PackagedDatasetUnavailable(empty_message)
     return source_examples, [dict(row) for row in selected]
 
 
 def _read_dataset_rows(path: Path, *, max_examples: int) -> tuple[int, list[dict[str, Any]]]:
+    from freesolo.datasets.records import load_records
+
+    invalid_message = (
+        f"environment dataset file {path.name!r} must contain JSON object or string rows. Add a "
+        "valid dataset/train.jsonl to the environment package."
+    )
     try:
         if path.stat().st_size > _MAX_PROFILE_DATASET_BYTES:
             raise PackagedDatasetUnavailable(
                 f"environment dataset file {path.name!r} exceeds the 32 MiB control-plane profiling "
                 "limit. Reduce the packaged training dataset."
             )
-        if path.suffix.lower() == ".jsonl":
-            source_examples, values = _read_jsonl_rows(path, max_examples=max_examples)
-        elif path.suffix.lower() == ".json":
-            loaded = json.loads(path.read_text(encoding="utf-8"))
-            values = loaded.get("records") if isinstance(loaded, dict) else loaded
-            source_examples, values = _validate_dataset_rows(
-                values,
-                invalid_message=(
-                    f"environment dataset file {path.name!r} must contain JSON object rows. Add a "
-                    "valid dataset/train.jsonl to the environment package."
-                ),
-                empty_message=(
-                    f"environment dataset file {path.name!r} contains no rows. Add training rows to "
-                    "dataset/train.jsonl in the environment package."
-                ),
-                max_examples=max_examples,
-            )
-        else:
-            raise ValueError("dataset file must end in .jsonl or .json")
+        if path.suffix.lower() not in {".jsonl", ".json"}:
+            raise PackagedDatasetUnavailable("dataset file must end in .jsonl or .json")
+        # use the worker's decoder; it materializes all rows before profiling selects a prefix.
+        rows = load_records(path)
     except PackagedDatasetUnavailable:
         raise
-    except TypeError as exc:
-        raise PackagedDatasetUnavailable(
-            f"environment dataset file {path.name!r} must contain JSON object rows. Add a valid "
-            "dataset/train.jsonl to the environment package."
-        ) from exc
     except (OSError, UnicodeError, json.JSONDecodeError) as exc:
         raise PackagedDatasetUnavailable(
             f"environment dataset file {path.name!r} is not readable JSON. Add a valid "
             "dataset/train.jsonl to the environment package."
         ) from exc
-    if not values:
-        raise PackagedDatasetUnavailable(
-            f"environment dataset file {path.name!r} contains no rows. Add training rows to "
-            "dataset/train.jsonl in the environment package."
-        )
-    return source_examples, [dict(row) for row in values]
+    except (TypeError, ValueError) as exc:
+        raise PackagedDatasetUnavailable(invalid_message) from exc
+    return _validate_dataset_rows(
+        rows,
+        invalid_message=invalid_message,
+        max_examples=max_examples,
+    )
 
 
 def profile_packaged_sft_dataset(

{freesolo_flash_dev-1.2.132 → freesolo_flash_dev-1.2.134}/flash/engine/support/verl_checkpoint.py

@@ -8,7 +8,6 @@ from collections.abc import Iterable
 from dataclasses import dataclass
 
 from flash._internal.fileio import reject_duplicate_keys
-from flash.engine.support.verl_policy import FsdpGeneration
 
 VERL_FSDP_CONFIG_FILE = "fsdp_config.json"
 _MAX_NATIVE_FSDP_WORLD_SIZE = 8
@@ -78,7 +77,6 @@ def inspect_fsdp_checkpoint_manifest(
     stamp_raw: bytes | str | None,
     files: Iterable[FsdpManifestFile],
     *,
-    expected_generation: FsdpGeneration,
     expected_world_size: int | None,
 ) -> FsdpCheckpointInspection:
     """validate the exact canonical native shard set for one stamped actor directory."""
@@ -90,13 +88,11 @@ def inspect_fsdp_checkpoint_manifest(
             rejection_reason="invalid or missing fsdp stamp",
         )
     generation, width = stamp
-    if generation != expected_generation:
+    if generation != 2:
         return FsdpCheckpointInspection(
             loadable=False,
             width=width,
-            rejection_reason=(
-                f"fsdp generation mismatch (stamped {generation}, expected {expected_generation})"
-            ),
+            rejection_reason=f"fsdp generation mismatch (stamped {generation}, expected 2)",
         )
     if expected_world_size is not None and width != expected_world_size:
         return FsdpCheckpointInspection(

{freesolo_flash_dev-1.2.132 → freesolo_flash_dev-1.2.134}/flash/engine/worker/train/entry/opd_train_runner.py

@@ -28,7 +28,6 @@ from flash.engine.plan import steps as _steps
 from flash.engine.plan.recipe import RECIPE
 from flash.engine.plan.steps import rl_data_parallel_cards
 from flash.engine.profiling.sft_workload import _materialize_verl_images
-from flash.engine.support.verl_policy import _resolve_fsdp_generation
 from flash.engine.worker.entry import opd as _opd_entry
 from flash.engine.worker.train.core.child.runtime import TEXT_LORA_TARGET_SHIM
 from flash.engine.worker.train.entry.prompt_rows import canonical_prompt_messages
@@ -187,7 +186,6 @@ def _prepare_workload(
     if isinstance(target_modules, set | frozenset):
         target_modules = sorted(target_modules)
     target_parameters = tuple(targeting.target_parameters) if targeting.target_parameters else None
-    fsdp_generation = _resolve_fsdp_generation("opd", target_parameters)
     lora_rank = int(lora_config.r)
     return _WorkloadState(
         prompts_per_step,
@@ -209,7 +207,6 @@ def _prepare_workload(
         int(lora_config.lora_alpha),
         target_modules,
         target_parameters,
-        fsdp_generation,
         targeting.exclude_modules,
         _sft._warmstart_adapter_path(
             request.model_id,
@@ -260,8 +257,6 @@ def _materialize_child_files(
         # the same count this attempt hands verl as n_gpus_per_node, which is the data-parallel
         # width: ulysses is pinned to 1, so every rank is a dp rank.
         world_size=gpu_count,
-        # native state is generation-specific, so use the same resolved policy as the child config.
-        expected_fsdp_generation=workload.fsdp_generation,
     )
     bridge = _opd_bridge._TeacherAlignmentBridge(
         prompts=prompt_state.prompts,
@@ -399,7 +394,6 @@ def _build_base_config(
         "target_modules": workload.target_modules,
         "exclude_modules": None,
         "target_parameters": workload.target_parameters,
-        "fsdp_generation": workload.fsdp_generation,
         "lora_adapter_path": workload.warmstart_adapter,
         "learning_rate": knobs.learning_rate,
         "local_dir": workload.local_dir,

{freesolo_flash_dev-1.2.132 → freesolo_flash_dev-1.2.134}/flash/engine/worker/train/entry/rl_train_runner.py

@@ -309,7 +309,6 @@ def _prepare_rl_files(inp, prompts):
     resume_step = rl_checkpoints._restore_verl_resume(
         local_dir,
         world_size=int(inp["dp_cards"]),
-        expected_fsdp_generation=inp["fsdp_generation"],
         required_steps=tuple(inp["save_at_steps"]),
     )
     train_pq = os.path.join(workdir, "train.parquet")

{freesolo_flash_dev-1.2.132 → freesolo_flash_dev-1.2.134}/flash/engine/worker/train/entry/sft_train.py

@@ -355,8 +355,7 @@ def _sft_liger_config() -> dict[str, bool]:
 
 
 # re-exported so the child-render helpers stay reachable as `sft_train.<name>`: the other
-# trainers import `_hydra_val` from here, and the sft tests import the renderers and the
-# LoRA+ marker from here.
+# trainers import `_hydra_val` from here, and the sft tests import the renderers.
 # the runner resolves patched seams through this parent module at call time, so these imports must
 # remain attributes of `sft_train` rather than direct imports in the split module.
 from flash.engine.plan.recipe import RECIPE  # noqa: E402,F401
@@ -394,7 +393,6 @@ from flash.engine.worker.train.sft.setup.checkpoints import (  # noqa: E402,F401
     _VerlCheckpointWatcher,
 )
 from flash.engine.worker.train.sft.setup.config import (  # noqa: E402,F401
-    _LORAPLUS_READY_MARKER,
     _REQUIRED_OVERRIDE_KEYS,
     _VERL_OPTIMIZER_IMPL,
     _VERL_OPTIMIZER_NAME,
@@ -485,9 +483,6 @@ def _write_sft_result(options, data, model, child, progress, verified, outputs)
             "loss_curve": progress.loss_curve[:400],
             "peak_gpu_gb": device_peak_gpu_gb,
             "device_peak_gpu_gb": device_peak_gpu_gb,
-            "loraplus_optim": _VERL_OPTIMIZER_NAME,
-            "loraplus_applied": progress.loraplus_applied,
-            "loraplus_ratio": options.loraplus_ratio,
             "verl_backend": "fsdp2",
             # sft shards by DATA -- see ULYSSES_SEQUENCE_PARALLEL_SIZE for why. fsdp splits the batch
             # across the ranks actually LAUNCHED, which is the allocated card count only when the
@@ -585,7 +580,7 @@ def run_sft_train(spec=None) -> None:
     child = _prepare_sft_child(
         options, data, model, capabilities, use_remove_padding, gdn_reset_arch
     )
-    child_progress = _prepare_sft_progress(options, data, model, child)
+    child_progress = _prepare_sft_progress(data, model, child)
     progress = child_progress.values
 
     def on_line(line: str) -> None:
@@ -606,7 +601,7 @@ def run_sft_train(spec=None) -> None:
     if child.resume_step < model.update_horizon:
         child.watcher.start()
         # check save completeness only after normal training completion. callback failures occur before
-        # return_code assignment; checking anyway would replace the real zero-grad or lora+ diagnosis
+        # return_code assignment; checking anyway would replace the real zero-grad or runtime-patch diagnosis
         # with a missing-save error. opd_train uses the same guard.
         training_completed = False
         try: