freesolo-flash-dev 0.2.40__tar.gz → 0.2.42__tar.gz

{freesolo_flash_dev-0.2.40 → freesolo_flash_dev-0.2.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freesolo-flash-dev
-Version: 0.2.40
+Version: 0.2.42
 Summary: Flash — managed LoRA post-training (SFT/GRPO) 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-0.2.40 → freesolo_flash_dev-0.2.42}/flash/catalog.py

@@ -12,7 +12,7 @@ ALGORITHMS = ("sft", "grpo")
 def normalize_algorithm(value: str) -> str:
     """Canonical (lowercased, validated) algorithm name."""
     if not value:
-        value = "grpo"
+        value = "sft"
     elif not isinstance(value, str):
         # A truthy non-string (e.g. a JSON number/bool/array) would AttributeError on .lower(), which
         # escapes the callers' ValueError/ConfigError guards -> uncaught 500. Raise ValueError instead.
@@ -95,6 +95,16 @@ class ModelInfo:
     num_layers: int = 0
     hidden_size: int = 0
 
+    @property
+    def is_moe(self) -> bool:
+        """True for a mixture-of-experts model — a token routes through only a subset of experts.
+
+        Keyed off ``active_params_b`` (0.0 == dense, "every token hits every param"). Used by the
+        GRPO worker to pick REENTRANT gradient checkpointing for MoE (its router re-dispatches tokens
+        on recompute, which the non-reentrant metadata-equality assert rejects).
+        """
+        return 0.0 < self.active_params_b < self.params_b
+
     def to_dict(self) -> dict[str, Any]:
         data = asdict(self)
         serving = data.get("serving")
