From 13e917e2923c92e89247d0d0d0483e83376ec08a Mon Sep 17 00:00:00 2001
From: Val Alexander <68980965+BunsDev@users.noreply.github.com>
Date: Thu, 30 Apr 2026 02:33:43 -0500
Subject: [PATCH] fix: derive dynamic context-window guard thresholds

Derive context-window guard thresholds from the effective model window, keeping 10% hard-min and 20% warning ratios with 4k/8k floors.

Stop the embedded runner from forcing old fixed guard overrides so runtime admission uses the dynamic resolver.

Validation:
- CI run 25151866833 passed, including build-artifacts and checks-node-channels.
- Parity gate 25151866868 passed.
- Testbox pnpm test:channels passed: 54 files / 433 tests.

Fixes #42999.

Prepared head SHA: 9c80383639321871fe93e276c56459de096a2d70
---
 CHANGELOG.md                                  |   1 +
 docs/gateway/local-models.md                  |   2 +-
 src/agents/context-window-guard.test.ts       | 104 +++++++++++++++---
 src/agents/context-window-guard.ts            |  63 ++++++++---
 .../run.overflow-compaction.harness.ts        |   4 +
 .../run.overflow-compaction.test.ts           |   2 +
 src/agents/pi-embedded-runner/run/setup.ts    |  10 +-
 src/commands/onboard-custom-config.test.ts    |   2 +-
 8 files changed, 147 insertions(+), 41 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index afcbf1f78d3..5c359b507f8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -43,6 +43,7 @@ Docs: https://docs.openclaw.ai
 - Security/outbound: strip re-formed HTML tags during plain-text sanitization so nested tag fragments cannot leave a CodeQL-detected `<script>` sequence behind. Thanks @vincentkoc.
 - Security/secrets: compare credential bytes with padded timing-safe buffers instead of hashing candidate passwords before equality checks. Thanks @vincentkoc.
 - CLI/agents/status: keep `openclaw agents`, text `agents list`, and plain text `status` on read-only metadata paths so human output no longer preloads plugin runtimes or live channel scans before printing. Fixes #74195. Thanks @NianJiuZst.
+- Agents/local models: derive context-window guard thresholds from the effective model window with 4k/8k safety floors, so small local models are no longer rejected by fixed 16k/32k preflight cutoffs. Fixes #42999. Thanks @chengjialu8888.
 - Media: treat legacy Word/OLE attachments with `application/msword` or `application/x-cfb` MIME as binary so printable-looking `.doc` files are not embedded into prompts as text. Fixes #54176; carries forward #54380. Thanks @andyliu.
 - Config: accept documented `browser.tabCleanup` keys in strict root config validation, so configured tab cleanup no longer fails before runtime reads it. Fixes #74577. Thanks @lonexreb and @ezdlp.
 - Cron: validate disabled job schedule edits before persisting updates, so invalid cron changes no longer partially mutate stored jobs. Fixes #74459. Thanks @yfge.
diff --git a/docs/gateway/local-models.md b/docs/gateway/local-models.md
index d8f36c1b76b..2e6b26cf456 100644
--- a/docs/gateway/local-models.md
+++ b/docs/gateway/local-models.md
@@ -319,7 +319,7 @@ Compatibility notes for stricter OpenAI-compatible backends:
   OpenClaw process RSS/heap snapshot in diagnostics. For LM Studio/Ollama
   memory pressure, match that timestamp against the server log or macOS crash /
   jetsam log to confirm whether the model server was killed.
-- OpenClaw warns when the detected context window is below **32k** and blocks below **16k**. If you hit that preflight, raise the server/model context limit or choose a larger model.
+- OpenClaw derives context-window preflight thresholds from the detected model window, or from the uncapped model window when `agents.defaults.contextTokens` lowers the effective window. It warns below 20% with an **8k** floor. Hard blocks use the 10% threshold with a **4k** floor, capped to the effective context window so oversized model metadata cannot reject an otherwise valid user cap. If you hit that preflight, raise the server/model context limit or choose a larger model.
 - Context errors? Lower `contextWindow` or raise your server limit.
 - OpenAI-compatible server returns `messages[].content ... expected a string`?
   Add `compat.requiresStringContent: true` on that model entry.
