@@ -433,6 +433,36 @@ def _legacy_standalone_gguf_key(model_id: str) -> Optional[str]:
     return resolve_model_override_key(f"{model_id}:{label}")
 
 
+def _fill_target_id(target_id: str) -> str:
+    """Where a one-time backfill write for ``target_id`` has to land.
+
+    A fill only adds, so unlike a save it cannot retire the other spelling of a cached
+    repo. Creating the snapshot-path key while the server already holds the repo id
+    would leave two entries for one quant, and the loader reads the load path before the
+    advertised id, so an upgraded browser's pre-upgrade copy would shadow the newer
+    server config on every API load. Fill into the entry already there instead: nothing
+    outranks it, and the fields it lacks still arrive.
+
+    Only in that direction. A repo-id key never outranks an existing path entry, and two
+    snapshot paths name two caches, neither of which is knowably the one loaded here.
+    """
+    from core.inference.model_ids import hf_cache_repo_id
+    from utils.openai_auto_switch_settings import split_quant_suffix
+
+    # Already stored, so this write creates no second key to outrank anything.
+    if isinstance(get_model_overrides().get(target_id), dict):
+        return target_id
+    split = split_quant_suffix(target_id)
+    # A bare id backs every quant and is read last, and only a cache path outranks.
+    if split is None or hf_cache_repo_id(split[0]) is None:
+        return target_id
+    for alias_id in cached_repo_alias_keys(target_id):
+        alias_split = split_quant_suffix(alias_id)
+        if alias_split is not None and hf_cache_repo_id(alias_split[0]) is None:
+            return alias_id
+    return target_id
+
+
 @router.put("/openai-auto-switch/overrides", response_model = ModelOverridesResponse)
 def update_openai_auto_switch_override(
     payload: ModelOverridePayload, current_subject: str = Depends(get_current_subject)
@@ -469,6 +499,15 @@ def update_openai_auto_switch_override(
                     bare_id = _bare_model_id(payload.model_id)
                     if bare_id:
                         requested_extra_args = get_model_override(bare_id).get("llama_extra_args")
+                if requested_extra_args is None:
+                    # And for a standalone .gguf upgraded from the build that keyed it by its
+                    # filename label: the bare path written here is read before that key, so
+                    # its flags would go dark with no page able to show or restore them.
+                    legacy_id = _legacy_standalone_gguf_key(payload.model_id)
+                    if legacy_id:
+                        requested_extra_args = get_model_override(legacy_id).get(
+                            "llama_extra_args"
+                        )
                 if requested_extra_args is None:
                     # Same for the other spelling of a cached repo, which this save retires
                     # below: its flags have nowhere else to live, and the page cannot show them.
@@ -524,6 +563,10 @@ def update_openai_auto_switch_override(
             # Save under the key a load resolves to, as the removal branch does: the literal
             # id would leave two keys for one model, making every other casing ambiguous.
             target_id = resolve_model_override_key(payload.model_id) or payload.model_id
+            if payload.fill_absent_fields:
+                # A fill retires nothing below, so it must not create the higher-priority
+                # spelling of a row the server already holds.
+                target_id = _fill_target_id(target_id)
             set_model_override(
                 target_id,
                 llama_extra_args = extra_args,
 
@@ -4272,6 +4272,75 @@ def test_model_override_load_kwargs_gates_gpu_placement_on_gguf():
     LoadRequest(model_path = "unsloth/B-GGUF", **gguf)
 
 
+def test_a_carried_ctx_flag_cannot_outrank_a_freshly_saved_context(monkeypatch):
+    # The settings page has no control for pass-through flags, so a save carries over the
+    # ones already stored while writing the field the user just edited, leaving one entry
+    # holding both. Sent together they reach llama-server with the extras appended last,
+    # and its parser takes the final -c, so the stale flag would pin the old context.
+    _mock_override_store(monkeypatch)
+    _put("unsloth/B-GGUF:Q4_K_M", llama_extra_args = ["--ctx-size", "8192", "--top-k", "40"])
+    saved = _put("unsloth/B-GGUF:Q4_K_M", max_seq_length = 32768)
+    entry = saved.overrides["unsloth/B-GGUF:Q4_K_M"]
+    assert entry["max_seq_length"] == 32768
+    assert entry["llama_extra_args"] == ["--ctx-size", "8192", "--top-k", "40"]
+
+    backend = _FakeBackend(None)
+    rec = _LoadRecorder(backend)
+    _wire(
+        monkeypatch,
+        enabled = True,
+        resolves_to = ("unsloth/B-GGUF", "Q4_K_M", "unsloth/B-GGUF"),
+        backend = backend,
+        recorder = rec,
+    )
+
+    _run_hook("unsloth/B-GGUF")
+    request = rec.calls[0]
+    assert request.max_seq_length == 32768
+    # The shadowing flag goes; the sampling flag beside it is nobody's first-class field.
+    assert request.llama_extra_args == ["--top-k", "40"]
+
+
+def test_load_kwargs_strip_only_the_shadow_groups_the_override_supplies():
+    # Same rule the /load route applies to inherited extras: one group per first-class
+    # field actually being sent, so a flag with nothing to shadow still passes through.
+    override = {
+        "llama_extra_args": [
+            "-c",
+            "8192",
+            "--cache-type-k",
+            "f16",
+            "--spec-type",
+            "ngram",
+            "--jinja",
+            "--split-mode",
+            "row",
+            "--top-p",
+            "0.9",
+        ],
+        "max_seq_length": 32768,
+        "kv_cache_dtype": "q8_0",
+        "speculative_type": "mtp",
+        "chat_template_override": "{{ bos_token }}",
+        "tensor_parallel": True,
+    }
+    stripped = settings.model_override_load_kwargs(override, is_gguf = True)
+    assert stripped["llama_extra_args"] == ["--top-p", "0.9"]
+
+    # Nothing is supplied to shadow them, so every flag survives.
+    kept = settings.model_override_load_kwargs(
+        {"llama_extra_args": override["llama_extra_args"]}, is_gguf = True
+    )
+    assert kept["llama_extra_args"] == override["llama_extra_args"]
+
+    # And one field strips one group.
+    ctx_only = settings.model_override_load_kwargs(
+        {"llama_extra_args": override["llama_extra_args"], "max_seq_length": 32768},
+        is_gguf = True,
+    )
+    assert ctx_only["llama_extra_args"] == override["llama_extra_args"][2:]
+
+
 def test_saved_parallel_slots_reach_an_api_load(monkeypatch):
     # Parallel decode slots are a per-model setting the picker sends on every GGUF load.
     backend = _FakeBackend(None)
@@ -4495,6 +4564,25 @@ def test_the_retired_snapshot_path_entry_hands_over_its_launch_flags(override_st
     assert f"{_LEGACY_SNAPSHOT}:Q4_K_M" not in resp.overrides
 
 
+def test_a_standalone_gguf_save_keeps_its_filename_label_launch_flags(override_store):
+    # An early build keyed a loose .gguf by the quant label from its filename, and the bare
+    # path the picker writes today is read before that key (see
+    # test_the_filename_label_key_no_longer_shadows_the_bare_path), so writing the bare entry
+    # without the legacy flags puts them out of reach of a page that cannot show or restore
+    # them. The forget path already consults the same derived key.
+    path = "/models/Qwen3-8B-Q4_K_M.gguf"
+    settings.set_model_override(
+        f"{path}:q4_k_m",
+        llama_extra_args = ["--flash-attn"],
+        max_seq_length = 4096,
+    )
+
+    resp = _put(path, max_seq_length = 32768)
+    entry = resp.overrides[path]
+    assert entry["llama_extra_args"] == ["--flash-attn"]
+    assert entry["max_seq_length"] == 32768
+
+
 def test_a_snapshot_path_save_retires_the_repo_id_entry(override_store):
     # The same rule the other way round: a row the picker still keys by its path (an inactive
     # cache reached as a local row) must not be shadowed, so the last spelling saved survives.
@@ -4537,6 +4625,26 @@ def test_the_one_time_fill_retires_nothing(override_store):
     assert resp.overrides["unsloth/B-GGUF:Q4_K_M"]["max_seq_length"] == 32768
 
 
+def test_a_fill_never_creates_a_snapshot_path_key_over_a_repo_id_entry(override_store):
+    # A fill only adds, so it cannot retire the other spelling the way a save does. Creating
+    # the snapshot path key would leave two entries for one quant, and the loader reads the
+    # load path before the advertised repo id, so an upgraded browser's pre-upgrade copy would
+    # shadow the newer server config on every API load. Fill into the entry that is already
+    # there instead: nothing outranks it and the fields it lacks still arrive.
+    settings.set_model_override("unsloth/B-GGUF:Q4_K_M", max_seq_length = 32768)
+
+    resp = _put(
+        f"{_LEGACY_SNAPSHOT}:Q4_K_M",
+        max_seq_length = 2048,
+        kv_cache_dtype = "q8_0",
+        fill_absent_fields = True,
+    )
+    assert f"{_LEGACY_SNAPSHOT}:Q4_K_M" not in resp.overrides
+    entry = resp.overrides["unsloth/B-GGUF:Q4_K_M"]
+    assert entry["max_seq_length"] == 32768
+    assert entry["kv_cache_dtype"] == "q8_0"
+
+
 def test_stale_gpu_ids_are_dropped_not_fatal(monkeypatch):
     # A two-GPU pin on a one-GPU box used to 400 the load; one dead field degrades to defaults.
     backend = _FakeBackend(None)
 
@@ -456,6 +456,33 @@ def model_override_load_kwargs(override: dict[str, Any], *, is_gguf: bool) -> di
             kwargs["n_cpu_moe"] = override["n_cpu_moe"]
         if override.get("gpu_ids") is not None:
             kwargs["gpu_ids"] = override["gpu_ids"]
+
+    if kwargs.get("llama_extra_args"):
+        # One entry can hold a pass-through flag *and* the first-class field it shadows: the
+        # settings page has no control for flags, so a save carries the stored ones over
+        # (routes/settings.py) while writing the field just edited, and a legacy or
+        # API-authored entry can start out that way. Sending both explicitly puts the flag
+        # after Unsloth's own on the command line, where llama.cpp's last-wins parse hands it
+        # the load, so a stale "--ctx-size 8192" would quietly outrank a freshly saved 32768.
+        # The /load route strips exactly these groups off inherited extras
+        # (_resolve_inherited_extra_args); the stripper is imported rather than mirrored so
+        # the two paths cannot drift over which flag belongs to which group -- the allow-list
+        # this module stays out of is validate_extra_args, which remains the caller's job.
+        from core.inference.llama_server_args import strip_shadowing_flags
+
+        kwargs["llama_extra_args"] = strip_shadowing_flags(
+            kwargs["llama_extra_args"],
+            # Only the groups this override actually supplies, as the route gates on its
+            # request's set fields: a flag with no first-class field behind it is the user's
+            # only way to set that knob and still passes through.
+            strip_context = "max_seq_length" in kwargs,
+            strip_cache = "cache_type_kv" in kwargs,
+            strip_spec = "speculative_type" in kwargs or "spec_draft_n_max" in kwargs,
+            strip_template = "chat_template_override" in kwargs,
+            # Sent only when on, so it is always the Tensor Parallelism toggle overriding the
+            # flag; an override that leaves the toggle off keeps a row/none/layer split mode.
+            strip_split_mode = bool(kwargs.get("tensor_parallel")),
+        )
     return kwargs
 
 
 
@@ -25,6 +25,7 @@ import {
 } from "../types/api";
 import type { ChatModelSummary } from "../types/runtime";
 import { sameGpuSelection } from "@/hooks/gpu-selection";
+import { resolveChatTemplateSeed } from "./resolve-chat-template-seed";
 
 type LocalReasoningEffort = Extract<ReasoningEffort, "low" | "medium" | "high">;
 
@@ -402,16 +403,18 @@ export function applyActiveModelStatusToStore(
       gpuStatusFields),
     // The one load param that only ever seeded from null, so a switch left the previous model's
     // template in the store, which the Hub settings page reads as the new model's loaded config:
-    // Apply then saves A's template under B. Re-seeding needs BOTH guards the fields above use,
-    // since seedLoadParams alone is just "no load in flight" and holds on an ordinary poll.
-    ...(status.chat_template_override !== undefined &&
-      seedLoadParams &&
-      (hydratingExistingModel ||
-        (prevState.loadedChatTemplateOverride === null &&
-          prevState.chatTemplateOverride === null)) && {
-        chatTemplateOverride: status.chat_template_override,
-        loadedChatTemplateOverride: status.chat_template_override,
-      }),
+    // Apply then saves A's template under B. A same-model reload from another client moves it
+    // too, so the seed also follows a changed status the way the GPU group above does: baseline
+    // always, control only while it still sits on that baseline. See resolveChatTemplateSeed.
+    ...resolveChatTemplateSeed({
+      incoming: status.chat_template_override,
+      previous: {
+        chatTemplateOverride: prevState.chatTemplateOverride,
+        loadedChatTemplateOverride: prevState.loadedChatTemplateOverride,
+      },
+      hydratingExistingModel,
+      seedLoadParams,
+    }),
   });
 
   ensureActiveModelInStoreList(status, checkpointId);
 
@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+// What a fresh /api/inference/status does to the chat-template override pair. Its own
+// module, importing neither the store nor a barrel, so the rules are testable off a browser.
+
+export interface ChatTemplateSeedState {
+  /** The editable control: what the next load or Apply would send. */
+  chatTemplateOverride: string | null;
+  /** What the resident server was launched with, as this tab last saw it. */
+  loadedChatTemplateOverride: string | null;
+}
+
+/** The subset of the pair to write back; empty means leave the store alone. */
+export type ChatTemplateSeed = Partial<ChatTemplateSeedState>;
+
+/** Blank and absent are the same template: /load normalises "" to null before launching. */
+function sameTemplate(a: string | null, b: string | null): boolean {
+  return (a?.trim() ? a : null) === (b?.trim() ? b : null);
+}
+
+export function resolveChatTemplateSeed(options: {
+  /** ``status.chat_template_override``; undefined on a backend that omits the field. */
+  incoming: string | null | undefined;
+  previous: ChatTemplateSeedState;
+  /** A different model or quant is being adopted, so both fields are stale. */
+  hydratingExistingModel: boolean;
+  /** No load of this tab's own is in flight (``!modelLoading``). */
+  seedLoadParams: boolean;
+}): ChatTemplateSeed {
+  const { incoming, previous, hydratingExistingModel, seedLoadParams } =
+    options;
+  // While a load is in flight performLoad owns the load params, and an older backend
+  // omitting the field says nothing about the template.
+  if (incoming === undefined || !seedLoadParams) {
+    return {};
+  }
+  const unseeded =
+    previous.loadedChatTemplateOverride === null &&
+    previous.chatTemplateOverride === null;
+  if (hydratingExistingModel || unseeded) {
+    return {
+      chatTemplateOverride: incoming,
+      loadedChatTemplateOverride: incoming,
+    };
+  }
+  // Same checkpoint and quant, steady template: an ordinary poll must not touch the
+  // control, or it would overwrite a staged edit every refresh.
+  if (sameTemplate(incoming, previous.loadedChatTemplateOverride)) {
+    return {};
+  }
+  // The resident template moved under this tab -- another tab or an API caller reloaded
+  // the same checkpoint with a different override. The baseline is a fact about the
+  // running server, so it always advances (the rollback resends it). The control follows
+  // only while it still sits on the old baseline; a genuinely dirty one keeps its intent,
+  // exactly as the GPU group above preserves an unapplied placement edit.
+  const controlIsDirty = !sameTemplate(
+    previous.chatTemplateOverride,
+    previous.loadedChatTemplateOverride,
+  );
+  return {
+    loadedChatTemplateOverride: incoming,
+    ...(controlIsDirty ? {} : { chatTemplateOverride: incoming }),
+  };
+}