@@ -263,9 +273,15 @@ MODELS: dict[str, ModelInfo] = {
             # rank-64 at only 6 hot slots: the fused-MoE LoRA buffer scales with
             # max_loras x rank x num_experts, so the A100-80GB ceiling is ~max_loras x rank = 384
             # (6 x 64 fits at 99.3% util; 16 x 64 OOMs on every single/multi GPU). Serving-validated.
+            # The 6 x 64 ceiling is WEIGHT-bound, not context-bound: the FP8 checkpoint's MoE experts
+            # load as bf16 under the LoRA path (~76 GiB on the 80 GiB card), so weights + the 6 x 64
+            # buffer leave only ~0.44 GiB for KV. Canary-measured 2026-07-04: at 8192 ctx that KV pool
+            # gives 2.2x concurrency; dropping to 4096 does NOT free any LoRA-slot room (7 x 64 and
+            # 8 x 64 both OOM at 4096 exactly as at 8192) but ~doubles concurrency to ~4.4x. So context
+            # is 4096 (concurrency win, matches the training-context cap) while slots stay 6 x 64.
             max_loras=6,
             max_lora_rank=64,
-            max_model_len=8192,
+            max_model_len=4096,
             max_num_seqs=8,
             max_num_batched_tokens=4096,
             gpu_memory_utilization=0.98,
@@ -313,6 +329,26 @@ def serving_lora_rank_cap(model: str | ModelInfo | None) -> int | None:
     return int(info.serving.max_lora_rank)
 
 
+def serving_context_cap(model: str | ModelInfo | None) -> int | None:
+    """Return the model's serving ``max_model_len`` (the context it is actually served at), or None
+    when Flash has no local serving entry (open-policy / uncataloged).
+
+    A LoRA trained at a longer context than it is served wastes compute and learns positions that are
+    never used at inference, so the control plane caps a run's training context to this (see
+    ``flash.lora_rank.preflight_train_context_within_serving``). Resolution mirrors
+    ``serving_lora_rank_cap``: unknown/open-policy models return None rather than a global fallback.
+    """
+    if isinstance(model, ModelInfo):
+        info = model
+    elif isinstance(model, str) and model.strip():
+        info = MODELS.get(model.strip())
+    else:
+        info = None
+    if info is None or info.serving is None:
+        return None
+    return int(info.serving.max_model_len)
+
+
 def vocab_size_for(model_id: str) -> int:
     """Curated vocab_size for a model, or the safe default for open-model-policy entries."""
     info = MODELS.get(model_id)

{freesolo_flash_dev-0.2.40 → freesolo_flash_dev-0.2.42}/flash/cli/__init__.py

@@ -168,7 +168,7 @@ class _FlashParser(_ThemedParser):
         footers = [
             f"new here? run `{CLI_NAME} login`, then `{CLI_NAME} env setup`",
             f"train after publishing: `{CLI_NAME} env push --name my-env .`, "
-            f"then `{CLI_NAME} train configs/rl.toml`",
+            f"then `{CLI_NAME} train configs/sft.toml`",
             f"any command in depth: `{CLI_NAME} <command> --help`",
             "docs: https://freesolo.co/docs",
         ]
@@ -234,7 +234,46 @@ def _build_parser() -> argparse.ArgumentParser:
     env = sub.add_parser("env", help="manage Freesolo environments")
     env_sub = env.add_subparsers(dest="env_cmd", required=True)
     setup = env_sub.add_parser("setup", help="create a starter Freesolo environment scaffold")
-    setup.set_defaults(func=cmd_env_setup)
+    setup_mode = setup.add_mutually_exclusive_group()
+    setup_mode.add_argument(
+        "--single-turn",
+        dest="turn_mode",
+        action="store_const",
+        const="single",
+        help="scaffold a single-turn environment (prompt -> one response). This is the default.",
+    )
+    setup_mode.add_argument(
+        "--multi-turn",
+        dest="turn_mode",
+        action="store_const",
+        const="multi",
+        help="scaffold a multi-turn environment (bounded episode with step_episode / score_episode).",
+    )
+    setup_reason = setup.add_mutually_exclusive_group()
+    setup_reason.add_argument(
+        "--reasoning",
+        dest="reasoning",
+        action="store_const",
+        const=True,
+        help="scaffold configs with reasoning enabled (thinking = true, with a raised token budget).",
+    )
+    setup_reason.add_argument(
+        "--no-reasoning",
+        dest="reasoning",
+        action="store_const",
+        const=False,
+        help="scaffold configs without reasoning. This is the default.",
+    )
+    setup.add_argument(
+        "-y",
+        "--yes",
+        dest="yes",
+        action="store_true",
+        help="accept defaults without prompting (single-turn, no reasoning).",
+    )
+    # turn_mode / reasoning default to None (unset) so the scaffold can tell an explicit flag
+    # apart from "not chosen yet" and, on an interactive terminal, ask instead of assuming.
+    setup.set_defaults(func=cmd_env_setup, turn_mode=None, reasoning=None, yes=False)
 
     env_list = env_sub.add_parser("list", help="list local environment sources")
     env_list.set_defaults(func=cmd_env_list)

{freesolo_flash_dev-0.2.40 → freesolo_flash_dev-0.2.42}/flash/cli/commands.py

@@ -193,15 +193,247 @@ _STARTER_DATASET_JSONL = """\
 """
 
 
+_STARTER_ENV_MULTITURN_PY = '''\
+"""Starter Freesolo multi-turn environment.
+
+A multi-turn environment runs a bounded episode: the model produces an assistant
+action, `step_episode` advances the world (optionally appending an observation
+message), and the loop repeats until `done` or `max_episode_turns`. The finished
+transcript is graded by `score_episode`.
+
+Edit dataset/train.jsonl and the episode logic, then upload with
+`flash env push --name my-env .`.
+
+A managed run should use the returned [environment] id from
+`flash env push --name my-env .`.
+
+This starter implements a tiny "guess the secret number" game so you can see the
+episode hooks wired end-to-end. Replace it with your real task before a real run.
+
+Both SFT and GRPO train off this file:
+- GRPO (configs/rl.toml) rolls out full episodes and optimizes `score_episode`.
+- SFT (configs/sft.toml) learns the gold trajectory. Provide it per row as
+  `output = {"messages": [...]}` (a full assistant/tool trajectory) or a scalar
+  `output` for a single gold assistant turn.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from freesolo.datasets.types import TaskExample
+from freesolo.environments import (
+    EnvironmentEpisode,
+    EnvironmentMultiTurn,
+    EnvironmentStepResult,
+    RewardResult,
+)
+
+
+DEFAULT_DATASET_PATH = Path(__file__).parent / "dataset" / "train.jsonl"
+
+# How many assistant guesses the model gets before the episode is forced terminal.
+MAX_TURNS = 5
+
+
+def load_jsonl(path: str | Path):
+    rows = []
+    with Path(path).open() as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                rows.append(json.loads(line))
+    return rows
+
+
+def _secret(example: TaskExample) -> int:
+    return int(str(example.output).strip())
+
+
+class StarterMultiTurnEnv(EnvironmentMultiTurn):
+    dataset = load_jsonl(DEFAULT_DATASET_PATH)
+
+    def start_episode(self, example: TaskExample, prompt_text: str):
+        # The opening prompt shown to the model. `example.input` describes the range.
+        return [
+            {
+                "role": "user",
+                "content": (
+                    f"{example.input}\\n"
+                    f"Reply with a single integer per turn. I will say 'higher', "
+                    f"'lower', or 'correct'. You have {MAX_TURNS} guesses."
+                ),
+            }
+        ]
+
+    def max_episode_turns(self, example: TaskExample) -> int:
+        return MAX_TURNS
+
+    def step_episode(
+        self,
+        example: TaskExample,
+        messages: list,
+        assistant_response: str,
+    ) -> EnvironmentStepResult:
+        # Advance the world after one assistant action. Return done=True to end the
+        # episode, or append an observation message and keep going.
+        try:
+            guess = int(assistant_response.strip().split()[0])
+        except (ValueError, IndexError):
+            return EnvironmentStepResult(
+                done=False,
+                messages=[{"role": "user", "content": "Please reply with a single integer."}],
+            )
+        secret = _secret(example)
+        if guess == secret:
+            return EnvironmentStepResult(done=True, final_response_text=str(guess))
+        hint = "higher" if guess < secret else "lower"
+        return EnvironmentStepResult(
+            done=False,
+            messages=[{"role": "user", "content": hint}],
+        )
+
+    def score_episode(
+        self,
+        example: TaskExample,
+        episode: EnvironmentEpisode,
+    ) -> RewardResult:
+        # Grade the finished transcript. Reward a correct final guess; give partial
+        # credit for getting close so GRPO has a usable gradient.
+        secret = _secret(example)
+        try:
+            final = int(str(episode.response_text).strip())
+        except ValueError:
+            return RewardResult(score=0.0, threshold=1.0)
+        if final == secret:
+            return RewardResult(score=1.0, threshold=1.0, success=True)
+        # Closeness in [0, 1): further guesses score lower.
+        closeness = max(0.0, 1.0 - abs(final - secret) / 100.0)
+        return RewardResult(score=closeness * 0.5, threshold=1.0, success=False)
+
+
+def load_environment(dataset_path: str | None = None, **kwargs) -> StarterMultiTurnEnv:
+    env = StarterMultiTurnEnv()
+    if dataset_path:
+        env.dataset = load_jsonl(dataset_path)
+    return env
+'''
+
+
+# Multi-turn rows: `input` sets up the episode, `output` is the secret number.
+# The scalar `output` also serves as the gold single-turn SFT target; swap in
+# `{"messages": [...]}` to teach a full gold trajectory.
+_STARTER_DATASET_MULTITURN_JSONL = """\
+{"input":"I picked a secret whole number between 1 and 100.","output":"42"}
+{"input":"I picked a secret whole number between 1 and 100.","output":"73"}
+"""
+
+
+_TURN_OPTIONS = [
+    ("single", "single-turn", "one prompt -> one response"),
+    ("multi", "multi-turn", "bounded episode: step_episode / score_episode"),
+]
+_REASONING_OPTIONS = [
+    ("off", "no reasoning", "the model answers directly"),
+    ("on", "reasoning", "thinking = true; spends more tokens per answer"),
+]
+
+
+def _setup_interactive(args) -> bool:
+    """Whether to ask the setup questions interactively.
+
+    Prompt only on a real terminal a human can answer from. Fall back to defaults (no prompt) when
+    --yes is passed, under CI, or when stdin is closed/redirected, so automation never blocks on an
+    unanswered prompt. A pseudo-TTY in CI can report isatty()=True, so CI is checked explicitly; a
+    closed fd 0 can make sys.stdin None, so that is guarded before .isatty()."""
+    if getattr(args, "yes", False):
+        return False
+    if os.environ.get("CI", "").strip().lower() not in ("", "0", "false", "no"):
+        return False
+    stdin = sys.stdin
+    if stdin is None or not stdin.isatty():
+        return False
+    return render.styled()
+
+
 def cmd_env_setup(args) -> int:
+    starter_env = Path("environment.py")
+    dataset = Path("dataset/train.jsonl")
+    # An existing environment.py is the authoritative signal for which turn mode this
+    # scaffold already uses (the dataset is plain JSONL with no reliable mode marker).
+    # Anchor to it so a re-run never leaves a single-turn env beside a multi-turn
+    # dataset (or vice versa); the flag/answer only decides the mode when starting fresh.
+    existing_multi: bool | None = None
+    anchor = "environment.py"
+    if starter_env.exists():
+        existing_multi = "EnvironmentMultiTurn" in starter_env.read_text(encoding="utf-8")
+    elif dataset.exists():
+        # No env.py to anchor on, but the starter multi-turn dataset carries a
+        # distinctive prompt; use it so we don't drop a single-turn env beside it.
+        existing_multi = "secret whole number" in dataset.read_text(encoding="utf-8")
+        anchor = "dataset/train.jsonl"
+
+    # Resolve the turn mode. An existing scaffold wins (warn if a flag disagrees); otherwise an
+    # explicit --single-turn/--multi-turn flag wins; otherwise ask on a terminal, else single-turn.
+    flag_mode = getattr(args, "turn_mode", None)
+    if existing_multi is not None:
+        if flag_mode is not None and (flag_mode == "multi") != existing_multi:
+            have = "multi-turn" if existing_multi else "single-turn"
+            want = "multi-turn" if flag_mode == "multi" else "single-turn"
+            msg = (
+                f"existing {anchor} is {have}; keeping it and ignoring --{want}. "
+                f"Delete environment.py and dataset/train.jsonl first to re-scaffold as {want}."
+            )
+            print(render.warn(msg) if render.styled() else f"warning: {msg}", file=sys.stderr)
+        multi_turn = existing_multi
+    elif flag_mode is not None:
+        multi_turn = flag_mode == "multi"
+    elif _setup_interactive(args):
+        multi_turn = (
+            render.select("How does the model interact with your task?", _TURN_OPTIONS) == "multi"
+        )
+    else:
+        multi_turn = False
+
+    # Resolve reasoning. Like the turn mode, an existing config is authoritative: configs are only
+    # written when absent, so applying a reasoning flag to an already-scaffolded project would
+    # silently no-op (or write one config with reasoning and leave the other without). Anchor to the
+    # existing config's `thinking` state and warn if a flag disagrees; otherwise the flag wins;
+    # otherwise ask on a terminal; else off.
+    rl = Path("configs/rl.toml")
+    sft = Path("configs/sft.toml")
+    existing_reasoning: bool | None = None
+    for cfg in (rl, sft):
+        if cfg.exists():
+            existing_reasoning = "thinking = true" in cfg.read_text(encoding="utf-8")
+            break
+    flag_reason = getattr(args, "reasoning", None)
+    if existing_reasoning is not None:
+        if flag_reason is not None and flag_reason != existing_reasoning:
+            have = "reasoning" if existing_reasoning else "no reasoning"
+            want = "reasoning" if flag_reason else "no-reasoning"
+            msg = (
+                f"existing configs are {have}; keeping them and ignoring --{want}. "
+                f"Delete configs/rl.toml and configs/sft.toml first to re-scaffold with --{want}."
+            )
+            print(render.warn(msg) if render.styled() else f"warning: {msg}", file=sys.stderr)
+        reasoning = existing_reasoning
+    elif flag_reason is not None:
+        reasoning = flag_reason
+    elif _setup_interactive(args):
+        reasoning = render.select("Train with reasoning (thinking)?", _REASONING_OPTIONS) == "on"
+    else:
+        reasoning = False
+
+    env_py = _STARTER_ENV_MULTITURN_PY if multi_turn else _STARTER_ENV_PY
+    dataset_jsonl = _STARTER_DATASET_MULTITURN_JSONL if multi_turn else _STARTER_DATASET_JSONL
     Path("configs").mkdir(exist_ok=True)
     Path("dataset").mkdir(exist_ok=True)
-    dataset = Path("dataset/train.jsonl")
     if not dataset.exists():
-        dataset.write_text(_STARTER_DATASET_JSONL)
-    starter_env = Path("environment.py")
+        dataset.write_text(dataset_jsonl)
     if not starter_env.exists():
-        starter_env.write_text(_STARTER_ENV_PY)
+        starter_env.write_text(env_py)
     env_comment = (
         "# Environment: upload this project folder with\n"
         "# `flash env push --name my-env .`, then paste the returned id below.\n"
@@ -211,27 +443,47 @@ def cmd_env_setup(args) -> int:
         'id = ""\n\n'
         '# secrets = ["SERPAPI_API_KEY"]\n\n'
     )
-    rl = Path("configs/rl.toml")
+    # `thinking = true` opts the run into reasoning mode. Reasoning shares the generation budget with
+    # the answer, so GRPO also gets a raised max_tokens. These strings are empty when reasoning is
+    # off, keeping the default scaffold byte-for-byte identical.
+    thinking_line = "thinking = true\n" if reasoning else ""
+    rl_reasoning_train = (
+        "max_tokens = 2048  # reasoning shares this budget with the answer; raised so it isn't truncated\n"
+        if reasoning
+        else ""
+    )
+    sft_reasoning_note = (
+        "# reasoning is on (thinking = true): each gold `output` must contain a <think>...</think>\n"
+        "# block; validate locally with freesolo.datasets.warn_missing_think_tags before a real run.\n"
+        if reasoning
+        else ""
+    )
     if not rl.exists():
         rl.write_text(
             'model = "Qwen/Qwen3.5-4B"\n'
-            'algorithm = "grpo"\n\n'
+            'algorithm = "grpo"\n'
+            f"{thinking_line}"
+            "\n"
             f"{env_comment}"
             "[train]\n"
             "steps = 150\n"
+            f"{rl_reasoning_train}"
             "lora_rank = 32\n"
             "# GPU and HF artifacts are managed automatically by the platform: the GPU is\n"
             "# the cheapest fitting managed class, and artifacts live in a private environment-scoped repo.\n"
         )
-    sft = Path("configs/sft.toml")
     if not sft.exists():
         sft.write_text(
             'model = "Qwen/Qwen3.5-4B"\n'
-            'algorithm = "sft"\n\n'
+            'algorithm = "sft"\n'
+            f"{thinking_line}"
+            "\n"
             f"{env_comment}"
             "[train]\n"
             "epochs = 1\n"
+            "max_examples = 2  # rows to train on; the starter dataset has 2 (raise as your dataset grows)\n"
             "lora_rank = 32\n"
+            f"{sft_reasoning_note}"
             "# GPU and HF artifacts are managed automatically by the platform: the GPU is\n"
             "# the cheapest fitting managed class, and artifacts live in a private environment-scoped repo.\n"
         )
@@ -242,8 +494,8 @@ def cmd_env_setup(args) -> int:
     scaffolded = [
         "environment.py",
         "dataset/train.jsonl",
-        "configs/rl.toml",
         "configs/sft.toml",
+        "configs/rl.toml",
         "TRAINING.md",
     ]
     if render.styled():
@@ -605,7 +857,9 @@ def cmd_deploy(args) -> int:
                 f"OpenAI-compatible base URL: {openai_base} — point clients at this /v1 base, "
                 "not the bare endpoint (which 404s on /chat/completions)."
             )
