feat(cmf): live-apply managed-server changes; auto-resolve import id collisions

- Saving the Local models list now applies IMMEDIATELY: removed or redefined
  rows stop their `cortiq serve` child (memory freed on the spot), new or
  changed rows are spawned and health-checked — no gateway restart needed.
- A managed row that shares its id with a same-id STATIC pool entry pointing at
  a local server (the shape Import→register creates) now supersedes it: the
  static entry is dropped automatically instead of failing the save with
  "duplicate managed model id".
- validate() now tells the two duplicate cases apart with actionable messages
  (two managed rows vs managed-vs-pool collision).

Cargo.lock

@@ -285,7 +285,7 @@ checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
 
 [[package]]
 name = "cortiq-gateway"
-version = "0.2.18"
+version = "0.2.20"
 dependencies = [
  "anyhow",
  "arc-swap",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cortiq-gateway"
-version = "0.2.18"
+version = "0.2.20"
 edition = "2021"
 rust-version = "1.75"
 license = "Apache-2.0"

src/admin/mod.rs

@@ -908,28 +908,44 @@ async fn put_settings(State(state): State<SharedState>, Json(b): Json<SettingsBo
         needs_restart = true;
         cfg.cache = v;
     }
+    let mut cmf_apply: Option<(Vec<crate::config::CmfServer>, CmfCfg)> = None;
     if let Some(v) = b.cmf {
-        // manage_server / local_model / threads / gpu apply on restart (the server
-        // is spawned once at startup with those env vars); local_only / router
-        // routing apply immediately.
-        if v.manage_server != cfg.cmf.manage_server
-            || v.local_model != cfg.cmf.local_model
-            || v.threads != cfg.cmf.threads
-            || v.gpu != cfg.cmf.gpu
-            || v.servers != cfg.cmf.servers
-        {
-            needs_restart = true;
-        }
         let old_servers = cfg.cmf.effective_servers();
         cfg.cmf = v;
+        // A managed row supersedes a same-id STATIC pool entry that points at a
+        // local server (the shape Import→register creates): drop the static one
+        // instead of failing validation with "duplicate managed model id".
+        let managed_ids: std::collections::HashSet<String> = cfg
+            .cmf
+            .effective_servers()
+            .into_iter()
+            .map(|s| s.id)
+            .collect();
+        cfg.models.retain(|m| {
+            !(managed_ids.contains(&m.id)
+                && (m.base_url.contains("//127.0.0.1:") || m.base_url.contains("//localhost:")))
+        });
         // Replacing or renaming a managed model must not brick the save: routing
         // may still reference the old id. Map a vanished id to its replacement
         // (the new server on the same port), strip ids that are truly gone, and
         // repair the default so validate() passes.
         heal_routing_after_cmf_change(&mut cfg, &old_servers);
+        // Server-list changes apply LIVE after a successful reload: removed /
+        // redefined servers are stopped (RAM freed), new ones are spawned.
+        if cfg.cmf.effective_servers() != old_servers {
+            cmf_apply = Some((old_servers, cfg.cmf.clone()));
+        }
     }
     state.reload(cfg)?;
-    ok(json!({ "ok": true, "needs_restart": needs_restart }))
+    let applied_live = cmf_apply.is_some();
+    if let Some((old, new_cfg)) = cmf_apply {
+        tokio::spawn(crate::cmf_runtime::apply_server_changes(
+            state.cmf.clone(),
+            old,
+            new_cfg,
+        ));
+    }
+    ok(json!({ "ok": true, "needs_restart": needs_restart, "applied_live": applied_live }))
 }
 
 /// After the managed-servers list changed, rewrite [routing] so it only
@@ -1009,6 +1025,7 @@ async fn cmf_status(State(state): State<SharedState>) -> ApiResult {
                 "port": s.port,
                 "threads": s.threads,
                 "gpu": s.gpu,
+                "o1": s.o1,
                 "running": live.map(|l| l.running).unwrap_or(false),
                 "healthy": live.map(|l| l.healthy).unwrap_or(false),
                 "last_error": live.and_then(|l| l.last_error.clone()),

src/cmf_runtime.rs

@@ -173,6 +173,31 @@ impl CmfRuntime {
         }
     }
 
