fix(engine, code): a model nobody could start, a window silently ignored, and six editor defects

THE ENTRY THAT COULD NOT START ON ANY MAC. A registry model whose only
measurement is a 92 GB cache, taken on a far larger machine, made eco ask
for more than perf: the mode names mean smallest and largest footprint,
and unclamped eco returned that 92 GB while perf returned the ceiling. The
step-down from perf therefore walked toward a HEAVIER footprint and never
converged, so every mode was impossible. The card was shown as
installable, min_ram_gb was satisfied, a speed was printed, and the user
found out after downloading 202 GB and building a 190 GB pack.

Both measured branches are clamped now, like the no-curve branch already
was. The test states it as the invariant rather than as a number: if perf
can start, eco must be able to start. Verified by removing the fix, where
it reports perf planning 14 GB while eco demands 100.

THE CONTEXT WINDOW SETTING WAS COSMETIC ON TWELVE MODELS. ctx_per_slot_for
clamps the request to what the model declares, and no MoE entry declared
anything, so all of them fell to a cautious 32K ceiling while the button
stayed lit on whatever had been chosen: picking 128K left 128K on screen
over an engine serving 32K. Nine entries now carry the window from their
own published config (Qwen3-Coder and Qwen3-Next at 256K, gpt-oss and
GLM-4.5-Air at 128K, OLMoE at 4K), and the engine reports the window it is
actually serving so the panel can say when a request was capped. The three
whose configuration is not public keep the cautious ceiling, which is what
they had.

SIX IN THE EDITOR.

The change gutter never updated while typing: the marks were computed once
at open and frozen, so twenty lines in, the bar still described the file as
it had been. The debounce and the cache were already there for it.

Creating, renaming or deleting from the tree left the file index stale for
the whole session: a new file was not offered by the palette and a renamed
one kept answering under its old path in project search.

The outline recomputed on every pause in typing whether or not anyone was
looking at it, forcing a syntax tree with a 50 ms budget on the main
thread for a panel that was not on screen.

And in a split, the linter ran the other pane's document under the focused
pane's filename: a .rs on the right was diagnosed as if it were the .md on
the left, so its sources went silent or returned another file's positions.
The linter now reads the path from the state it is given, which is exactly
what the docRel facet exists for.

Author: Schaerer Damien

app/src-tauri/src/lib.rs

@@ -248,6 +248,57 @@ fn root_set(path: String) -> Result<(), String> {
     })
 }
 