-            print(render.arrow(url_note) if render.styled() else f"note: {url_note}", file=sys.stderr)
+            print(
+                render.arrow(url_note) if render.styled() else f"note: {url_note}", file=sys.stderr
+            )
     if dep.get("state") != "dry_run":
         state = dep.get("state", "deploying")
         if state == "failed":

{freesolo_flash_dev-0.2.40 → freesolo_flash_dev-0.2.42}/flash/cli/render.py

@@ -273,6 +273,38 @@ def arrow(msg: str) -> str:
     return _safe(f"{_paint(_glyph('→', '->'), _ACCENT2)} {_dim(msg)}")
 
 
+def select(title: str, options: list[tuple[str, str, str]], default: int = 0) -> str:
+    """Themed single-choice prompt; returns the chosen option's value.
+
+    ``options`` is a list of ``(value, label, hint)``. The default option is marked and taken on
+    an empty answer (enter). Reads via ``input()`` so it is easy to drive in tests; the caller
+    decides *when* to prompt (interactive stdin), so this always prompts when called. On EOF the
+    default is returned so a closed stdin never hangs the scaffold."""
+    q = _paint(_glyph("?", "?"), _ACCENT, "1")
+    print(f"{q} {_bold(_safe(title))}")
+    for i, (_value, label, hint) in enumerate(options):
+        num = _paint(f"{i + 1})", _ACCENT2)
+        lab = _bold(label) if i == default else label
+        tail = f"  {_dim(_safe(hint))}" if hint else ""
+        mark = _paint(" (default)", _GREEN) if i == default else ""
+        print(f"  {num} {_safe(lab)}{tail}{mark}")
+    pointer = _paint(_glyph("›", ">"), _ACCENT2)  # noqa: RUF001 (the glyph is the point)
+    for _ in range(5):
+        try:
+            raw = input(f"{pointer} ").strip()
+        except EOFError:
+            print()
+            return options[default][0]
+        if not raw:
+            return options[default][0]
+        if raw.isdigit():
+            idx = int(raw) - 1
+            if 0 <= idx < len(options):
+                return options[idx][0]
+        print(note(f"enter 1-{len(options)}, or press enter for the default"))
+    return options[default][0]
+
+
 def money(value: float, decimals: int = 4) -> str:
     return _paint(f"${value:.{decimals}f}", _TEAL)
 