+    /// Ensure a status slot exists for `server` (used when servers are added at
+    /// runtime); refreshes model/port if the slot already exists.
+    fn add_server_slot(&self, server: &CmfServer, host: &str) {
+        let mut s = self.status.lock().unwrap();
+        s.enabled = true;
+        if let Some(sv) = s.servers.iter_mut().find(|x| x.id == server.id) {
+            sv.model = server.model.clone();
+            sv.port = server.port;
+            sv.base_url = format!("http://{host}:{}/v1", server.port);
+            sv.running = false;
+            sv.healthy = false;
+            sv.last_error = None;
+        } else {
+            s.servers.push(CmfServerStatus {
+                id: server.id.clone(),
+                model: server.model.clone(),
+                port: server.port,
+                base_url: format!("http://{host}:{}/v1", server.port),
+                running: false,
+                healthy: false,
+                last_error: None,
+            });
+        }
+    }
+
     /// Stop and forget a single managed server (used when a model is deleted).
     pub async fn stop_one(&self, id: &str) {
         let removed = {
@@ -295,6 +320,11 @@ fn spawn_serve(server: &CmfServer, cfg: &CmfCfg) -> Result<Child, String> {
     if server.gpu {
         cmd.env("CMF_GPU", "1");
     }
+    // Serve-time O(1) attention override: "off" forces exact attention (undoes a
+    // too-aggressive --o1 conversion hint without re-converting the file).
+    if !server.o1.trim().is_empty() {
+        cmd.env("CMF_O1", server.o1.trim());
+    }
     cmd.stdout(Stdio::null())
         .stderr(Stdio::null())
         .kill_on_drop(true)
@@ -322,6 +352,62 @@ async fn wait_healthy(host: &str, port: u16, tries: u32) -> bool {
     false
 }
 
+/// Apply a changed managed-servers list LIVE (no gateway restart): stop servers
+/// that were removed or redefined — freeing their memory immediately — and
+/// spawn servers that are new or redefined.
+pub async fn apply_server_changes(rt: Arc<CmfRuntime>, old: Vec<CmfServer>, cfg: CmfCfg) {
+    let new = cfg.effective_servers();
+    // 1. Stop what's gone or changed (kills the child → RAM released).
+    for o in &old {
+        let unchanged = new.iter().any(|n| n == o);
+        if !unchanged {
+            rt.stop_one(&o.id).await;
+            rt.log(format!("stopped '{}' (removed or changed)", o.id));
+        }
+    }
+    if new.is_empty() {
+        return;
+    }
+    // 2. Spawn what's new or changed.
+    if installed_version(&cfg.cortiq_bin).is_none() {
+        rt.fail("cortiq binary not found — cannot start local model servers");
+        return;
+    }
+    for n in &new {
+        let unchanged = old.iter().any(|o| o == n);
+        if unchanged {
+            continue; // already running with the same definition
+        }
+        rt.add_server_slot(n, &cfg.local_host);
+        if !std::path::Path::new(&n.model).exists() {
+            rt.fail_server(&n.id, format!("model file not found: {}", n.model));
+            continue;
+        }
+        rt.log(format!(
+            "starting: cortiq serve {} --host {} --port {}",
+            n.model, cfg.local_host, n.port
+        ));
+        match spawn_serve(n, &cfg) {
+            Ok(child) => rt.add_child(n.id.clone(), child),
+            Err(e) => {
+                rt.fail_server(&n.id, format!("failed to spawn: {e}"));
+                continue;
+            }
+        }
+        let (rtc, host, id, port) = (rt.clone(), cfg.local_host.clone(), n.id.clone(), n.port);
+        tokio::spawn(async move {
+            if wait_healthy(&host, port, 240).await {
+                rtc.set_healthy(&id, true);
+                rtc.log(format!(
+                    "local CMF server ready — '{id}' at http://{host}:{port}/v1"
+                ));
+            } else {
+                rtc.fail_server(&id, "did not become healthy in time");
+            }
+        });
+    }
+}
+
 /// Orchestrate the whole lifecycle: ensure installed → maybe update → spawn each
 /// configured local model → wait healthy. Safe to call in a background task; it
 /// never panics.

src/config.rs

@@ -83,6 +83,12 @@ pub struct CmfServer {
     /// Offload matvecs to the GPU (CMF_GPU=1).
     #[serde(default)]
     pub gpu: bool,
+    /// Serve-time O(1) attention override (exported as CMF_O1). Empty = follow
+    /// the hint recorded in the .cmf; "off" = force exact attention (fixes a
+    /// too-aggressive conversion without re-converting); "all"/"deepN"/"i,j,k"
+    /// = force-enable on those layers.
+    #[serde(default)]
+    pub o1: String,
 }
 
 /// CMF-format model factory: import a HuggingFace model, convert it to a
@@ -172,6 +178,7 @@ impl CmfCfg {
                 port: self.local_port,
                 threads: self.threads,
                 gpu: self.gpu,
+                o1: String::new(),
             }];
         }
         Vec::new()
@@ -675,9 +682,19 @@ impl Config {
             self.models.iter().map(|m| m.id.as_str()).collect();
         // managed local servers are known ids too; also enforce unique ports/ids
         let mut ports = std::collections::HashSet::new();
+        let mut managed_seen = std::collections::HashSet::new();
         for s in &servers {
+            if !managed_seen.insert(s.id.as_str()) {
+                anyhow::bail!(
+                    "config: two managed local models share the id '{}' — give one of the rows a different id",
+                    s.id
+                );
+            }
             if !ids.insert(s.id.as_str()) {
-                anyhow::bail!("config: duplicate managed model id '{}'", s.id);
+                anyhow::bail!(
+                    "config: managed local model '{}' has the same id as a pool model — rename the row or delete the pool entry",
+                    s.id
+                );
             }
             if !ports.insert(s.port) {
                 anyhow::bail!("config: two managed models share port {}", s.port);

web/js/i18n/en.js

@@ -264,7 +264,9 @@ export default {
   "settings.cmf.pick": "select a model",
   "settings.cmf.models": "Local models",
   "settings.cmf.modelsHelp": "Each row is one model the gateway runs (its own cortiq serve on its own port) and registers in the pool. Add as many as you have .cmf files and free ports.",
-  "settings.cmf.rowHint": "id · .cmf file · port · threads · GPU. Changes apply on restart; deleting a row stops that server.",
+  "settings.cmf.rowHint": "id · .cmf file · port · threads · GPU · O(1). Applied on save: a removed row stops its server (memory freed), a new row starts one.",
+  "settings.cmf.o1Auto": "O(1): auto",
+  "settings.cmf.o1Help": "O(1) attention at serve time: auto — follow the hint recorded in the .cmf; off — force exact attention (fixes incoherent output after a too-aggressive --o1 conversion, no re-convert needed); all/deepN — force-enable on those layers.",
   "settings.cmf.addServer": "+ Add local model",
   "settings.cmf.checkPort": "Check port",
   "settings.cmf.portFree": "port is free",

web/js/i18n/ru.js

@@ -263,7 +263,9 @@ export default {
   "settings.cmf.pick": "выберите модель",
   "settings.cmf.models": "Локальные модели",
   "settings.cmf.modelsHelp": "Каждая строка — отдельная модель: шлюз поднимает свой cortiq serve на своём порту и регистрирует её в пуле. Добавляйте столько, сколько есть .cmf-файлов и свободных портов.",
-  "settings.cmf.rowHint": "id · файл .cmf · порт · потоки · GPU. Изменения применяются после перезапуска; удаление строки останавливает сервер.",
+  "settings.cmf.rowHint": "id · файл .cmf · порт · потоки · GPU · O(1). Применяется сразу при сохранении: удалённая строка останавливает сервер (память освобождается), новая — запускает.",
+  "settings.cmf.o1Auto": "O(1): авто",
+  "settings.cmf.o1Help": "O(1)-внимание при запуске: авто — использовать подсказку из .cmf; off — принудительно точное внимание (лечит бессвязный вывод после слишком агрессивной --o1 конвертации, без переконвертации); all/deepN — принудительно включить на этих слоях.",
   "settings.cmf.addServer": "+ Добавить модель",
   "settings.cmf.checkPort": "Проверить порт",
   "settings.cmf.portFree": "порт свободен",

web/js/views/settings.js

@@ -234,6 +234,12 @@ export async function renderSettings() {
     const portIn = h("input", { type: "number", value: sv.port ?? 8090, style: "width:82px" });
     const threadsIn = h("input", { type: "number", min: 0, value: sv.threads ?? 8, style: "width:60px", title: t("settings.cmf.threadsHelp") });
     const gpuIn = h("input", { type: "checkbox", checked: sv.gpu ? true : null, title: t("settings.cmf.gpuHelp") });
+    // serve-time O(1) override: off cures a too-aggressive --o1 conversion
+    const o1Opts = ["", "off", "all", "deep4", "deep8", "deep12"];
+    const o1In = h("select", { style: "width:110px", title: t("settings.cmf.o1Help") },
+      ...o1Opts.map((v) => h("option", { value: v, selected: (sv.o1 || "") === v ? true : null },
+        v === "" ? t("settings.cmf.o1Auto") : v)));
+    if (sv.o1 && !o1Opts.includes(sv.o1)) o1In.appendChild(h("option", { value: sv.o1, selected: true }, sv.o1));
     const checkBtn = h("button", { class: "btn small", type: "button" }, t("settings.cmf.checkPort"));
     const removeBtn = h("button", { class: "btn small danger", type: "button", title: t("common.delete") }, "✕");
     const st = h("span", { class: "small" });
@@ -258,8 +264,8 @@ export async function renderSettings() {
       checkBtn.disabled = false;
     });
     const row = h("div", { class: "flex wrap", style: "gap:6px;align-items:center;margin:6px 0" },
-      idIn, modelSel, portIn, checkBtn, threadsIn, h("label", { class: "flex", style: "gap:4px" }, gpuIn, "GPU"), removeBtn, st);
-    const entry = { node: row, read: () => ({ id: idIn.value.trim() || autoId(modelSel.value), model: modelSel.value.trim(), port: parseInt(portIn.value) || 8090, threads: parseInt(threadsIn.value) || 0, gpu: gpuIn.checked }) };
+      idIn, modelSel, portIn, checkBtn, threadsIn, h("label", { class: "flex", style: "gap:4px" }, gpuIn, "GPU"), o1In, removeBtn, st);
+    const entry = { node: row, read: () => ({ id: idIn.value.trim() || autoId(modelSel.value), model: modelSel.value.trim(), port: parseInt(portIn.value) || 8090, threads: parseInt(threadsIn.value) || 0, gpu: gpuIn.checked, o1: o1In.value }) };
     removeBtn.addEventListener("click", () => { const i = serverRows.indexOf(entry); if (i >= 0) serverRows.splice(i, 1); row.remove(); });
     serverRows.push(entry);
     serversWrap.appendChild(row);