+#[cfg(test)]
+mod cache_ceiling_tests {
+    use super::*;
+
+    /// If perf can start, eco must be able to start.
+    ///
+    /// That is what the three modes mean: eco is the smallest footprint, perf
+    /// the largest. The registry entry that broke it has ONE measured point, a
+    /// 92 GB cache taken on a machine far bigger than the one being planned
+    /// for, and eco returned that number unclamped. So eco asked for MORE than
+    /// perf, the step-down from perf walked toward a heavier footprint, and
+    /// every mode came back impossible, on a card the app had shown as
+    /// installable after a 202 GB download.
+    ///
+    /// Stated as an invariant between modes rather than as a number, because
+    /// the numbers depend on the machine and the invariant does not.
+    #[test]
+    fn eco_is_never_heavier_than_perf() {
+        let entry = json!({
+            "id": "single-point",
+            "gguf_bytes": 60_000_000_000u64,
+            "expert_bytes_total": 50_000_000_000u64,
+            "non_expert_bytes": 4_000_000_000u64,
+            "record_bytes": 13_000_000u64,
+            "experts": 128,
+            "experts_used": 8,
+            "layers_moe": 40,
+            "min_cache_bytes": 5_000_000_000u64,
+            "status": "certified_bit_transparent",
+            // The only measurement comes from a much larger machine.
+            "measured": [{"cache_gb": 92.0, "gen_tps": 6.0, "mac_gb": 512}],
+        });
+        for ram in [32u64, 64, 128] {
+            let machine = MachineLimits { ram_gb: ram, available: None, gpu_working_set: None };
+            let perf = plan_cache(&entry, machine, None, "perf", false, 1, CTX_PER_SLOT);
+            let eco = plan_cache(&entry, machine, None, "eco", false, 1, CTX_PER_SLOT);
+            if let Ok(p) = perf {
+                let e = eco.unwrap_or_else(|err| {
+                    panic!("{ram} GB: perf planned {} but eco refused: {err}", p.cache_bytes)
+                });
+                assert!(
+                    e.cache_bytes <= p.cache_bytes,
+                    "{ram} GB: eco planned {} against perf's {}",
+                    e.cache_bytes,
+                    p.cache_bytes
+                );
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod settings_read_tests {
     use super::*;
@@ -1681,10 +1732,18 @@ struct ServerState {
     generation: u64,
     /// Port actually bound by the running server (0 when stopped).
     port: u16,
-    /// Engine regime: resident-metal | streamed-metal | cpu-bit-exact.
+    /// Engine regime: resident-bit-exact | streamed-bit-exact | cpu-bit-exact
+    /// | stock-llamacpp (a dense model, which streams nothing).
     mode: String,
     /// Decode slots the running server was started with (--parallel).
     slots: u32,
+    /// Context window per slot the running server was started with.
+    ///
+    /// The setting offers 8K to 128K, and ctx_per_slot_for clamps it to what
+    /// the model declares (or to a cautious 32K when it declares nothing). The
+    /// UI painted the STORED value, so someone who chose 128K saw 128K on a
+    /// server running 32K, with nothing saying the request had been reduced.
+    ctx_per_slot: u32,
     /// Measured tool-calling verdict for the running model (see ServerStatus).
     tools_ok: Option<bool>,
     /// The footprint mode this server was actually started in, and why. None
@@ -1705,6 +1764,7 @@ fn server_state() -> &'static Mutex<ServerState> {
             port: 0,
             mode: String::new(),
             slots: 1,
+            ctx_per_slot: 0,
             tools_ok: None,
             footprint: None,
         })
@@ -1859,6 +1919,9 @@ struct ServerStatus {
     /// have been cheaper and would have been wrong: it depends on the build,
     /// the chat template and the quantization, not on the model name.
     tools_ok: Option<bool>,
+    /// The context window per slot the engine is actually serving, which is
+    /// not always the one that was asked for.
+    ctx_per_slot: u32,
     /// The memory-footprint decision this engine was started with: the mode
     /// asked for, the mode actually used, and the two numbers that separate
     /// them. The UI says so out loud when they differ, because a user who
@@ -1878,6 +1941,7 @@ fn server_status() -> ServerStatus {
         // Stopped: report what the NEXT start would give, so the UI never
         // promises a concurrency the engine will not have.
         slots: if s.child.is_some() { s.slots } else { engine_slots() },
+        ctx_per_slot: s.ctx_per_slot,
         tools_ok: s.tools_ok,
         footprint: s.footprint.clone(),
     }
@@ -3118,7 +3182,14 @@ fn plan_cache(
             return if mode == "perf" || floor == 0 { ceiling } else { floor.min(ceiling) };
         }
         match mode {
-            "eco" => (measured[0].0 * 1e9) as u64,
+            // Clamped, like the no-curve branch above already was. A measured
+            // point is a number from a bigger machine, not a promise this one
+            // can keep: a model whose only measurement is a 92 GB cache made eco
+            // ask for MORE than perf, so the step-down walked toward a heavier
+            // footprint and never reached anything that fitted. The user saw an
+            // installable card, downloaded 202 GB, and then could not start it
+            // on any Mac.
+            "eco" => ((measured[0].0 * 1e9) as u64).min(ceiling),
             "perf" => ceiling,
             _ => {
                 // Full residency first, when the ceiling already reaches every
@@ -3144,7 +3215,7 @@ fn plan_cache(
                     .fold(measured[0].1, f64::max);
                 for (c, t) in &measured {
                     if *t >= 0.9 * reachable {
-                        return (*c * 1e9) as u64;
+                        return ((*c * 1e9) as u64).min(ceiling);
                     }
                 }
                 ceiling
@@ -4596,6 +4667,7 @@ async fn server_start(app: AppHandle, model_id: String, cache_gb: Option<u64>) -
         s.generation = generation;
         s.port = port;
         s.slots = slots;
+        s.ctx_per_slot = ctx_per_slot;
         s.footprint = Some(plan.decision.clone());
     }
     let _ = app.emit(

app/src/api.ts

@@ -137,12 +137,19 @@ export interface ServerStatus {
   model_id?: string;
   port: number;
   phase: string; // stopped | starting | ready
-  mode?: string; // resident-metal | streamed-metal | cpu-bit-exact
+  mode?: string; // resident-bit-exact | streamed-bit-exact | cpu-bit-exact | stock-llamacpp
   /**
    * Concurrent decode streams the engine serves (llama-server --parallel).
    * The hard bound on how many conversations may generate at the same time.
    */
   slots?: number;
+  /**
+   * The context window per slot the engine is actually serving.
+   *
+   * Not always the one that was asked for: each model is capped by the window
+   * it was trained on, and by a cautious ceiling when it declares none.
+   */
+  ctx_per_slot?: number;
   /**
    * Whether the running model actually emits tool calls, MEASURED at warmup.
    * Undefined while unknown. False disables every agent surface, because

app/src/code.ts

@@ -37,7 +37,7 @@ import type { PermissionRequest } from "./agent";
 import { isElevatedCommand } from "./agent";
 import { t, getLang } from "./i18n";
 
-import { Docs, type Doc } from "./code/docs";
+import { Docs, type Doc, docRel } from "./code/docs";
 import { editorExtensions, intelComp } from "./code/extensions";
 import { tabsHtml, onTabsClick } from "./code/tabs";
 import { cmPhrases } from "./code/phrases";
@@ -425,7 +425,11 @@ function newRegistry(): Docs {
         onSave: () => void saveOpenFile(),
         phrases: cmPhrases(getLang()),
         language: langFor(rel),
-        diagnostics: [diagnosticsExtension(() => docs.activeRel())],
+        // The document this state belongs to, read from the state itself. It
+        // used to be the FOCUSED pane's file: a .rs on the right was linted as
+        // if it were the .md on the left, so the sources went silent or, worse,
+        // put another file's positions on this one.
+        diagnostics: [diagnosticsExtension((state) => state.facet(docRel))],
       }),
       oneDark,
       syntaxHighlighting(galactusHighlight),
@@ -1437,6 +1441,10 @@ async function newEntry(anchor: string | null, isDir: boolean, folder: boolean):
     deps?.toast(String(e?.message ?? e));
     return;
   }
+  // The palette and the project search read a cached file list. Creating,
+  // renaming or deleting from the tree left it stale for the whole session:
+  // a new file was not offered by Cmd+P and a renamed one kept its old path.
+  indexStale = true;
   await refreshDirOf(rel);
   // A new file opens; a new folder opens in the tree, where the next click is.
   if (folder) {
@@ -1464,6 +1472,10 @@ async function renameEntry(rel: string): Promise<void> {
   // the next save cannot recreate the file under the name that just went away.
   const wasOpen = docs.list().some((d) => d.rel === rel);
   if (wasOpen) closeTab(rel);
+  // The palette and the project search read a cached file list. Creating,
+  // renaming or deleting from the tree left it stale for the whole session:
+  // a new file was not offered by Cmd+P and a renamed one kept its old path.
+  indexStale = true;
   await refreshDirOf(dest);
   if (wasOpen) await openFile(dest);
 }
@@ -1488,6 +1500,10 @@ async function deleteEntry(rel: string): Promise<void> {
   if (docs.list().some((d) => d.rel === rel)) closeTab(rel);
   expanded.delete(rel);
   treeCache.delete(rel);
+  // The palette and the project search read a cached file list. Creating,
+  // renaming or deleting from the tree left it stale for the whole session:
+  // a new file was not offered by Cmd+P and a renamed one kept its old path.
+  indexStale = true;
   await refreshDirOf(rel);
   // Says where it went, because "moved to Trash" and "moved to .galactus/trash"
   // are two different places to go looking for it.
@@ -1558,6 +1574,9 @@ function onEditorUpdate(u: ViewUpdate): void {
   d.state = u.state;
   if (u.docChanged) {
     scheduleOutline();
+    // The marks were computed once at open and then frozen: twenty lines typed
+    // and the bar still described the file as it was before.
+    scheduleChangeBar();
     if (tsActive()) tsintel!.updateBuffer(d.rel, u.state.doc.toString());
     if (isRust(d.rel)) syncRustBuffer(d.rel, u.state.doc.toString());
   }
@@ -2032,6 +2051,9 @@ function scheduleOutline(): void {
 }
 
 async function computeOutline(): Promise<void> {
+  // Nobody is looking: this forces a syntax tree with a 50 ms budget on the
+  // main thread at every pause in typing, for a panel that is not on screen.
+  if (leftTab !== "outline") return;
   const d = docs.active();
   if (!d || d.error !== null) {
     outlineItems = [];

app/src/code/diagnostics.ts

@@ -763,6 +763,10 @@ const dict: Record<string, { en: string; fr: string }> = {
     en: "Family, size on disk, and how many of its experts run per token: a Mixture-of-Experts model uses a few of them at a time, which is why it can be larger than your memory.",
     fr: "Famille, taille sur le disque, et combien de ses experts tournent par jeton : un modèle Mixture-of-Experts n'en utilise que quelques-uns à la fois, et c'est pour cela qu'il peut dépasser votre mémoire.",
   },
+  "settings.ctxCapped": {
+    en: "Running at %s tokens: this model was not trained for more.",
+    fr: "En cours à %s jetons : ce modèle n'a pas été entraîné pour plus.",
+  },
   "news.title": { en: "What changed in %s", fr: "Ce qui a changé dans la %s" },
   "news.sub": {
     en: "Since the version you were running.",

app/src/i18n.ts

@@ -3952,7 +3952,7 @@ function settingsView(): HTMLElement {
           <button data-sl="4">4</button>
         </div>
       </div>
-      <div class="set-row"><div class="grow"><b>${esc(t("settings.ctx"))}</b><span>${esc(t("settings.ctxHint"))}</span></div>
+      <div class="set-row"><div class="grow"><b>${esc(t("settings.ctx"))}</b><span>${esc(t("settings.ctxHint"))}</span><span class="d ctxnote"></span></div>
         <div class="seg" id="ctxseg">
           <button data-ctx="8192">8K</button>
           <button data-ctx="16384">16K</button>
@@ -4113,7 +4113,23 @@ function settingsView(): HTMLElement {
       const paintCtx = (v: string) =>
         ctxseg.querySelectorAll("button").forEach((b) =>
           (b as HTMLElement).classList.toggle("on", (b as HTMLElement).dataset.ctx === v));
-      api.settingsGet().then((s) => paintCtx(s["engine_ctx"] || "8192"));
+      api.settingsGet().then((s) => {
+        paintCtx(s["engine_ctx"] || "8192");
+        // What the engine is ACTUALLY serving, when it differs from what was
+        // asked for. Each model is capped by the window it was trained on (or
+        // by a cautious ceiling when it declares none), and the segment painted
+        // the stored value regardless: choosing 128K left the button on 128K
+        // over a server running 32K, with nothing saying so.
+        const live = server.ctx_per_slot ?? 0;
+        const want = Number(s["engine_ctx"] || "8192");
+        const note = ctxseg.parentElement?.querySelector<HTMLElement>(".ctxnote");
+        if (note) {
+          note.textContent =
+            server.running && live > 0 && live !== want
+              ? t("settings.ctxCapped").replace("%s", String(live))
+              : "";
+        }
+      });
       ctxseg.addEventListener("click", async (e) => {
         const b = (e.target as HTMLElement).closest("[data-ctx]") as HTMLElement | null;
         if (!b) return;

app/src/main.ts

@@ -108,7 +108,8 @@
         "regime": "cross-check path (CPU experts and biases)",
         "date": "2026-08-11",
         "recorded_by": "scripts/certify.py"
-      }
+      },
+      "context_length": 131072
     },
     {
       "id": "glm-5.2-744b",
@@ -149,7 +150,8 @@
           "GLM-5.2-UD-IQ1_S-00005-of-00006.gguf",
           "GLM-5.2-UD-IQ1_S-00006-of-00006.gguf"
         ]
-      }
+      },
+      "context_length": 202752
     },
     {
       "id": "qwen3-30b-a3b",
@@ -232,7 +234,8 @@
         "writing",
         "scripting"
       ],
-      "min_ram_gb": 16
+      "min_ram_gb": 16,
+      "context_length": 40960
     },
     {
       "id": "llama4-scout",
@@ -398,7 +401,8 @@
         "max",
         "reasoning",
         "writing"
-      ]
+      ],
+      "context_length": 40960
     },
     {
       "id": "glm-4.5-air",
@@ -491,7 +495,8 @@
       "tasks": [
         "writing",
         "reasoning"
-      ]
+      ],
+      "context_length": 131072
     },
     {
       "id": "qwen3-next-80b",
@@ -591,7 +596,8 @@
       "tasks": [
         "general",
         "writing"
-      ]
+      ],
+      "context_length": 262144
     },
     {
       "id": "qwen3-coder-30b",
@@ -676,7 +682,8 @@
         "regime": "cross-check path (CPU experts and biases)",
         "date": "2026-08-11",
         "recorded_by": "scripts/certify.py"
-      }
+      },
+      "context_length": 262144
     },
     {
       "id": "olmoe-1b-7b",
@@ -751,7 +758,8 @@
           "prompt_spread_pct": 5.0
         }
       ],
-      "measured_note": "MacBook Pro M5 Max, 128 GB, internal SSD, shipped path (Metal bit-exact experts), batch 512, planner ubatch, 192 predicted tokens on a 24-paragraph prompt, bench 2026-08-10 by scripts/bench-curve.py; cache = app planning ceiling per Mac tier, curve stops at full residency (3.90 GB)"
+      "measured_note": "MacBook Pro M5 Max, 128 GB, internal SSD, shipped path (Metal bit-exact experts), batch 512, planner ubatch, 192 predicted tokens on a 24-paragraph prompt, bench 2026-08-10 by scripts/bench-curve.py; cache = app planning ceiling per Mac tier, curve stops at full residency (3.90 GB)",
+      "context_length": 4096
     },
     {
       "id": "phi35-moe",
@@ -830,7 +838,8 @@
           "prompt_spread_pct": 0.0
         }
       ],
-      "measured_note": "MacBook Pro M5 Max, 128 GB, internal SSD, shipped path (Metal bit-exact experts), batch 512, planner ubatch, 192 predicted tokens on a 24-paragraph prompt, bench 2026-08-10 by scripts/bench-curve.py; cache = app planning ceiling per Mac tier, curve stops at full residency (24.38 GB)"
+      "measured_note": "MacBook Pro M5 Max, 128 GB, internal SSD, shipped path (Metal bit-exact experts), batch 512, planner ubatch, 192 predicted tokens on a 24-paragraph prompt, bench 2026-08-10 by scripts/bench-curve.py; cache = app planning ceiling per Mac tier, curve stops at full residency (24.38 GB)",
+      "context_length": 131072
     },
     {
       "id": "mellum2-12b",