@@ -391,7 +423,7 @@ def models_table(rows: list[dict]) -> str:
     """Supported base models — a clean themed list of ids (the CLI lists ids only)."""
     dot = _glyph("•", "-")
     ids = "\n".join(f"  {_paint(dot, _FAINT)} {_paint(r['id'], _ACCENT2)}" for r in rows)
-    foot = arrow("train one with: flash train configs/rl.toml")
+    foot = arrow("train one with: flash train configs/sft.toml")
     return _safe(f"{header('models', 'supported base models')}\n{ids}\n\n{foot}")
 
 
@@ -643,8 +675,8 @@ def env_setup(paths: list[str]) -> str:
     labels = {
         "environment.py": "env entrypoint — edit the reward + prompt",
         "dataset/train.jsonl": "starter training rows",
-        "configs/rl.toml": "GRPO run config",
         "configs/sft.toml": "SFT run config",
+        "configs/rl.toml": "GRPO run config",
         "TRAINING.md": "how to train well — read this first",
     }
     keyw = max(len(p) for p in paths)

{freesolo_flash_dev-0.2.40 → freesolo_flash_dev-0.2.42}/flash/cli/training_doc.py

@@ -40,8 +40,8 @@ flash gpus                           # managed GPU classes with estimated $/hr
 ```text
 environment.py          # the task: how to prompt the model and how to score it
 dataset/train.jsonl     # training rows, one JSON object per line: {"input": ..., "output": ...}
-configs/rl.toml         # a GRPO (RL) run config
 configs/sft.toml        # an SFT run config
+configs/rl.toml         # a GRPO (RL) run config
 TRAINING.md             # this file
 ```
 