diff --git a/src/agents/context-window-guard.test.ts b/src/agents/context-window-guard.test.ts
index 55dbcc5fed7..6155207916d 100644
--- a/src/agents/context-window-guard.test.ts
+++ b/src/agents/context-window-guard.test.ts
@@ -6,6 +6,7 @@ import {
   evaluateContextWindowGuard,
   formatContextWindowBlockMessage,
   formatContextWindowWarningMessage,
+  resolveContextWindowGuardThresholds,
   resolveContextWindowInfo,
 } from "./context-window-guard.js";
 
@@ -35,41 +36,43 @@ describe("context-window-guard", () => {
     } satisfies OpenClawConfig;
   }
 
-  it("blocks below 16k (model metadata)", () => {
+  it("blocks below the hard-min floor (model metadata)", () => {
     const info = resolveContextWindowInfo({
       cfg: undefined,
       provider: "openrouter",
       modelId: "tiny",
-      modelContextWindow: 8000,
+      modelContextWindow: 3999,
       defaultTokens: 200_000,
     });
     const guard = evaluateContextWindowGuard({ info });
     expect(guard.source).toBe("model");
-    expect(guard.tokens).toBe(8000);
+    expect(guard.tokens).toBe(3999);
+    expect(guard.hardMinTokens).toBe(4000);
+    expect(guard.warnBelowTokens).toBe(8000);
     expect(guard.shouldWarn).toBe(true);
     expect(guard.shouldBlock).toBe(true);
   });
 
-  it("warns below 32k but does not block at 16k+", () => {
+  it("warns below the warning floor but does not block at hard-min+", () => {
     const info = resolveContextWindowInfo({
       cfg: undefined,
       provider: "openai",
       modelId: "small",
-      modelContextWindow: 24_000,
+      modelContextWindow: 6_000,
       defaultTokens: 200_000,
     });
     const guard = evaluateContextWindowGuard({ info });
-    expect(guard.tokens).toBe(24_000);
+    expect(guard.tokens).toBe(6_000);
     expect(guard.shouldWarn).toBe(true);
     expect(guard.shouldBlock).toBe(false);
   });
 
-  it("does not warn at 32k+ (model metadata)", () => {
+  it("does not warn at the warning floor (model metadata)", () => {
     const info = resolveContextWindowInfo({
       cfg: undefined,
       provider: "openai",
       modelId: "ok",
-      modelContextWindow: 64_000,
+      modelContextWindow: 8_000,
       defaultTokens: 200_000,
     });
     const guard = evaluateContextWindowGuard({ info });
@@ -78,7 +81,7 @@ describe("context-window-guard", () => {
   });
 
   it("uses models.providers.*.models[].contextWindow when present", () => {
-    const cfg = openRouterModelConfig({ contextWindow: 12_000 });
+    const cfg = openRouterModelConfig({ contextWindow: 3_000 });
 
     const info = resolveContextWindowInfo({
       cfg,
@@ -160,6 +163,10 @@ describe("context-window-guard", () => {
     });
     const guard = evaluateContextWindowGuard({ info });
     expect(info.source).toBe("agentContextTokens");
+    expect(info.tokens).toBe(20_000);
+    expect(info.referenceTokens).toBe(200_000);
+    expect(guard.hardMinTokens).toBe(20_000);
+    expect(guard.warnBelowTokens).toBe(40_000);
     expect(guard.shouldWarn).toBe(true);
     expect(guard.shouldBlock).toBe(false);
   });
@@ -193,6 +200,30 @@ describe("context-window-guard", () => {
     expect(guard.shouldBlock).toBe(false);
   });
 
+  it("normalizes invalid default context tokens to the warning floor", () => {
+    const info = resolveContextWindowInfo({
+      cfg: undefined,
+      provider: "anthropic",
+      modelId: "unknown",
+      defaultTokens: Number.NaN,
+    });
+    const guard = evaluateContextWindowGuard({ info });
+    expect(info).toEqual({ source: "default", tokens: 8_000 });
+    expect(guard.shouldWarn).toBe(false);
+    expect(guard.shouldBlock).toBe(false);
+  });
+
+  it("blocks invalid guard token counts instead of silently passing", () => {
+    const guard = evaluateContextWindowGuard({
+      info: { tokens: Number.NaN, source: "model" },
+    });
+    expect(guard.tokens).toBe(0);
+    expect(guard.hardMinTokens).toBe(4_000);
+    expect(guard.warnBelowTokens).toBe(8_000);
+    expect(guard.shouldWarn).toBe(true);
+    expect(guard.shouldBlock).toBe(true);
+  });
+
   it("allows overriding thresholds", () => {
     const info = { tokens: 10_000, source: "model" as const };
     const guard = evaluateContextWindowGuard({
@@ -200,18 +231,55 @@ describe("context-window-guard", () => {
       warnBelowTokens: 12_000,
       hardMinTokens: 9_000,
     });
+    expect(guard.hardMinTokens).toBe(9_000);
+    expect(guard.warnBelowTokens).toBe(12_000);
     expect(guard.shouldWarn).toBe(true);
     expect(guard.shouldBlock).toBe(false);
   });
 
-  it("exports thresholds as expected", () => {
-    expect(CONTEXT_WINDOW_HARD_MIN_TOKENS).toBe(16_000);
-    expect(CONTEXT_WINDOW_WARN_BELOW_TOKENS).toBe(32_000);
+  it("exports threshold floors as expected", () => {
+    expect(CONTEXT_WINDOW_HARD_MIN_TOKENS).toBe(4_000);
+    expect(CONTEXT_WINDOW_WARN_BELOW_TOKENS).toBe(8_000);
+  });
+
+  it("derives percentage-based thresholds above the safe floors", () => {
+    expect(resolveContextWindowGuardThresholds(1_000_000)).toEqual({
+      hardMinTokens: 100_000,
+      warnBelowTokens: 200_000,
+    });
+    expect(resolveContextWindowGuardThresholds(64_000)).toEqual({
+      hardMinTokens: 6_400,
+      warnBelowTokens: 12_800,
+    });
+    expect(resolveContextWindowGuardThresholds(Number.NaN)).toEqual({
+      hardMinTokens: 4_000,
+      warnBelowTokens: 8_000,
+    });
+  });
+
+  it("derives guard thresholds from the reference window when capped", () => {
+    const guard = evaluateContextWindowGuard({
+      info: { tokens: 150_000, referenceTokens: 1_000_000, source: "agentContextTokens" },
+    });
+    expect(guard.hardMinTokens).toBe(100_000);
+    expect(guard.warnBelowTokens).toBe(200_000);
+    expect(guard.shouldWarn).toBe(true);
+    expect(guard.shouldBlock).toBe(false);
+  });
+
+  it("does not let inflated reference metadata hard-block a valid effective cap", () => {
+    const guard = evaluateContextWindowGuard({
+      info: { tokens: 20_000, referenceTokens: 1_000_000_000, source: "agentContextTokens" },
+    });
+    expect(guard.hardMinTokens).toBe(20_000);
+    expect(guard.warnBelowTokens).toBe(200_000_000);
+    expect(guard.shouldWarn).toBe(true);
+    expect(guard.shouldBlock).toBe(false);
   });
 
   it("adds a local-model hint to warning messages for localhost endpoints", () => {
     const guard = evaluateContextWindowGuard({
-      info: { tokens: 24_000, source: "model" },
+      info: { tokens: 6_000, source: "model" },
     });
 
     expect(
@@ -221,12 +289,12 @@ describe("context-window-guard", () => {
         guard,
         runtimeBaseUrl: "http://127.0.0.1:1234/v1",
       }),
-    ).toContain("local/self-hosted runs work best at 32000+ tokens");
+    ).toContain("local/self-hosted runs work best at 8000+ tokens");
   });
 
   it("does not add local-model hints for generic custom endpoints", () => {
     const guard = evaluateContextWindowGuard({
-      info: { tokens: 24_000, source: "model" },
+      info: { tokens: 6_000, source: "model" },
     });
 
     expect(
@@ -236,7 +304,7 @@ describe("context-window-guard", () => {
         guard,
         runtimeBaseUrl: "https://models.example.com/v1",
       }),
-    ).toBe("low context window: custom/hosted-proxy-model ctx=24000 (warn<32000) source=model");
+    ).toBe("low context window: custom/hosted-proxy-model ctx=6000 (warn<8000) source=model");
   });
 
   it("adds a local-model hint to block messages for localhost endpoints", () => {
@@ -281,7 +349,7 @@ describe("context-window-guard", () => {
 
   it("keeps block messages concise for public providers", () => {
     const guard = evaluateContextWindowGuard({
-      info: { tokens: 8_000, source: "model" },
+      info: { tokens: 3_000, source: "model" },
     });
 
     expect(
@@ -289,6 +357,6 @@ describe("context-window-guard", () => {
         guard,
         runtimeBaseUrl: "https://api.openai.com/v1",
       }),
-    ).toBe(`Model context window too small (8000 tokens; source=model). Minimum is 16000.`);
+    ).toBe(`Model context window too small (3000 tokens; source=model). Minimum is 4000.`);
   });
 });
diff --git a/src/agents/context-window-guard.ts b/src/agents/context-window-guard.ts
index 25b0b7a088c..e3979df5b4b 100644
--- a/src/agents/context-window-guard.ts
+++ b/src/agents/context-window-guard.ts
@@ -2,13 +2,16 @@ import type { OpenClawConfig } from "../config/types.openclaw.js";
 import { resolveProviderEndpoint } from "./provider-attribution.js";
 import { findNormalizedProviderValue } from "./provider-id.js";
 
-export const CONTEXT_WINDOW_HARD_MIN_TOKENS = 16_000;
-export const CONTEXT_WINDOW_WARN_BELOW_TOKENS = 32_000;
+export const CONTEXT_WINDOW_HARD_MIN_TOKENS = 4_000;
+export const CONTEXT_WINDOW_WARN_BELOW_TOKENS = 8_000;
+export const CONTEXT_WINDOW_HARD_MIN_RATIO = 0.1;
+export const CONTEXT_WINDOW_WARN_BELOW_RATIO = 0.2;
 
 export type ContextWindowSource = "model" | "modelsConfig" | "agentContextTokens" | "default";
 
 export type ContextWindowInfo = {
   tokens: number;
+  referenceTokens?: number;
   source: ContextWindowSource;
 };
 
@@ -43,25 +46,34 @@ export function resolveContextWindowInfo(params: {
   const fromModel =
     normalizePositiveInt(params.modelContextTokens) ??
     normalizePositiveInt(params.modelContextWindow);
+  const defaultTokens =
+    normalizePositiveInt(params.defaultTokens) ?? CONTEXT_WINDOW_WARN_BELOW_TOKENS;
   const baseInfo = fromModelsConfig
     ? { tokens: fromModelsConfig, source: "modelsConfig" as const }
     : fromModel
       ? { tokens: fromModel, source: "model" as const }
-      : { tokens: Math.floor(params.defaultTokens), source: "default" as const };
+      : { tokens: defaultTokens, source: "default" as const };
 
   const capTokens = normalizePositiveInt(params.cfg?.agents?.defaults?.contextTokens);
   if (capTokens && capTokens < baseInfo.tokens) {
-    return { tokens: capTokens, source: "agentContextTokens" };
+    return { tokens: capTokens, referenceTokens: baseInfo.tokens, source: "agentContextTokens" };
   }
 
   return baseInfo;
 }
 
 export type ContextWindowGuardResult = ContextWindowInfo & {
+  hardMinTokens: number;
+  warnBelowTokens: number;
   shouldWarn: boolean;
   shouldBlock: boolean;
 };
 
+export type ContextWindowGuardThresholds = {
+  hardMinTokens: number;
+  warnBelowTokens: number;
+};
+
 export type ContextWindowGuardHint = {
   endpointClass: ReturnType<typeof resolveProviderEndpoint>["endpointClass"];
   likelySelfHosted: boolean;
@@ -77,13 +89,29 @@ export function resolveContextWindowGuardHint(params: {
   };
 }
 
+export function resolveContextWindowGuardThresholds(
+  contextWindowTokens: number,
+): ContextWindowGuardThresholds {
+  const tokens = normalizePositiveInt(contextWindowTokens) ?? 0;
+  return {
+    hardMinTokens: Math.max(
+      CONTEXT_WINDOW_HARD_MIN_TOKENS,
+      Math.floor(tokens * CONTEXT_WINDOW_HARD_MIN_RATIO),
+    ),
+    warnBelowTokens: Math.max(
+      CONTEXT_WINDOW_WARN_BELOW_TOKENS,
+      Math.floor(tokens * CONTEXT_WINDOW_WARN_BELOW_RATIO),
+    ),
+  };
+}
+
 export function formatContextWindowWarningMessage(params: {
   provider: string;
   modelId: string;
   guard: ContextWindowGuardResult;
   runtimeBaseUrl?: string | null;
 }): string {
-  const base = `low context window: ${params.provider}/${params.modelId} ctx=${params.guard.tokens} (warn<${CONTEXT_WINDOW_WARN_BELOW_TOKENS}) source=${params.guard.source}`;
+  const base = `low context window: ${params.provider}/${params.modelId} ctx=${params.guard.tokens} (warn<${params.guard.warnBelowTokens}) source=${params.guard.source}`;
   const hint = resolveContextWindowGuardHint({ runtimeBaseUrl: params.runtimeBaseUrl });
   if (!hint.likelySelfHosted) {
     return base;
@@ -102,7 +130,7 @@ export function formatContextWindowWarningMessage(params: {
   }
   return (
     `${base}; local/self-hosted runs work best at ` +
-    `${CONTEXT_WINDOW_WARN_BELOW_TOKENS}+ tokens and may show weaker tool use or more compaction until the server/model context limit is raised`
+    `${params.guard.warnBelowTokens}+ tokens and may show weaker tool use or more compaction until the server/model context limit is raised`
   );
 }
 
@@ -112,7 +140,7 @@ export function formatContextWindowBlockMessage(params: {
 }): string {
   const base =
     `Model context window too small (${params.guard.tokens} tokens; ` +
-    `source=${params.guard.source}). Minimum is ${CONTEXT_WINDOW_HARD_MIN_TOKENS}.`;
+    `source=${params.guard.source}). Minimum is ${params.guard.hardMinTokens}.`;
   const hint = resolveContextWindowGuardHint({ runtimeBaseUrl: params.runtimeBaseUrl });
   if (!hint.likelySelfHosted) {
     return base;
@@ -129,7 +157,7 @@ export function formatContextWindowBlockMessage(params: {
   return (
     `${base} This looks like a local model endpoint. ` +
     `Raise the server/model context limit or choose a larger model. ` +
-    `OpenClaw local/self-hosted runs work best at ${CONTEXT_WINDOW_WARN_BELOW_TOKENS}+ tokens.`
+    `OpenClaw local/self-hosted runs work best at ${params.guard.warnBelowTokens}+ tokens.`
   );
 }
 
@@ -138,16 +166,25 @@ export function evaluateContextWindowGuard(params: {
   warnBelowTokens?: number;
   hardMinTokens?: number;
 }): ContextWindowGuardResult {
+  const normalizedTokens = normalizePositiveInt(params.info.tokens);
+  const tokens = normalizedTokens ?? 0;
+  const referenceTokens = normalizePositiveInt(params.info.referenceTokens) ?? tokens;
+  const resolvedThresholds = resolveContextWindowGuardThresholds(referenceTokens);
   const warnBelow = Math.max(
     1,
-    Math.floor(params.warnBelowTokens ?? CONTEXT_WINDOW_WARN_BELOW_TOKENS),
+    Math.floor(params.warnBelowTokens ?? resolvedThresholds.warnBelowTokens),
   );
-  const hardMin = Math.max(1, Math.floor(params.hardMinTokens ?? CONTEXT_WINDOW_HARD_MIN_TOKENS));
-  const tokens = Math.max(0, Math.floor(params.info.tokens));
+  const defaultHardMin = Math.min(
+    resolvedThresholds.hardMinTokens,
+    Math.max(tokens, CONTEXT_WINDOW_HARD_MIN_TOKENS),
+  );
+  const hardMin = Math.max(1, Math.floor(params.hardMinTokens ?? defaultHardMin));
   return {
     ...params.info,
     tokens,
-    shouldWarn: tokens > 0 && tokens < warnBelow,
-    shouldBlock: tokens > 0 && tokens < hardMin,
+    hardMinTokens: hardMin,
+    warnBelowTokens: warnBelow,
+    shouldWarn: !normalizedTokens || tokens < warnBelow,
+    shouldBlock: !normalizedTokens || tokens < hardMin,
   };
 }
diff --git a/src/agents/pi-embedded-runner/run.overflow-compaction.harness.ts b/src/agents/pi-embedded-runner/run.overflow-compaction.harness.ts
index 40c0474f1b2..33bb6a9030b 100644
--- a/src/agents/pi-embedded-runner/run.overflow-compaction.harness.ts
+++ b/src/agents/pi-embedded-runner/run.overflow-compaction.harness.ts
@@ -195,6 +195,8 @@ export const mockedEvaluateContextWindowGuard = vi.fn(() => ({
   shouldBlock: false,
   tokens: 200000,
   source: "model",
+  hardMinTokens: 1000,
+  warnBelowTokens: 5000,
 }));
 export const mockedResolveContextWindowInfo = vi.fn(() => ({
   tokens: 200000,
@@ -357,6 +359,8 @@ export function resetRunOverflowCompactionHarnessMocks(): void {
     shouldBlock: false,
     tokens: 200000,
     source: "model",
+    hardMinTokens: 1000,
+    warnBelowTokens: 5000,
   });
   mockedResolveContextWindowInfo.mockReset();
   mockedResolveContextWindowInfo.mockReturnValue({
diff --git a/src/agents/pi-embedded-runner/run.overflow-compaction.test.ts b/src/agents/pi-embedded-runner/run.overflow-compaction.test.ts
index 05c5a83aef7..a0f3c2dcad3 100644
--- a/src/agents/pi-embedded-runner/run.overflow-compaction.test.ts
+++ b/src/agents/pi-embedded-runner/run.overflow-compaction.test.ts
@@ -386,6 +386,8 @@ describe("runEmbeddedPiAgent overflow compaction trigger routing", () => {
       shouldBlock: true,
       tokens: 800,
       source: "model",
+      hardMinTokens: 1000,
+      warnBelowTokens: 5000,
     });
 
     await expect(
diff --git a/src/agents/pi-embedded-runner/run/setup.ts b/src/agents/pi-embedded-runner/run/setup.ts
index aa9e099c3be..09a564f24ec 100644
--- a/src/agents/pi-embedded-runner/run/setup.ts
+++ b/src/agents/pi-embedded-runner/run/setup.ts
@@ -6,8 +6,6 @@ import type {
   PluginHookBeforeModelResolveEvent,
 } from "../../../plugins/types.js";
 import {
-  CONTEXT_WINDOW_HARD_MIN_TOKENS,
-  CONTEXT_WINDOW_WARN_BELOW_TOKENS,
   evaluateContextWindowGuard,
   formatContextWindowBlockMessage,
   formatContextWindowWarningMessage,
@@ -140,11 +138,7 @@ export function resolveEffectiveRuntimeModel(params: {
     ctxInfo.tokens < (params.runtimeModel.contextWindow ?? Infinity)
       ? { ...params.runtimeModel, contextWindow: ctxInfo.tokens }
       : params.runtimeModel;
-  const ctxGuard = evaluateContextWindowGuard({
-    info: ctxInfo,
-    warnBelowTokens: CONTEXT_WINDOW_WARN_BELOW_TOKENS,
-    hardMinTokens: CONTEXT_WINDOW_HARD_MIN_TOKENS,
-  });
+  const ctxGuard = evaluateContextWindowGuard({ info: ctxInfo });
   const runtimeBaseUrl =
     typeof (params.runtimeModel as { baseUrl?: unknown }).baseUrl === "string"
       ? (params.runtimeModel as { baseUrl: string }).baseUrl
@@ -165,7 +159,7 @@ export function resolveEffectiveRuntimeModel(params: {
       runtimeBaseUrl,
     });
     log.error(
-      `blocked model (context window too small): ${params.provider}/${params.modelId} ctx=${ctxGuard.tokens} (min=${CONTEXT_WINDOW_HARD_MIN_TOKENS}) source=${ctxGuard.source}; ${message}`,
+      `blocked model (context window too small): ${params.provider}/${params.modelId} ctx=${ctxGuard.tokens} (min=${ctxGuard.hardMinTokens}) source=${ctxGuard.source}; ${message}`,
     );
     throw new FailoverError(message, {
       reason: "unknown",
diff --git a/src/commands/onboard-custom-config.test.ts b/src/commands/onboard-custom-config.test.ts
index f4e94404c76..bc8dd1d84e8 100644
--- a/src/commands/onboard-custom-config.test.ts
+++ b/src/commands/onboard-custom-config.test.ts
@@ -112,7 +112,7 @@ describe("applyCustomApiConfig", () => {
     },
     {
       name: "upgrades existing custom model context window when below hard minimum",
-      existingContextWindow: 4096,
+      existingContextWindow: 2048,
       expectedContextWindow: CONTEXT_WINDOW_HARD_MIN_TOKENS,
     },
     {