diff --git a/changelog.d/fixes/15595-engine-config-page-partial-save.md b/changelog.d/fixes/15595-engine-config-page-partial-save.md
new file mode 100644
index 000000000000..e1f0ab4b750f
--- /dev/null
+++ b/changelog.d/fixes/15595-engine-config-page-partial-save.md
@@ -0,0 +1 @@
+- **fix(dashboard):** Compression engine pages now save only the fields edited on that page. A save re-reads the stored settings and applies the edits onto the fresh stored copy, so saving an engine page no longer reverts thresholds and tool strategies the Compression Settings tab saved after the page loaded. An emptied text field clears its stored key, `ultra.enabled` survives engine-page saves, and the Ultra page saves on a default install where the model path was never set. (#15595)
diff --git a/changelog.d/fixes/15612-engine-config-empty-number-unset.md b/changelog.d/fixes/15612-engine-config-empty-number-unset.md
new file mode 100644
index 000000000000..cd826b728344
--- /dev/null
+++ b/changelog.d/fixes/15612-engine-config-empty-number-unset.md
@@ -0,0 +1 @@
+- **fix(dashboard):** compression engine config pages treat an emptied number field as "not set" instead of saving `0`, which silently changed compression for fields that accept zero (`aggressive.minSavingsThreshold`, `ultra.compressionRate`, `ultra.minScoreThreshold`) and 400'd saves for fields with a floor (`maxTokensPerMessage`, `minRows`, `minBlockChars`, `minChars`, `retrievalRampFactor`). Emptied fields now save as unset, show the schema default as a placeholder, keep an unparseable entry from unsetting the value, and reject overflow input visibly; lite's cap still clears when emptied.
diff --git a/src/i18n/messages/en.json b/src/i18n/messages/en.json
index 09c72e0c4715..8b9ff481e3f5 100644
--- a/src/i18n/messages/en.json
+++ b/src/i18n/messages/en.json
@@ -8544,6 +8544,7 @@
   "compressionEngineConfig": {
     "loading": "Loading…",
     "loadFailed": "Failed to load engine information.",
+    "settingsLoadFailed": "Failed to load the saved settings. The fields show defaults, and Save stays off until the page reloads.",
     "engineNotFound": "Engine \"{engine}\" not found.",
     "saveFailed": "Failed to save configuration.",
     "previewFailed": "Preview failed.",
diff --git a/src/shared/components/compression/EngineConfigForm.tsx b/src/shared/components/compression/EngineConfigForm.tsx
index 8be71aede446..e782aadf5472 100644
--- a/src/shared/components/compression/EngineConfigForm.tsx
+++ b/src/shared/components/compression/EngineConfigForm.tsx
@@ -4,11 +4,11 @@ import type { EngineConfigField } from "@omniroute/open-sse/services/compression
 export interface EngineConfigFormProps {
   schema: EngineConfigField[];
   value: Record<string, unknown>;
-  onChange: (next: Record<string, unknown>) => void;
+  // Called with one field at a time, so the caller can apply it to its latest state.
+  onChange: (key: string, value: unknown) => void;
 }
 
-export function EngineConfigForm({ schema, value, onChange }: EngineConfigFormProps) {
-  const set = (k: string, v: unknown) => onChange({ ...value, [k]: v });
+export function EngineConfigForm({ schema, value, onChange: set }: EngineConfigFormProps) {
   return (
     <div className="flex flex-col gap-3">
       {schema.map((f) => {
@@ -23,22 +23,19 @@ export function EngineConfigForm({ schema, value, onChange }: EngineConfigFormPr
             {f.type === "number" && (
               <input
                 type="number"
-                value={
-                  f.key === "maxToolLength" &&
-                  !(typeof v === "number" && Number.isFinite(v))
-                    ? ""
-                    : (v as number)
-                }
+                // NaN (an emptied field, "not set") renders as an empty input, never as 0;
+                // overflow (Infinity) also renders empty and surfaces through the save error.
+                value={typeof v === "number" && Number.isFinite(v) ? v : ""}
+                placeholder={f.defaultValue != null ? String(f.defaultValue) : ""}
                 min={f.min}
                 max={f.max}
-                onChange={(e) =>
-                  set(
-                    f.key,
-                    f.key === "maxToolLength" && e.target.value === ""
-                      ? Number.NaN
-                      : Number(e.target.value)
-                  )
-                }
+                onChange={(e) => {
+                  // A browser reports badInput with an empty value for unparseable entries
+                  // ("1e", "1,5" in a comma-decimal locale): keep the last valid value rather
+                  // than mapping the entry to the unset sentinel.
+                  if (e.target.value === "" && e.target.validity.badInput) return;
+                  set(f.key, e.target.value === "" ? Number.NaN : Number(e.target.value));
+                }}
                 className="border border-border rounded px-2 py-1"
               />
             )}
diff --git a/src/shared/components/compression/EngineConfigPage.tsx b/src/shared/components/compression/EngineConfigPage.tsx
index 4c05af2caafd..dfb75b79b1be 100644
--- a/src/shared/components/compression/EngineConfigPage.tsx
+++ b/src/shared/components/compression/EngineConfigPage.tsx
@@ -4,6 +4,13 @@ import { useEffect, useState } from "react";
 import { useLocale, useTranslations } from "next-intl";
 import type { EngineConfigField } from "@omniroute/open-sse/services/compression/engines/types";
 import { EngineConfigForm } from "@/shared/components/compression/EngineConfigForm";
+import {
+  buildEngineDetailUpdate,
+  forgetSentEdits,
+  formAfterSave,
+  seedEngineForm,
+  withoutEmptyText,
+} from "@/shared/components/compression/engineConfigSave";
 
 // ── Types ─────────────────────────────────────────────────────────────────
 
@@ -119,6 +126,9 @@ export function EngineConfigPage({ engineId }: { engineId: string }) {
   // ── Data state ──────────────────────────────────────────────────────────
   const [engine, setEngine] = useState<EngineEntry | null>(null);
   const [configState, setConfigState] = useState<Record<string, unknown>>({});
+  // The stored values as of the last load or save, in form shape. A save sends the fields
+  // changed since.
+  const [savedConfig, setSavedConfig] = useState<Record<string, unknown>>({});
   const [analytics, setAnalytics] = useState<Analytics | null>(null);
   const [loadError, setLoadError] = useState<string | null>(null);
   const [loading, setLoading] = useState(true);
@@ -156,35 +166,26 @@ export function EngineConfigPage({ engineId }: { engineId: string }) {
           .catch(() => null) as Promise<Analytics | null>,
       ]);
 
-      let foundEngine: EngineEntry | null = null;
-      if (enginesData) {
-        foundEngine = enginesData.engines?.find((e) => e.id === engineId) ?? null;
-      } else {
-        setLoadError(t("loadFailed"));
-      }
+      const foundEngine = enginesData?.engines?.find((e) => e.id === engineId) ?? null;
 
       // Detailed config lives in the engine's settings sub-object (when it has one);
-      // the on/off + level moved to the panel. 404/null/missing = schema defaults.
+      // the on/off + level moved to the panel. A missing sub-object means schema defaults.
       const subKey = SETTINGS_SUBOBJECT[engineId];
       const stored = subKey ? settingsData?.[subKey] : undefined;
-      const currentConfig: Record<string, unknown> =
-        stored && typeof stored === "object" ? (stored as Record<string, unknown>) : {};
 
       if (!cancelled) {
+        if (!enginesData) {
+          setLoadError(t("loadFailed"));
+        } else if (subKey && !settingsData) {
+          // Without the stored settings the form would show defaults as saved values, so
+          // Save stays off.
+          setLoadError(t("settingsLoadFailed"));
+        }
         if (analyticsData) setAnalytics(analyticsData);
         setEngine(foundEngine);
-        // Seed configState from defaultValues then override with the stored sub-object.
-        const defaults: Record<string, unknown> = {};
-        for (const field of foundEngine?.configSchema ?? []) {
-          defaults[field.key] = field.defaultValue;
-        }
-        // Do not seed lite.maxToolLength from the schema default. Persisting 2000
-        // would freeze the cap in settings and hide OMNIROUTE_LITE_MAX_TOOL_LENGTH.
-        // The form still shows 2000 via field.defaultValue until the operator edits it.
-        if (engineId === "lite" && currentConfig.maxToolLength === undefined) {
-          delete defaults.maxToolLength;
-        }
-        setConfigState({ ...defaults, ...currentConfig });
+        const seeded = seedEngineForm(engineId, foundEngine?.configSchema ?? [], stored);
+        setConfigState(seeded);
+        setSavedConfig(seeded);
         setLoading(false);
       }
     }
@@ -207,38 +208,56 @@ export function EngineConfigPage({ engineId }: { engineId: string }) {
       setSaveError(null);
       return;
     }
-    // Strip the `enabled` key — engine on/off is the panel's responsibility.
-    const { enabled: _ignored, ...formDetail } = configState;
-    void _ignored;
-    let detail: Record<string, unknown> = formDetail;
-    if (engineId === "lite") {
-      const raw = formDetail.maxToolLength;
-      const compressToolResults = formDetail.compressToolResults !== false;
-      if (!Object.prototype.hasOwnProperty.call(formDetail, "maxToolLength")) {
-        detail = { compressToolResults };
-      } else if (typeof raw === "number" && Number.isFinite(raw)) {
-        const n = Math.floor(raw);
-        if (n < 256 || n > 1_000_000) {
-          setSaveError(t("saveFailed"));
-          return;
-        }
-        detail = { compressToolResults, maxToolLength: n };
-      } else {
-        detail = { compressToolResults, maxToolLength: null };
-      }
+    // Lite's cap must be in range before anything is sent; the save floors it to a whole number.
+    // Only NaN (the emptied sentinel) skips the check — overflow like 1e999 fails the range below.
+    const cap = engineId === "lite" ? configState.maxToolLength : undefined;
+    if (
+      typeof cap === "number" &&
+      !Number.isNaN(cap) &&
+      (Math.floor(cap) < 256 || Math.floor(cap) > 1_000_000)
+    ) {
+      setSaveError(t("saveFailed"));
+      return;
     }
+    const sent = configState;
     setSaving(true);
     setSaveError(null);
     try {
+      // The body starts from the copy stored now and changes only the fields edited here. The
+      // server replaces each sub-object whole (lite merges), so a copy this page loaded earlier
+      // would write back fields another page saved since.
+      const current = (await fetch("/api/settings/compression")
+        .then((r) => (r.ok ? r.json() : null))
+        .catch(() => null)) as CompressionSettings | null;
+      if (!current) {
+        setSaveError(t("saveFailed"));
+        return;
+      }
+      const detail = buildEngineDetailUpdate(engineId, savedConfig, sent, current[subKey]);
       const res = await fetch("/api/settings/compression", {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ [subKey]: detail }),
       });
       if (!res.ok) {
+        setSavedConfig((saved) => forgetSentEdits(saved, sent));
         setSaveError(t("saveFailed"));
+        return;
       }
+      // Show what the server now holds, which can include fields another page changed, and
+      // keep anything typed while the save was out.
+      const settings = (await res.json().catch(() => null)) as CompressionSettings | null;
+      const written = seedEngineForm(
+        engineId,
+        engine?.configSchema ?? [],
+        settings?.[subKey] ?? detail
+      );
+      setSavedConfig(written);
+      setConfigState((now) => formAfterSave(written, sent, now));
     } catch {
+      // The PUT may have reached the server before the request failed, so the next save
+      // sends these fields again.
+      setSavedConfig((saved) => forgetSentEdits(saved, sent));
       setSaveError(t("saveFailed"));
     } finally {
       setSaving(false);
@@ -256,15 +275,15 @@ export function EngineConfigPage({ engineId }: { engineId: string }) {
         engineId === "headroom"
           ? {
               headroom: {
-                ...(typeof configState.minRows === "number"
+                ...(typeof configState.minRows === "number" && !Number.isNaN(configState.minRows)
                   ? { minRows: configState.minRows }
                   : {}),
               },
             }
           : engineId === "aggressive"
-            ? { aggressive: { ...configState } }
+            ? { aggressive: withoutEmptyText(configState) }
             : engineId === "ultra"
-              ? { ultra: { ...configState } }
+              ? { ultra: withoutEmptyText(configState) }
               : undefined;
       const res = await fetch("/api/compression/preview", {
         method: "POST",
@@ -379,7 +398,7 @@ export function EngineConfigPage({ engineId }: { engineId: string }) {
           <EngineConfigForm
             schema={visibleConfigSchema}
             value={configState}
-            onChange={setConfigState}
+            onChange={(key, next) => setConfigState((prev) => ({ ...prev, [key]: next }))}
           />
         ) : (
           <p className="text-sm text-text-muted">{t("noAdditionalConfiguration")}</p>
@@ -388,7 +407,7 @@ export function EngineConfigPage({ engineId }: { engineId: string }) {
           {persistable ? (
             <button
               onClick={handleSave}
-              disabled={saving}
+              disabled={saving || Boolean(loadError)}
               className="px-4 py-1.5 rounded bg-primary text-primary-foreground text-sm font-medium disabled:opacity-50"
             >
               {saving ? t("saving") : t("save")}
diff --git a/src/shared/components/compression/compressionPipelineModel.ts b/src/shared/components/compression/compressionPipelineModel.ts
index ca2f7b468c5b..37e74943a0ef 100644
--- a/src/shared/components/compression/compressionPipelineModel.ts
+++ b/src/shared/components/compression/compressionPipelineModel.ts
@@ -14,10 +14,7 @@ export type EngineIntensities = Record<string, readonly string[]>;
 const FALLBACK_INTENSITIES: readonly string[] = ["standard"];
 
 /** Intensities a given engine allows (falls back to `["standard"]` for unknown engines). */
-export function allowedIntensities(
-  engine: string,
-  table: EngineIntensities
-): readonly string[] {
+export function allowedIntensities(engine: string, table: EngineIntensities): readonly string[] {
   const list = table[engine];
   return list && list.length > 0 ? list : FALLBACK_INTENSITIES;
 }
@@ -54,11 +51,7 @@ export function addLayer(
 }
 
 /** Remove the layer at `index`, never dropping below `minLength` (default 1). */
-export function removeLayer(
-  steps: PipelineStep[],
-  index: number,
-  minLength = 1
-): PipelineStep[] {
+export function removeLayer(steps: PipelineStep[], index: number, minLength = 1): PipelineStep[] {
   if (steps.length <= minLength) return steps.slice();
   if (index < 0 || index >= steps.length) return steps.slice();
   return steps.filter((_, i) => i !== index);
@@ -72,7 +65,5 @@ export function updateLayer(
   table: EngineIntensities
 ): PipelineStep[] {
   if (index < 0 || index >= steps.length) return steps.slice();
-  return steps.map((step, i) =>
-    i === index ? normalizeStep({ ...step, ...patch }, table) : step
-  );
+  return steps.map((step, i) => (i === index ? normalizeStep({ ...step, ...patch }, table) : step));
 }
diff --git a/src/shared/components/compression/engineConfigSave.ts b/src/shared/components/compression/engineConfigSave.ts
new file mode 100644
index 000000000000..d5dc50e4037d
--- /dev/null
+++ b/src/shared/components/compression/engineConfigSave.ts
@@ -0,0 +1,104 @@
+import type { EngineConfigField } from "@omniroute/open-sse/services/compression/engines/types";
+
+type FormValues = Record<string, unknown>;
+
+function asRecord(value: unknown): FormValues {
+  return value && typeof value === "object" ? (value as FormValues) : {};
+}
+
+// The settings schemas reject an empty string, so an emptied text field means "not set".
+function isEmptyText(value: unknown): boolean {
+  return typeof value === "string" && value.trim() === "";
+}
+
+/** Form values an engine page shows: schema defaults, then the stored sub-object. */
+export function seedEngineForm(
+  engineId: string,
+  schema: EngineConfigField[],
+  stored: unknown
+): FormValues {
+  const current = asRecord(stored);
+  const defaults: FormValues = Object.fromEntries(schema.map((f) => [f.key, f.defaultValue]));
+  // Leave lite.maxToolLength out until a cap is stored. The baseline then has no cap, so an
+  // unset cap stays unset (OMNIROUTE_LITE_MAX_TOOL_LENGTH applies) and typing 2000 still counts
+  // as an edit. The form still shows 2000 through field.defaultValue.
+  if (engineId === "lite" && current.maxToolLength === undefined) {
+    delete defaults.maxToolLength;
+  }
+  return { ...defaults, ...current };
+}
+
+/**
+ * The sub-object an engine page PUTs on save. The server replaces each sub-object row whole
+ * (lite merges), so the body starts from the copy stored at save time and applies only the fields
+ * edited since `saved`. The page hides `enabled`, so the form never writes it and the stored value
+ * passes through. An emptied text field removes its key, and an emptied number field (NaN) leaves
+ * the body as not set — except lite's cap, which maps to null below.
+ */
+export function buildEngineDetailUpdate(
+  engineId: string,
+  saved: FormValues,
+  edited: FormValues,
+  stored: unknown
+): FormValues {
+  const next = { ...asRecord(stored) };
+  for (const [key, value] of Object.entries(edited)) {
+    if (key === "enabled" || Object.is(value, saved[key])) continue;
+    if (isEmptyText(value)) {
+      delete next[key];
+    } else if (typeof value === "number" && Number.isNaN(value)) {
+      // An emptied number input is the only source of NaN: it means "not set" and leaves the
+      // body, except lite's cap, which the lite merge below maps to null to drop the stored cap.
+      // Overflow (Infinity) is a value, not an unset: it stays, and a non-lite schema rejects the
+      // wire-null it serializes to. lite's cap null IS the clear sentinel, so only the page's cap
+      // range guard stops an overflow cap from silently clearing the stored cap.
+      if (engineId !== "lite" || key !== "maxToolLength") delete next[key];
+      else next[key] = value;
+    } else {
+      next[key] = value;
+    }
+  }
+  if (engineId !== "lite") return next;
+  // The lite settings schema accepts only these two fields. A cleared cap input holds NaN, and
+  // null tells the server to drop the stored cap.
+  const cap = next.maxToolLength;
+  return {
+    compressToolResults: next.compressToolResults !== false,
+    ...("maxToolLength" in next
+      ? { maxToolLength: typeof cap === "number" && Number.isNaN(cap) ? null : Math.floor(cap) }
+      : {}),
+  };
+}
+
+/** The form after a successful save: what the server now holds, plus edits made meanwhile. */
+export function formAfterSave(written: FormValues, sent: FormValues, now: FormValues): FormValues {
+  const next = { ...written };
+  for (const [key, value] of Object.entries(now)) {
+    if (!Object.is(value, sent[key])) next[key] = value;
+  }
+  return next;
+}
+
+/**
+ * The baseline after a failed save. The server may have applied the save before the request
+ * failed, so the fields it carried leave the baseline and the next save sends them again.
+ */
+export function forgetSentEdits(saved: FormValues, sent: FormValues): FormValues {
+  const next = { ...saved };
+  for (const [key, value] of Object.entries(sent)) {
+    if (!Object.is(value, saved[key])) delete next[key];
+  }
+  return next;
+}
+
+/**
+ * Form values without emptied text fields or emptied number fields (NaN), so a preview config
+ * passes the settings schema. Overflow values stay, so the schema rejects them visibly.
+ */
+export function withoutEmptyText(values: FormValues): FormValues {
+  return Object.fromEntries(
+    Object.entries(values).filter(
+      ([, value]) => !isEmptyText(value) && !(typeof value === "number" && Number.isNaN(value))
+    )
+  );
+}
diff --git a/tests/unit/compression/engine-config-empty-number.test.ts b/tests/unit/compression/engine-config-empty-number.test.ts
new file mode 100644
index 000000000000..acb32080af37
--- /dev/null
+++ b/tests/unit/compression/engine-config-empty-number.test.ts
@@ -0,0 +1,97 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+  buildEngineDetailUpdate,
+  withoutEmptyText,
+} from "../../../src/shared/components/compression/engineConfigSave.ts";
+
+type Settings = Record<string, unknown>;
+
+describe("engine config emptied numbers", () => {
+  it("leaves an emptied number field out of the PUT body", () => {
+    const saved: Settings = { minSavingsThreshold: 0.5, maxTokensPerMessage: 4096 };
+    const edited = { ...saved, minSavingsThreshold: Number.NaN };
+    const body = buildEngineDetailUpdate("aggressive", saved, edited, {
+      minSavingsThreshold: 0.5,
+      maxTokensPerMessage: 1024,
+    });
+
+    assert.equal(body.maxTokensPerMessage, 1024);
+    assert.ok(!("minSavingsThreshold" in body));
+  });
+
+  it("drops a stored value its number field clears", () => {
+    const saved: Settings = { minChars: 500 };
+    const body = buildEngineDetailUpdate("ccr", saved, { minChars: Number.NaN }, { minChars: 500 });
+
+    assert.deepEqual(body, {});
+  });
+
+  it("keeps a zero the operator typed", () => {
+    const saved: Settings = { minSavingsThreshold: 0.5 };
+    const body = buildEngineDetailUpdate(
+      "aggressive",
+      saved,
+      { minSavingsThreshold: 0 },
+      { minSavingsThreshold: 0.5 }
+    );
+
+    assert.deepEqual(body, { minSavingsThreshold: 0 });
+  });
+
+  it("maps the emptied Lite cap to null so the stored cap is dropped", () => {
+    const saved: Settings = { compressToolResults: true, maxToolLength: 8000 };
+    const body = buildEngineDetailUpdate(
+      "lite",
+      saved,
+      { ...saved, maxToolLength: Number.NaN },
+      { ...saved }
+    );
+
+    assert.deepEqual(body, { compressToolResults: true, maxToolLength: null });
+  });
+
+  it("drops emptied numbers from the preview config", () => {
+    const config = withoutEmptyText({
+      minSavingsThreshold: Number.NaN,
+      compressionRate: 0,
+      modelPath: "  ",
+      maxTokensPerMessage: 2048,
+    });
+
+    assert.deepEqual(config, { compressionRate: 0, maxTokensPerMessage: 2048 });
+  });
+
+  it("keeps an overflow value in the body so the settings schema rejects it", () => {
+    const saved: Settings = { minSavingsThreshold: 0.5 };
+    const body = buildEngineDetailUpdate(
+      "aggressive",
+      saved,
+      { minSavingsThreshold: Number("1e999") },
+      { minSavingsThreshold: 0.5 }
+    );
+
+    assert.deepEqual(body, { minSavingsThreshold: Number.POSITIVE_INFINITY });
+  });
+
+  it("keeps an overflow cap in the lite body, where the page range guard rejects it", () => {
+    const saved: Settings = { compressToolResults: true, maxToolLength: 8000 };
+    const body = buildEngineDetailUpdate(
+      "lite",
+      saved,
+      { ...saved, maxToolLength: Number("1e999") },
+      { ...saved }
+    );
+
+    assert.deepEqual(body, {
+      compressToolResults: true,
+      maxToolLength: Number.POSITIVE_INFINITY,
+    });
+  });
+
+  it("keeps an overflow value in the preview config so the schema rejects it", () => {
+    const config = withoutEmptyText({ compressionRate: Number("1e999") });
+
+    assert.deepEqual(config, { compressionRate: Number.POSITIVE_INFINITY });
+  });
+});
diff --git a/tests/unit/compression/engine-config-save.test.ts b/tests/unit/compression/engine-config-save.test.ts
new file mode 100644
index 000000000000..407d08741404
--- /dev/null
+++ b/tests/unit/compression/engine-config-save.test.ts
@@ -0,0 +1,309 @@
+import { describe, it, beforeEach, after } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-engine-config-save-"));
+const ORIGINAL_DATA_DIR = process.env.DATA_DIR;
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../../src/lib/db/core.ts");
+const { getCompressionSettings, updateCompressionSettings } =
+  await import("../../../src/lib/db/compression.ts");
+const { compressionPreviewConfigSchema, compressionSettingsUpdateSchema } =
+  await import("../../../src/shared/validation/compressionConfigSchemas.ts");
+const { aggressiveEngine, liteEngine, ultraEngine } =
+  await import("../../../open-sse/services/compression/engines/cavemanAdapter.ts");
+const { headroomEngine } =
+  await import("../../../open-sse/services/compression/engines/headroom/index.ts");
+const { sessionDedupEngine } =
+  await import("../../../open-sse/services/compression/engines/session-dedup/index.ts");
+const { ccrEngine } = await import("../../../open-sse/services/compression/engines/ccr/index.ts");
+const {
+  seedEngineForm,
+  buildEngineDetailUpdate,
+  formAfterSave,
+  forgetSentEdits,
+  withoutEmptyText,
+} = await import("../../../src/shared/components/compression/engineConfigSave.ts");
+
+type Settings = Record<string, unknown>;
+type Engine = typeof aggressiveEngine;
+
+beforeEach(() => {
+  core.resetDbInstance();
+  fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+});
+
+after(() => {
+  core.resetDbInstance();
+  fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+  if (ORIGINAL_DATA_DIR === undefined) {
+    delete process.env.DATA_DIR;
+  } else {
+    process.env.DATA_DIR = ORIGINAL_DATA_DIR;
+  }
+});
+
+async function readSettings(): Promise<Settings> {
+  return (await getCompressionSettings()) as unknown as Settings;
+}
+
+// Mirrors PUT /api/settings/compression: the route's schema validates the body, then the
+// settings are written.
+async function put(body: Settings): Promise<number> {
+  const parsed = compressionSettingsUpdateSchema.safeParse(body);
+  if (!parsed.success) return 400;
+  await updateCompressionSettings(parsed.data as Parameters<typeof updateCompressionSettings>[0]);
+  return 200;
+}
+
+// An engine page save: the form was seeded from `loadedSettings`, the operator applied
+// `edits`, and the body is built from a read made at save time.
+async function pageSave(
+  engine: Engine,
+  subKey: string,
+  loadedSettings: Settings,
+  edits: Settings
+): Promise<number> {
+  const loaded = seedEngineForm(engine.id, engine.getConfigSchema(), loadedSettings[subKey]);
+  const current = await readSettings();
+  return put({
+    [subKey]: buildEngineDetailUpdate(engine.id, loaded, { ...loaded, ...edits }, current[subKey]),
+  });
+}
+
+describe("engine config page save", () => {
+  it("keeps aggressive fields another page saved after the engine page loaded", async () => {
+    const loadedSettings = await readSettings();
+    const now = (await readSettings()).aggressive as Settings & {
+      thresholds: Settings;
+      toolStrategies: Settings;
+    };
+    const fromSettingsTab = {
+      ...now,
+      thresholds: { ...now.thresholds, fullSummary: 9 },
+      toolStrategies: { ...now.toolStrategies, json: false },
+      summarizerEnabled: false,
+    };
+    assert.equal(await put({ aggressive: fromSettingsTab }), 200);
+
+    const status = await pageSave(aggressiveEngine, "aggressive", loadedSettings, {
+      maxTokensPerMessage: 4096,
+    });
+
+    assert.equal(status, 200);
+    assert.deepEqual((await readSettings()).aggressive, {
+      ...fromSettingsTab,
+      maxTokensPerMessage: 4096,
+    });
+  });
+
+  it("saves the ultra page on a default install, where the form shows an empty model path", async () => {
+    const loadedSettings = await readSettings();
+    const before = loadedSettings.ultra as Settings;
+    assert.equal(before.modelPath, undefined);
+
+    const status = await pageSave(ultraEngine, "ultra", loadedSettings, { compressionRate: 0.4 });
+
+    assert.equal(status, 200);
+    assert.deepEqual((await readSettings()).ultra, { ...before, compressionRate: 0.4 });
+  });
+
+  it("keeps ultra.enabled and the model path when the ultra page saves another field", async () => {
+    const now = (await readSettings()).ultra as Settings;
+    assert.equal(await put({ ultra: { ...now, enabled: true, modelPath: "/models/ultra" } }), 200);
+    const loadedSettings = await readSettings();
+
+    const status = await pageSave(ultraEngine, "ultra", loadedSettings, { compressionRate: 0.4 });
+
+    assert.equal(status, 200);
+    assert.deepEqual((await readSettings()).ultra, {
+      ...now,
+      enabled: true,
+      modelPath: "/models/ultra",
+      compressionRate: 0.4,
+    });
+  });
+
+  it("clears the stored model path when the field is emptied", async () => {
+    const now = (await readSettings()).ultra as Settings;
+    assert.equal(await put({ ultra: { ...now, modelPath: "/models/ultra" } }), 200);
+    const loadedSettings = await readSettings();
+
+    const status = await pageSave(ultraEngine, "ultra", loadedSettings, { modelPath: "  " });
+
+    assert.equal(status, 200);
+    assert.deepEqual((await readSettings()).ultra, now);
+  });
+
+  it("never writes enabled from the page form", async () => {
+    const now = (await readSettings()).ultra as Settings;
+    assert.equal(await put({ ultra: { ...now, enabled: true } }), 200);
+    const loadedSettings = await readSettings();
+
+    const status = await pageSave(ultraEngine, "ultra", loadedSettings, { enabled: false });
+
+    assert.equal(status, 200);
+    assert.equal(((await readSettings()).ultra as Settings).enabled, true);
+  });
+
+  it("sends back the stored sub-object when nothing was edited", async () => {
+    const settings = await readSettings();
+    const loaded = seedEngineForm(
+      aggressiveEngine.id,
+      aggressiveEngine.getConfigSchema(),
+      settings.aggressive
+    );
+
+    assert.deepEqual(
+      buildEngineDetailUpdate(aggressiveEngine.id, loaded, loaded, settings.aggressive),
+      settings.aggressive
+    );
+  });
+
+  it("saves every engine page sub-object back unchanged when nothing was edited", async () => {
+    // Each save starts from the stored copy the settings read returns, so that copy has to
+    // pass the strict update schema for every engine page.
+    const pages: [Engine, string][] = [
+      [liteEngine, "lite"],
+      [aggressiveEngine, "aggressive"],
+      [ultraEngine, "ultra"],
+      [headroomEngine, "headroom"],
+      [sessionDedupEngine, "sessionDedup"],
+      [ccrEngine, "ccr"],
+    ];
+    for (const [engine, subKey] of pages) {
+      const loadedSettings = await readSettings();
+
+      assert.equal(await pageSave(engine, subKey, loadedSettings, {}), 200, subKey);
+      assert.deepEqual((await readSettings())[subKey], loadedSettings[subKey], subKey);
+    }
+  });
+
+  it("keeps the lite switch another page changed when the lite page edits the cap", async () => {
+    assert.equal(await put({ lite: { compressToolResults: true, maxToolLength: 8000 } }), 200);
+    const loadedSettings = await readSettings();
+    assert.equal(await put({ lite: { compressToolResults: false } }), 200);
+
+    const status = await pageSave(liteEngine, "lite", loadedSettings, { maxToolLength: 9000 });
+
+    assert.equal(status, 200);
+    assert.deepEqual((await readSettings()).lite, {
+      compressToolResults: false,
+      maxToolLength: 9000,
+    });
+  });
+
+  it("clears the stored lite cap when the cap input is emptied", async () => {
+    assert.equal(await put({ lite: { compressToolResults: true, maxToolLength: 8000 } }), 200);
+    const loadedSettings = await readSettings();
+
+    // A cleared number input holds NaN.
+    const status = await pageSave(liteEngine, "lite", loadedSettings, {
+      maxToolLength: Number.NaN,
+    });
+
+    assert.equal(status, 200);
+    assert.deepEqual((await readSettings()).lite, { compressToolResults: true });
+  });
+
+  it("leaves the lite cap unset when the lite page saves the switch", async () => {
+    const loadedSettings = await readSettings();
+    const form = seedEngineForm(liteEngine.id, liteEngine.getConfigSchema(), loadedSettings.lite);
+    assert.equal("maxToolLength" in form, false);
+
+    const status = await pageSave(liteEngine, "lite", loadedSettings, {
+      compressToolResults: false,
+    });
+
+    assert.equal(status, 200);
+    assert.deepEqual((await readSettings()).lite, { compressToolResults: false });
+  });
+
+  it("sends a field again after a save whose response was lost", async () => {
+    const loadedSettings = await readSettings();
+    const loaded = seedEngineForm(
+      ultraEngine.id,
+      ultraEngine.getConfigSchema(),
+      loadedSettings.ultra
+    );
+    const sent = { ...loaded, compressionRate: 0.4 };
+    // The server applies this save, but the response is lost, so the page reports a failure.
+    const current = (await readSettings()).ultra;
+    assert.equal(
+      await put({ ultra: buildEngineDetailUpdate(ultraEngine.id, loaded, sent, current) }),
+      200
+    );
+    const baseline = forgetSentEdits(loaded, sent);
+
+    // The operator puts the loaded value back and saves again.
+    const restored = { ...sent, compressionRate: loaded.compressionRate };
+    const afterLostSave = (await readSettings()).ultra;
+    assert.equal(
+      await put({
+        ultra: buildEngineDetailUpdate(ultraEngine.id, baseline, restored, afterLostSave),
+      }),
+      200
+    );
+
+    assert.deepEqual((await readSettings()).ultra, loadedSettings.ultra);
+  });
+
+  it("shows another page's value after a save, so typing the loaded value back sends it", async () => {
+    const loadedSettings = await readSettings();
+    const schema = ultraEngine.getConfigSchema();
+    const loaded = seedEngineForm(ultraEngine.id, schema, loadedSettings.ultra);
+    assert.equal(
+      await put({ ultra: { ...(loadedSettings.ultra as Settings), compressionRate: 0.9 } }),
+      200
+    );
+
+    // The page saves a different field. The PUT response is the settings read after the write.
+    const sent = { ...loaded, minScoreThreshold: 0.6 };
+    const current = (await readSettings()).ultra;
+    assert.equal(
+      await put({ ultra: buildEngineDetailUpdate(ultraEngine.id, loaded, sent, current) }),
+      200
+    );
+    const written = seedEngineForm(ultraEngine.id, schema, (await readSettings()).ultra);
+    const shown = formAfterSave(written, sent, sent);
+    assert.equal(shown.compressionRate, 0.9);
+
+    const retyped = { ...shown, compressionRate: loaded.compressionRate };
+    const afterSave = (await readSettings()).ultra;
+    assert.equal(
+      await put({ ultra: buildEngineDetailUpdate(ultraEngine.id, written, retyped, afterSave) }),
+      200
+    );
+
+    assert.deepEqual((await readSettings()).ultra, {
+      ...(loadedSettings.ultra as Settings),
+      minScoreThreshold: 0.6,
+    });
+  });
+
+  it("keeps an edit typed while a save was in flight", () => {
+    const sent = { compressionRate: 0.4, modelPath: "" };
+    const now = { compressionRate: 0.4, modelPath: "/models/ultra" };
+    const written = { compressionRate: 0.4, modelPath: "", enabled: true };
+
+    assert.deepEqual(formAfterSave(written, sent, now), {
+      compressionRate: 0.4,
+      modelPath: "/models/ultra",
+      enabled: true,
+    });
+  });
+
+  it("builds an ultra preview config that the preview schema accepts on a default install", async () => {
+    const settings = await readSettings();
+    const form = seedEngineForm(ultraEngine.id, ultraEngine.getConfigSchema(), settings.ultra);
+    assert.equal(form.modelPath, "");
+
+    const parsed = compressionPreviewConfigSchema.safeParse({ ultra: withoutEmptyText(form) });
+
+    assert.equal(parsed.success, true);
+  });
+});
diff --git a/tests/unit/ui/engine-config-page-empty-number.test.tsx b/tests/unit/ui/engine-config-page-empty-number.test.tsx
new file mode 100644
index 000000000000..f0068d325762
--- /dev/null
+++ b/tests/unit/ui/engine-config-page-empty-number.test.tsx
@@ -0,0 +1,320 @@
+// @vitest-environment jsdom
+import { act, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { EngineConfigPage } from "@/shared/components/compression/EngineConfigPage";
+import {
+  compressionPreviewConfigSchema,
+  compressionSettingsUpdateSchema,
+} from "@/shared/validation/compressionConfigSchemas";
+import {
+  aggressiveEngine,
+  liteEngine,
+  ultraEngine,
+} from "@omniroute/open-sse/services/compression/engines/cavemanAdapter.ts";
+import { headroomEngine } from "@omniroute/open-sse/services/compression/engines/headroom/index.ts";
+import { ccrEngine } from "@omniroute/open-sse/services/compression/engines/ccr/index.ts";
+import { DEFAULT_AGGRESSIVE_CONFIG } from "@omniroute/open-sse/services/compression/types.ts";
+
+type Settings = Record<string, unknown>;
+
+// The same fields GET /api/compression/engines returns, taken from the real engines.
+const ENGINES = {
+  engines: [aggressiveEngine, ultraEngine, liteEngine, headroomEngine, ccrEngine].map((engine) => ({
+    id: engine.id,
+    name: engine.name,
+    description: engine.description,
+    icon: engine.icon,
+    stackable: engine.stackable,
+    stackPriority: engine.stackPriority,
+    metadata: engine.metadata,
+    configSchema: engine.getConfigSchema(),
+  })),
+};
+
+// Lite rows merge with the stored row, as mergeLiteSettingsForWrite does: an omitted cap stays,
+// and a null cap is cleared.
+function mergeLite(existing: unknown, incoming: Settings): Settings {
+  const merged: Settings = { ...(existing as Settings), ...incoming };
+  if (merged.maxToolLength === null) delete merged.maxToolLength;
+  return merged;
+}
+
+// Stands in for /api/settings/compression. A PUT is checked against the real update schema,
+// and each key in its body replaces the stored sub-object whole, as updateCompressionSettings
+// does, except lite, which merges. A preview's config is checked against the preview route's
+// schema.
+function startServer(initial: Settings) {
+  let stored: Settings = JSON.parse(JSON.stringify(initial));
+  let held: Promise<void> | null = null;
+  let releaseHeld: () => void = () => {};
+  const server = {
+    puts: [] as { body: Settings; status: number }[],
+    previews: [] as { config: unknown; status: number }[],
+    // The next PUT answers 500 without applying, as a transient server failure would.
+    failNextPut: false,
+    // Keeps PUTs waiting until the returned release runs, as a slow server would.
+    holdWrites() {
+      held = new Promise((resolve) => {
+        releaseHeld = () => {
+          held = null;
+          resolve();
+        };
+      });
+      return releaseHeld;
+    },
+    get stored() {
+      return stored;
+    },
+  };
+  const respond = (data: unknown, status = 200) =>
+    new Response(JSON.stringify(data), {
+      status,
+      headers: { "Content-Type": "application/json" },
+    });
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+      const { pathname } = new URL(String(input), "http://localhost");
+      if (pathname === "/api/compression/engines") return respond(ENGINES);
+      if (pathname === "/api/context/analytics/engine") {
+        return respond({ engineId: "", runs: 0, tokensSaved: 0, avgSavingsPercent: 0, days: 7 });
+      }
+      if (pathname === "/api/settings/compression") {
+        if (init?.method !== "PUT") return respond(stored);
+        const body = JSON.parse(String(init.body)) as Settings;
+        const parsed = compressionSettingsUpdateSchema.safeParse(body);
+        server.puts.push({ body, status: parsed.success ? 200 : 400 });
+        if (!parsed.success) return respond({ error: "Invalid request" }, 400);
+        if (server.failNextPut) {
+          server.failNextPut = false;
+          return respond({ error: "unavailable" }, 500);
+        }
+        if (held) await held;
+        const { lite, ...rest } = parsed.data as Settings;
+        stored = { ...stored, ...rest };
+        if (lite) stored.lite = mergeLite(stored.lite, lite as Settings);
+        return respond(stored);
+      }
+      if (pathname === "/api/compression/preview") {
+        const { config } = JSON.parse(String(init?.body)) as { config?: unknown };
+        const parsed = compressionPreviewConfigSchema.optional().safeParse(config);
+        server.previews.push({ config, status: parsed.success ? 200 : 400 });
+        if (!parsed.success) return respond({ error: "Invalid request" }, 400);
+        return respond({
+          original: "original text",
+          compressed: "compressed text",
+          originalTokens: 4,
+          compressedTokens: 2,
+          savingsPct: 50,
+        });
+      }
+      return respond(null, 404);
+    })
+  );
+  return server;
+}
+
+async function settle() {
+  for (let i = 0; i < 3; i++) {
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    });
+  }
+}
+
+function inputFor(label: string): HTMLInputElement {
+  const input = screen.getByText(label).closest("label")?.querySelector("input");
+  if (!input) throw new Error(`no input for ${label}`);
+  return input;
+}
+
+async function renderPage(engineId: string) {
+  render(<EngineConfigPage engineId={engineId} />);
+  await settle();
+}
+
+async function save() {
+  fireEvent.click(screen.getByRole("button", { name: "Save" }));
+  await settle();
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe("EngineConfigPage treats an emptied number field as not set", () => {
+  it("keeps an emptied number field empty instead of writing zero", async () => {
+    const server = startServer({
+      aggressive: { ...DEFAULT_AGGRESSIVE_CONFIG, minSavingsThreshold: 0.5 },
+    });
+    await renderPage("aggressive");
+
+    fireEvent.change(inputFor("Minimum savings threshold"), { target: { value: "" } });
+    await settle();
+
+    expect(inputFor("Minimum savings threshold").value).toBe("");
+    // The blank state shows the schema default as a placeholder, so "default applies" is visible.
+    expect(inputFor("Minimum savings threshold").placeholder.length).toBeGreaterThan(0);
+    expect(server.puts).toHaveLength(0);
+  });
+
+  it("saves an emptied number field as unset", async () => {
+    const server = startServer({
+      aggressive: { ...DEFAULT_AGGRESSIVE_CONFIG, minSavingsThreshold: 0.5 },
+    });
+    await renderPage("aggressive");
+
+    fireEvent.change(inputFor("Minimum savings threshold"), { target: { value: "" } });
+    await save();
+
+    expect(server.puts.at(-1)?.status).toBe(200);
+    const { minSavingsThreshold: _unset, ...defaults } = DEFAULT_AGGRESSIVE_CONFIG;
+    expect(server.stored.aggressive).toEqual(defaults);
+    expect(screen.queryByText("Failed to save configuration.")).toBeNull();
+  });
+
+  it("saves a page whose emptied field rejects zero", async () => {
+    const server = startServer({ ccr: { minChars: 500 } });
+    await renderPage("ccr");
+
+    fireEvent.change(inputFor("Minimum block characters"), { target: { value: "" } });
+    await save();
+
+    expect(server.puts.at(-1)?.status).toBe(200);
+    expect(server.stored.ccr).toEqual({});
+    expect(screen.queryByText("Failed to save configuration.")).toBeNull();
+  });
+
+  it("previews without an emptied number field", async () => {
+    const server = startServer({ headroom: { minRows: 8 } });
+    await renderPage("headroom");
+
+    fireEvent.change(inputFor("Minimum rows to compact"), { target: { value: "" } });
+    fireEvent.click(screen.getByRole("button", { name: "Preview" }));
+    await settle();
+
+    expect(server.previews.at(-1)?.status).toBe(200);
+    expect(server.previews.at(-1)?.config).toEqual({ headroom: {} });
+    expect(screen.queryByText("Preview failed.")).toBeNull();
+  });
+
+  it("still clears the stored Lite cap when the field is emptied", async () => {
+    const server = startServer({ lite: { compressToolResults: true, maxToolLength: 8000 } });
+    await renderPage("lite");
+
+    fireEvent.change(inputFor("Maximum tool-result length"), { target: { value: "" } });
+    await save();
+
+    expect(server.puts.at(-1)?.status).toBe(200);
+    expect(server.stored.lite).toEqual({ compressToolResults: true });
+  });
+
+  it("keeps a zero the operator types", async () => {
+    const server = startServer({ aggressive: DEFAULT_AGGRESSIVE_CONFIG });
+    await renderPage("aggressive");
+
+    fireEvent.change(inputFor("Minimum savings threshold"), { target: { value: "0" } });
+    await save();
+
+    expect(server.puts.at(-1)?.status).toBe(200);
+    expect((server.stored.aggressive as Settings).minSavingsThreshold).toBe(0);
+  });
+
+  it("rejects an overflow cap instead of silently clearing it", async () => {
+    // jsdom empties "1e999", so the overflow arrives as the finite 9e300; the range check it
+    // hits is the same one Infinity fails, since only NaN skips the check.
+    const server = startServer({ lite: { compressToolResults: true, maxToolLength: 8000 } });
+    await renderPage("lite");
+
+    fireEvent.change(inputFor("Maximum tool-result length"), { target: { value: "9e300" } });
+    await save();
+
+    expect(server.puts).toHaveLength(0);
+    expect(screen.getByText("Failed to save configuration.")).toBeTruthy();
+    expect((server.stored.lite as Settings).maxToolLength).toBe(8000);
+  });
+
+  it("keeps an emptied field unset through a failed save and its retry", async () => {
+    const server = startServer({
+      aggressive: { ...DEFAULT_AGGRESSIVE_CONFIG, minSavingsThreshold: 0.5 },
+    });
+    await renderPage("aggressive");
+
+    server.failNextPut = true;
+    fireEvent.change(inputFor("Minimum savings threshold"), { target: { value: "" } });
+    await save();
+    expect(screen.getByText("Failed to save configuration.")).toBeTruthy();
+    expect(inputFor("Minimum savings threshold").value).toBe("");
+
+    await save();
+
+    expect(server.puts.at(-1)?.status).toBe(200);
+    const { minSavingsThreshold: _unset, ...defaults } = DEFAULT_AGGRESSIVE_CONFIG;
+    expect(server.stored.aggressive).toEqual(defaults);
+  });
+
+  it("previews a stored finite minRows", async () => {
+    const server = startServer({ headroom: { minRows: 8 } });
+    await renderPage("headroom");
+
+    fireEvent.click(screen.getByRole("button", { name: "Preview" }));
+    await settle();
+
+    expect(server.previews.at(-1)?.status).toBe(200);
+    expect(server.previews.at(-1)?.config).toEqual({ headroom: { minRows: 8 } });
+  });
+
+  it("shows the schema default again after an emptied field saves", async () => {
+    const server = startServer({
+      aggressive: { ...DEFAULT_AGGRESSIVE_CONFIG, minSavingsThreshold: 0.5 },
+    });
+    await renderPage("aggressive");
+
+    fireEvent.change(inputFor("Minimum savings threshold"), { target: { value: "" } });
+    await save();
+
+    expect(server.puts.at(-1)?.status).toBe(200);
+    expect(inputFor("Minimum savings threshold").value).toBe(
+      String(DEFAULT_AGGRESSIVE_CONFIG.minSavingsThreshold)
+    );
+  });
+
+  it("keeps the stored value when a field reports badInput instead of unsetting it", async () => {
+    // A browser reports badInput with an empty value for unparseable entries ("1e", "1,5" in a
+    // comma-decimal locale); jsdom never sets the flag, so the test stubs it.
+    const server = startServer({
+      aggressive: { ...DEFAULT_AGGRESSIVE_CONFIG, minSavingsThreshold: 0.5 },
+    });
+    await renderPage("aggressive");
+    const input = inputFor("Minimum savings threshold");
+    Object.defineProperty(input, "validity", {
+      value: { ...input.validity, badInput: true },
+      configurable: true,
+    });
+
+    fireEvent.change(input, { target: { value: "1e" } });
+    await save();
+
+    expect(server.puts.at(-1)?.status).toBe(200);
+    expect((server.stored.aggressive as Settings).minSavingsThreshold).toBe(0.5);
+  });
+
+  it("clears a cap emptied while a save was in flight", async () => {
+    const server = startServer({ lite: { compressToolResults: true, maxToolLength: 3000 } });
+    await renderPage("lite");
+    const release = server.holdWrites();
+
+    fireEvent.change(inputFor("Maximum tool-result length"), { target: { value: "3500" } });
+    await save();
+    // The cap is emptied while the first save is still out.
+    fireEvent.change(inputFor("Maximum tool-result length"), { target: { value: "" } });
+    release();
+    await settle();
+    expect((server.stored.lite as Settings).maxToolLength).toBe(3500);
+
+    await save();
+
+    expect(server.puts.at(-1)?.status).toBe(200);
+    expect(server.stored.lite).toEqual({ compressToolResults: true });
+  });
+});
diff --git a/tests/unit/ui/engine-config-page-partial-save.test.tsx b/tests/unit/ui/engine-config-page-partial-save.test.tsx
new file mode 100644
index 000000000000..8195711a4feb
--- /dev/null
+++ b/tests/unit/ui/engine-config-page-partial-save.test.tsx
@@ -0,0 +1,451 @@
+// @vitest-environment jsdom
+import { act, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { EngineConfigPage } from "@/shared/components/compression/EngineConfigPage";
+import {
+  compressionPreviewConfigSchema,
+  compressionSettingsUpdateSchema,
+} from "@/shared/validation/compressionConfigSchemas";
+import {
+  aggressiveEngine,
+  liteEngine,
+  ultraEngine,
+} from "@omniroute/open-sse/services/compression/engines/cavemanAdapter.ts";
+import {
+  DEFAULT_AGGRESSIVE_CONFIG,
+  DEFAULT_ULTRA_CONFIG,
+} from "@omniroute/open-sse/services/compression/types.ts";
+
+type Settings = Record<string, unknown>;
+
+// The same fields GET /api/compression/engines returns, taken from the real engines.
+const ENGINES = {
+  engines: [aggressiveEngine, ultraEngine, liteEngine].map((engine) => ({
+    id: engine.id,
+    name: engine.name,
+    description: engine.description,
+    icon: engine.icon,
+    stackable: engine.stackable,
+    stackPriority: engine.stackPriority,
+    metadata: engine.metadata,
+    configSchema: engine.getConfigSchema(),
+  })),
+};
+
+// Lite rows merge with the stored row, as mergeLiteSettingsForWrite does: an omitted cap stays,
+// and a null cap is cleared.
+function mergeLite(existing: unknown, incoming: Settings): Settings {
+  const merged: Settings = { ...(existing as Settings), ...incoming };
+  if (merged.maxToolLength === null) delete merged.maxToolLength;
+  return merged;
+}
+
+// Stands in for /api/settings/compression. A PUT is checked against the real update schema,
+// and each key in its body replaces the stored sub-object whole, as updateCompressionSettings
+// does, except lite, which merges. `readsFail` makes GETs fail. `holdNextRead` keeps the next GET
+// waiting until the returned function runs, then fails it. `failNextWrite` answers the next PUT
+// with a 500, either before applying it ("rejected") or after ("applied"). `loseNextResponse`
+// applies the next PUT and then fails the request, as a dropped connection would. `holdWrites`
+// keeps PUTs waiting until the returned function runs. A preview's config is checked against the
+// preview route's schema.
+function startServer(initial: Settings) {
+  let stored: Settings = JSON.parse(JSON.stringify(initial));
+  let held: Promise<void> | null = null;
+  let heldRead: Promise<void> | null = null;
+  const server = {
+    readsFail: false,
+    failNextWrite: null as null | "rejected" | "applied",
+    loseNextResponse: false,
+    puts: [] as { body: Settings; status: number }[],
+    previews: [] as { config: unknown; status: number }[],
+    get stored() {
+      return stored;
+    },
+    // A save made on another page, such as the compression settings tab.
+    write(patch: Settings) {
+      stored = { ...stored, ...patch };
+    },
+    holdWrites() {
+      let release = () => {};
+      held = new Promise((resolve) => {
+        release = () => {
+          held = null;
+          resolve();
+        };
+      });
+      return release;
+    },
+    holdNextRead() {
+      let fail = () => {};
+      heldRead = new Promise((resolve) => {
+        fail = () => resolve();
+      });
+      return fail;
+    },
+  };
+  const respond = (data: unknown, status = 200) =>
+    new Response(JSON.stringify(data), {
+      status,
+      headers: { "Content-Type": "application/json" },
+    });
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+      const { pathname } = new URL(String(input), "http://localhost");
+      if (pathname === "/api/compression/engines") return respond(ENGINES);
+      if (pathname === "/api/context/analytics/engine") {
+        return respond({ engineId: "", runs: 0, tokensSaved: 0, avgSavingsPercent: 0, days: 7 });
+      }
+      if (pathname === "/api/settings/compression") {
+        if (init?.method !== "PUT") {
+          if (heldRead) {
+            const wait = heldRead;
+            heldRead = null;
+            await wait;
+            return respond({ error: "unavailable" }, 500);
+          }
+          return server.readsFail ? respond({ error: "unavailable" }, 500) : respond(stored);
+        }
+        const body = JSON.parse(String(init.body)) as Settings;
+        const parsed = compressionSettingsUpdateSchema.safeParse(body);
+        server.puts.push({ body, status: parsed.success ? 200 : 400 });
+        if (!parsed.success) return respond({ error: "Invalid request" }, 400);
+        if (held) await held;
+        if (server.failNextWrite === "rejected") {
+          server.failNextWrite = null;
+          return respond({ error: "unavailable" }, 500);
+        }
+        const { lite, ...rest } = parsed.data as Settings;
+        stored = { ...stored, ...rest };
+        if (lite) stored.lite = mergeLite(stored.lite, lite as Settings);
+        if (server.failNextWrite === "applied") {
+          server.failNextWrite = null;
+          return respond({ error: "unavailable" }, 500);
+        }
+        if (server.loseNextResponse) {
+          server.loseNextResponse = false;
+          throw new TypeError("Failed to fetch");
+        }
+        return respond(stored);
+      }
+      if (pathname === "/api/compression/preview") {
+        const { config } = JSON.parse(String(init?.body)) as { config?: unknown };
+        const parsed = compressionPreviewConfigSchema.optional().safeParse(config);
+        server.previews.push({ config, status: parsed.success ? 200 : 400 });
+        if (!parsed.success) return respond({ error: "Invalid request" }, 400);
+        return respond({
+          original: "original text",
+          compressed: "compressed text",
+          originalTokens: 4,
+          compressedTokens: 2,
+          savingsPct: 50,
+        });
+      }
+      return respond(null, 404);
+    })
+  );
+  return server;
+}
+
+async function settle() {
+  for (let i = 0; i < 3; i++) {
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    });
+  }
+}
+
+function inputFor(label: string): HTMLInputElement {
+  const input = screen.getByText(label).closest("label")?.querySelector("input");
+  if (!input) throw new Error(`no input for ${label}`);
+  return input;
+}
+
+async function renderPage(engineId: string) {
+  render(<EngineConfigPage engineId={engineId} />);
+  await settle();
+}
+
+async function save() {
+  fireEvent.click(screen.getByRole("button", { name: "Save" }));
+  await settle();
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe("EngineConfigPage saves only what the operator changed", () => {
+  it("keeps Aggressive thresholds and tool strategies saved elsewhere after the page loaded", async () => {
+    const server = startServer({ aggressive: DEFAULT_AGGRESSIVE_CONFIG });
+    await renderPage("aggressive");
+    // The compression settings tab edits the same sub-object after this page loaded.
+    const fromSettingsTab = {
+      ...DEFAULT_AGGRESSIVE_CONFIG,
+      thresholds: { ...DEFAULT_AGGRESSIVE_CONFIG.thresholds, fullSummary: 9 },
+      toolStrategies: { ...DEFAULT_AGGRESSIVE_CONFIG.toolStrategies, json: false },
+      summarizerEnabled: false,
+    };
+    server.write({ aggressive: fromSettingsTab });
+
+    fireEvent.change(inputFor("Maximum tokens per message"), { target: { value: "4096" } });
+    await save();
+
+    expect(server.puts.at(-1)?.status).toBe(200);
+    expect(server.stored.aggressive).toEqual({ ...fromSettingsTab, maxTokensPerMessage: 4096 });
+  });
+
+  it("saves the Ultra page on a default install that has no model path", async () => {
+    const server = startServer({ ultra: DEFAULT_ULTRA_CONFIG });
+    await renderPage("ultra");
+
+    fireEvent.change(inputFor("Compression rate"), { target: { value: "0.4" } });
+    await save();
+
+    expect(server.puts.at(-1)?.status).toBe(200);
+    expect(server.stored.ultra).toEqual({ ...DEFAULT_ULTRA_CONFIG, compressionRate: 0.4 });
+    expect(screen.queryByText("Failed to save configuration.")).toBeNull();
+  });
+
+  it("keeps ultra.enabled when the Ultra page saves", async () => {
+    const server = startServer({
+      ultra: { ...DEFAULT_ULTRA_CONFIG, enabled: true, modelPath: "/models/ultra" },
+    });
+    await renderPage("ultra");
+
+    fireEvent.change(inputFor("Compression rate"), { target: { value: "0.4" } });
+    await save();
+
+    expect(server.puts.at(-1)?.status).toBe(200);
+    expect(server.stored.ultra).toEqual({
+      ...DEFAULT_ULTRA_CONFIG,
+      enabled: true,
+      modelPath: "/models/ultra",
+      compressionRate: 0.4,
+    });
+  });
+
+  it("clears a stored model path when the field is emptied", async () => {
+    const server = startServer({ ultra: { ...DEFAULT_ULTRA_CONFIG, modelPath: "/models/ultra" } });
+    await renderPage("ultra");
+
+    fireEvent.change(inputFor("Model path"), { target: { value: "  " } });
+    await save();
+
+    expect(server.puts.at(-1)?.status).toBe(200);
+    expect(server.stored.ultra).toEqual(DEFAULT_ULTRA_CONFIG);
+  });
+
+  it("fails the save without writing when the current settings cannot be read", async () => {
+    const server = startServer({ aggressive: DEFAULT_AGGRESSIVE_CONFIG });
+    await renderPage("aggressive");
+    server.readsFail = true;
+
+    fireEvent.change(inputFor("Maximum tokens per message"), { target: { value: "4096" } });
+    await save();
+
+    expect(server.puts).toHaveLength(0);
+    expect(screen.getByText("Failed to save configuration.")).toBeTruthy();
+  });
+
+  it("sends a second save's change without resending the first one", async () => {
+    const server = startServer({ aggressive: DEFAULT_AGGRESSIVE_CONFIG });
+    await renderPage("aggressive");
+
+    fireEvent.change(inputFor("Maximum tokens per message"), { target: { value: "4096" } });
+    await save();
+    // Another page sets the same field back after the first save.
+    server.write({ aggressive: { ...DEFAULT_AGGRESSIVE_CONFIG, maxTokensPerMessage: 1024 } });
+
+    fireEvent.change(inputFor("Minimum savings threshold"), { target: { value: "0.2" } });
+    await save();
+
+    expect(server.stored.aggressive).toEqual({
+      ...DEFAULT_AGGRESSIVE_CONFIG,
+      maxTokensPerMessage: 1024,
+      minSavingsThreshold: 0.2,
+    });
+  });
+
+  it("shows the stored values after a save, so a value typed back afterwards is sent", async () => {
+    const server = startServer({ aggressive: DEFAULT_AGGRESSIVE_CONFIG });
+    await renderPage("aggressive");
+    // Another page changes a field this page shows, after it loaded.
+    server.write({ aggressive: { ...DEFAULT_AGGRESSIVE_CONFIG, maxTokensPerMessage: 1024 } });
+
+    fireEvent.change(inputFor("Minimum savings threshold"), { target: { value: "0.2" } });
+    await save();
+
+    expect(inputFor("Maximum tokens per message").value).toBe("1024");
+
+    fireEvent.change(inputFor("Maximum tokens per message"), {
+      target: { value: String(DEFAULT_AGGRESSIVE_CONFIG.maxTokensPerMessage) },
+    });
+    await save();
+
+    expect(server.stored.aggressive).toEqual({
+      ...DEFAULT_AGGRESSIVE_CONFIG,
+      minSavingsThreshold: 0.2,
+    });
+  });
+
+  it("sends a field again after a save whose response was lost", async () => {
+    const server = startServer({ ultra: DEFAULT_ULTRA_CONFIG });
+    await renderPage("ultra");
+
+    // The server applies the write, but the response never arrives.
+    server.loseNextResponse = true;
+    fireEvent.change(inputFor("Compression rate"), { target: { value: "0.4" } });
+    await save();
+    expect(screen.getByText("Failed to save configuration.")).toBeTruthy();
+    expect((server.stored.ultra as Settings).compressionRate).toBe(0.4);
+
+    // The operator puts the loaded value back and saves again.
+    fireEvent.change(inputFor("Compression rate"), {
+      target: { value: String(DEFAULT_ULTRA_CONFIG.compressionRate) },
+    });
+    await save();
+
+    expect(server.puts.at(-1)?.status).toBe(200);
+    expect(server.stored.ultra).toEqual(DEFAULT_ULTRA_CONFIG);
+  });
+
+  it("keeps an edit typed while a save is in flight", async () => {
+    const server = startServer({ aggressive: DEFAULT_AGGRESSIVE_CONFIG });
+    await renderPage("aggressive");
+    const release = server.holdWrites();
+
+    fireEvent.change(inputFor("Maximum tokens per message"), { target: { value: "4096" } });
+    await save();
+    fireEvent.change(inputFor("Minimum savings threshold"), { target: { value: "0.2" } });
+    release();
+    await settle();
+
+    expect(inputFor("Minimum savings threshold").value).toBe("0.2");
+    await save();
+
+    expect(server.stored.aggressive).toEqual({
+      ...DEFAULT_AGGRESSIVE_CONFIG,
+      maxTokensPerMessage: 4096,
+      minSavingsThreshold: 0.2,
+    });
+  });
+
+  it("keeps the Lite switch another page changed when this page edits the cap", async () => {
+    const server = startServer({ lite: { compressToolResults: true, maxToolLength: 8000 } });
+    await renderPage("lite");
+    server.write({ lite: { compressToolResults: false, maxToolLength: 8000 } });
+
+    fireEvent.change(inputFor("Maximum tool-result length"), { target: { value: "9000" } });
+    await save();
+
+    expect(server.puts.at(-1)?.status).toBe(200);
+    expect(server.stored.lite).toEqual({ compressToolResults: false, maxToolLength: 9000 });
+  });
+
+  it("turns Save off when the stored settings cannot be loaded", async () => {
+    const server = startServer({ aggressive: DEFAULT_AGGRESSIVE_CONFIG });
+    server.readsFail = true;
+    await renderPage("aggressive");
+
+    expect(
+      screen.getByText(
+        "Failed to load the saved settings. The fields show defaults, and Save stays off until the page reloads."
+      )
+    ).toBeTruthy();
+    expect((screen.getByRole("button", { name: "Save" }) as HTMLButtonElement).disabled).toBe(true);
+  });
+
+  it("ignores a settings read that fails after the page reloads", async () => {
+    const server = startServer({
+      ultra: DEFAULT_ULTRA_CONFIG,
+      aggressive: DEFAULT_AGGRESSIVE_CONFIG,
+    });
+    const failFirstRead = server.holdNextRead();
+    const { rerender } = render(<EngineConfigPage engineId="ultra" />);
+    await settle();
+    // The page reloads before the first settings read answers.
+    rerender(<EngineConfigPage engineId="aggressive" />);
+    await settle();
+    failFirstRead();
+    await settle();
+
+    expect(screen.queryByText(/Failed to load/)).toBeNull();
+    expect((screen.getByRole("button", { name: "Save" }) as HTMLButtonElement).disabled).toBe(
+      false
+    );
+  });
+
+  it("keeps an edit after a rejected save, so the next save sends it", async () => {
+    const server = startServer({ ultra: DEFAULT_ULTRA_CONFIG });
+    await renderPage("ultra");
+    server.failNextWrite = "rejected";
+
+    fireEvent.change(inputFor("Compression rate"), { target: { value: "0.4" } });
+    await save();
+    expect(screen.getByText("Failed to save configuration.")).toBeTruthy();
+    expect(server.stored.ultra).toEqual(DEFAULT_ULTRA_CONFIG);
+
+    await save();
+
+    expect(server.stored.ultra).toEqual({ ...DEFAULT_ULTRA_CONFIG, compressionRate: 0.4 });
+  });
+
+  it("sends a field again after a save the server applied but answered with an error", async () => {
+    const server = startServer({ ultra: DEFAULT_ULTRA_CONFIG });
+    await renderPage("ultra");
+    server.failNextWrite = "applied";
+
+    fireEvent.change(inputFor("Compression rate"), { target: { value: "0.4" } });
+    await save();
+    expect(screen.getByText("Failed to save configuration.")).toBeTruthy();
+    expect((server.stored.ultra as Settings).compressionRate).toBe(0.4);
+
+    // The operator puts the loaded value back and saves again.
+    fireEvent.change(inputFor("Compression rate"), {
+      target: { value: String(DEFAULT_ULTRA_CONFIG.compressionRate) },
+    });
+    await save();
+
+    expect(server.stored.ultra).toEqual(DEFAULT_ULTRA_CONFIG);
+  });
+
+  it("keeps another page's value when a keystroke lands as a save finishes", async () => {
+    const server = startServer({ aggressive: DEFAULT_AGGRESSIVE_CONFIG });
+    await renderPage("aggressive");
+    // Another page changes a field this page shows, after it loaded.
+    server.write({ aggressive: { ...DEFAULT_AGGRESSIVE_CONFIG, maxTokensPerMessage: 1024 } });
+    const release = server.holdWrites();
+    fireEvent.change(inputFor("Minimum savings threshold"), { target: { value: "0.2" } });
+    await save();
+
+    // The response arrives, and a keystroke lands before the page re-renders.
+    await act(async () => {
+      release();
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      fireEvent.change(inputFor("Minimum savings threshold"), { target: { value: "0.3" } });
+    });
+    await settle();
+
+    expect(inputFor("Maximum tokens per message").value).toBe("1024");
+    await save();
+
+    expect(server.stored.aggressive).toEqual({
+      ...DEFAULT_AGGRESSIVE_CONFIG,
+      maxTokensPerMessage: 1024,
+      minSavingsThreshold: 0.3,
+    });
+  });
+
+  it("previews the Ultra engine on a default install that has no model path", async () => {
+    const server = startServer({ ultra: DEFAULT_ULTRA_CONFIG });
+    await renderPage("ultra");
+
+    fireEvent.click(screen.getByRole("button", { name: "Preview" }));
+    await settle();
+
+    expect(server.previews.at(-1)?.status).toBe(200);
+    expect(screen.queryByText("Preview failed.")).toBeNull();
+    expect(screen.getByText("compressed text")).toBeTruthy();
+  });
+});
diff --git a/tests/unit/ui/engineConfigForm.test.tsx b/tests/unit/ui/engineConfigForm.test.tsx
index e7503c6bbfac..2eda1f510fad 100644
--- a/tests/unit/ui/engineConfigForm.test.tsx
+++ b/tests/unit/ui/engineConfigForm.test.tsx
@@ -193,7 +193,7 @@ describe("EngineConfigForm", () => {
       checkbox.dispatchEvent(new MouseEvent("click", { bubbles: true }));
     });
 
-    expect(onChange).toHaveBeenCalledWith({ ...INITIAL_VALUE, enabled: true });
+    expect(onChange).toHaveBeenCalledWith("enabled", true);
   });
 
   it("calls onChange with new number when number input changes", async () => {
@@ -217,7 +217,7 @@ describe("EngineConfigForm", () => {
       numInput.dispatchEvent(new Event("change", { bubbles: true }));
     });
 
-    expect(onChange).toHaveBeenCalledWith({ ...INITIAL_VALUE, maxTokens: 2048 });
+    expect(onChange).toHaveBeenCalledWith("maxTokens", 2048);
   });
 
   it("calls onChange with updated array when a multiselect option is checked", async () => {
@@ -241,9 +241,6 @@ describe("EngineConfigForm", () => {
       stripCommentsCheckbox.dispatchEvent(new MouseEvent("click", { bubbles: true }));
     });
 
-    expect(onChange).toHaveBeenCalledWith({
-      ...INITIAL_VALUE,
-      techniques: ["strip-comments"],
-    });
+    expect(onChange).toHaveBeenCalledWith("techniques", ["strip-comments"]);
   });
 });