@@ -92,7 +92,7 @@ edit to `environment.py` or `dataset/` so the managed run uses your change.
 
 ```toml
 model = "Qwen/Qwen3.5-4B"   # see `flash models`
-algorithm = "grpo"          # "grpo" (RL) or "sft"
+algorithm = "sft"           # "sft" (supervised) or "grpo" (RL)
 # thinking = true           # opt-in reasoning mode, for models that support it
 
 [environment]
@@ -102,10 +102,11 @@ id = "your-org/my-env"      # the id printed by `flash env push`
                                    # never stored in the spec
 
 [train]
-steps = 150                 # GRPO is step-driven; SFT is epoch-driven (epochs = N)
+epochs = 1                  # SFT is epoch-driven; GRPO is step-driven (steps = N)
+max_examples = 2            # rows to train on (the starter dataset has 2)
 lora_rank = 32
 lora_alpha = 64
-# All GRPO/SFT knobs live under [train]. Do not add [grpo] or [sft] tables.
+# All SFT/GRPO knobs live under [train]. Do not add [sft] or [grpo] tables.
 ```
 
 GPU and HF artifacts are **fully managed** — do not pick `gpu.type` or set
@@ -117,10 +118,10 @@ extra.toml` (deep-merge) and `--set key=value` (e.g. `--set train.steps=300`).
 ### 4. Submit
 
 ```bash
-flash train configs/rl.toml --dry-run   # validate the config locally — no GPU, no charge
-flash train configs/rl.toml --cost      # pre-flight USD estimate, then exit
-flash train configs/rl.toml             # submit and follow logs (Ctrl-C detaches)
-flash train configs/rl.toml --background  # submit and return immediately
+flash train configs/sft.toml --dry-run     # validate the config locally — no GPU, no charge
+flash train configs/sft.toml --cost        # pre-flight USD estimate, then exit
+flash train configs/sft.toml               # submit and follow logs (Ctrl-C detaches)
+flash train configs/sft.toml --background  # submit and return immediately
 ```
 
 ### 5. Monitor
@@ -159,9 +160,9 @@ Work in tight, attributable iterations. Each one is a hypothesis:
 1. Reconstruct state — what's the best run so far, and what have you already tried?
 2. Form a hypothesis — pick ONE lever and say WHY it will move the metric.
 3. Change that ONE lever.
-4. Validate locally — `flash train configs/rl.toml --dry-run` (catches config errors
+4. Validate locally — `flash train configs/sft.toml --dry-run` (catches config errors
    for free; a paid run on a broken config or an all-zero reward is wasted budget).
-5. Submit — `flash train configs/rl.toml`.
+5. Submit — `flash train configs/sft.toml`.
 6. Judge — read the metric trend AND a sample of real rollouts (see below).
 7. Keep the best run; revert the change if it didn't beat the noise band. Repeat.
 ```
@@ -181,7 +182,7 @@ different value.
 A run is only evidence of improvement when **all** of these hold:
 
 - [ ] The run reached `done` (confirmed via `flash status <run-id>`), not merely submitted.
-- [ ] The reward trend rose (GRPO `reward_mean`) or the SFT loss fell — **beyond the noise band**, not within it.
+- [ ] The SFT loss fell or the reward trend rose (GRPO `reward_mean`) — **beyond the noise band**, not within it.
 - [ ] You **probed the trained adapter on real inputs** (`flash deploy` + `flash chat`), including cases it should fail — not just the metrics.
 - [ ] The score is real behavior, not empty/truncated/templated outputs, skipped rows, leakage, a swallowed exception, or a format-only win.
 - [ ] If you track a clean success signal separately from the shaped reward (an explicit `RewardMetric`), *that* moved too.
@@ -219,7 +220,7 @@ spending another GPU run:
 ## Judge the run, don't just finish it
 
 - **Judge the trend, not a single number.** The proof of training is the curve:
-  `reward_mean` rising over steps (GRPO) or loss falling (SFT). Record the base/early
+  loss falling (SFT) or `reward_mean` rising over steps (GRPO). Record the base/early
   value and the final value. A flat or noisy trend with no improvement is not success.
 - **Read the model's outputs, not just the metrics.** A rising reward can come from
   reward-hacking or a degenerate output the reward still credits — metrics alone never
@@ -480,9 +481,9 @@ flash env setup                       # scaffold environment.py, dataset/, confi
 flash env push --name my-env .        # publish the environment; paste the returned id into [environment]
 flash env pull your-org/my-env        # download a published environment into the current folder
 flash env delete your-org/my-env -y   # delete a published environment
-flash train configs/rl.toml --dry-run # validate the config locally (no GPU, no charge)
-flash train configs/rl.toml --cost    # pre-flight USD estimate, then exit
-flash train configs/rl.toml           # submit and follow logs (Ctrl-C detaches; --background to skip following)
+flash train configs/sft.toml --dry-run # validate the config locally (no GPU, no charge)
+flash train configs/sft.toml --cost    # pre-flight USD estimate, then exit
+flash train configs/sft.toml           # submit and follow logs (Ctrl-C detaches; --background to skip following)
 flash status <run-id>                 # state + accrued cost
 flash log <run-id>                    # reward/loss trend + worker console/error logs
 flash log <run-id> --follow           # stream a live run to completion

{freesolo_flash_dev-0.2.40 → freesolo_flash_dev-0.2.42}/flash/engine/chalk_kernels.py

@@ -22,7 +22,6 @@ _KERNELS: list[tuple[str, bool]] = [
     ("trainable_attn_epilogue", True),
     ("fused_embedding", True),
     ("gdn", True),
-    ("fused_mlp", False),  # off: eval-only bf16 MLP forward, not the training activation path
     ("attn_epilogue", False),  # off (eval-only; needs q/k/v out of LoRA)
     ("fp8_frozen_base", False),  # off by default: speed/memory tradeoff, enable only after run A/B
 ]
@@ -54,15 +53,24 @@ def chalk_fused_ce_available(model_id: str | None = None) -> bool:
     return callable(_apply)
 
 
-def install_chalk_kernels(model=None) -> dict:
+def install_chalk_kernels(model=None, *, fused_ce: bool = True) -> dict:
     """Apply chalk standalone kernels to ``model``; call AFTER TRL builds the trainer.
 
+    ``fused_ce=False`` skips the fused-linear-CE kernel. flce computes the loss inside a chunked
+    LM-head+CE kernel and returns ``logits=None`` (the whole point — it never materialises the
+    ``[batch, seq, vocab]`` logits). trl's ``SFTTrainer.compute_loss`` reads ``outputs.logits`` and
+    only skips it under ``use_liger_kernel=True`` — which flash can't set, since that makes trl apply
+    Liger and clash with chalk. So the SFT (trl) path passes ``fused_ce=False`` and lets the model
+    materialise logits; the custom GRPO/opd loops read the fused loss directly and keep it on.
+
     Returns chalk's per-kernel report, or ``{}`` when freesolo-chalk isn't installed.
     """
     if model is None:
         return {}
 
     kwargs = dict(_KERNELS)
+    if not fused_ce:
+        kwargs["fused_linear_cross_entropy"] = False
     try:
         from chalk.transformers import apply_chalk_kernel_to_qwen35
     except ImportError:

{freesolo_flash_dev-0.2.40 → freesolo_flash_dev-0.2.42}/flash/engine/worker/__init__.py

@@ -114,6 +114,7 @@ from flash.engine.worker.perf import (
     gpu_diagnostics,
     grad_checkpointing_on,
     grpo_sleep_mode,
+    grpo_use_reentrant,
     is_cuda_oom,
     liger_on,
     loraplus_optimizer_cls,
@@ -377,6 +378,7 @@ __all__ = [
     "grpo_mask_truncated_completions",
     "grpo_overrides",
     "grpo_sleep_mode",
+    "grpo_use_reentrant",
     "heartbeat",
     "hf_api",
     "hf_prefix",