diff --git a/gui/src/components/provider-workspace/ProviderModels.tsx b/gui/src/components/provider-workspace/ProviderModels.tsx
index bb158ed7802..944e6a0cb5c 100644
--- a/gui/src/components/provider-workspace/ProviderModels.tsx
+++ b/gui/src/components/provider-workspace/ProviderModels.tsx
@@ -1,8 +1,9 @@
 /** Canonical inventory and revision-bound custom-definition operations for one provider. */
 import { useEffect, useRef, useState } from "react";
 import { useT } from "../../i18n/shared";
+import { Switch } from "../../ui";
 import type { WorkspaceItem } from "../../provider-workspace/catalog";
-import type { ModelRow } from "../../pages/models-shared";
+import { filterFreeModelRows, freeOnlyInForce, modelPricingKnown, type ModelRow } from "../../pages/models-shared";
 import { putModelVisibility } from "../../model-visibility";
 import { readJsonOrThrow } from "../../fetch-json";
 import { createBoundedFetch } from "../../bounded-fetch";
@@ -45,6 +46,8 @@ function ProviderModelInventory({ item, apiBase, availableModels, selectedModels
 }: ProviderModelsProps) {
   const t = useT();
   const [query, setQuery] = useState("");
+  // Free-only narrowing for this provider's inventory (#3666), mirroring the Models page.
+  const [freeOnly, setFreeOnly] = useState(false);
   const [draft, setDraft] = useState("");
   const [ownershipEpoch, setOwnershipEpoch] = useState(0);
   const ownershipKey = JSON.stringify([apiBase, item.name, modelRevision, ownershipEpoch]);
@@ -74,8 +77,18 @@ function ProviderModelInventory({ item, apiBase, availableModels, selectedModels
   const modelId = draft.trim();
   const duplicate = !!modelId && (known.includes(modelId) || encodedModelIdCollides(modelId, known));
   const visible = rows.filter(row => !row.disabled);
+  // Offered only where discovery actually returned per-token prices; a provider that publishes
+  // none would otherwise get a switch that can only empty its own inventory.
+  const pricingKnown = modelPricingKnown(visible);
+  // Absent pricingStatus is never free — the classifier omits it exactly when the provider's
+  // rates were missing, partial, or unusable.
+  // Lapses with the switch: `pricingKnown` hides the control when discovery stops returning
+  // prices, and a stale `freeOnly` would otherwise keep filtering an inventory in which nothing
+  // can classify as free.
+  const freeOnlyActive = freeOnlyInForce(freeOnly, visible);
+  const priced = filterFreeModelRows(visible, freeOnlyActive);
   const normalizedQuery = query.trim().toLowerCase();
-  const filtered = visible.filter(row => [row.id, row.namespaced].some(value => value.toLowerCase().includes(normalizedQuery)));
+  const filtered = priced.filter(row => [row.id, row.namespaced].some(value => value.toLowerCase().includes(normalizedQuery)));
   const labels = new Map<string, number>();
   for (const row of visible) labels.set(row.id, (labels.get(row.id) ?? 0) + 1);
 
@@ -245,10 +258,16 @@ function ProviderModelInventory({ item, apiBase, availableModels, selectedModels
       </div> : (!ready || busy) && <p className="muted" role="status">{t(!modelRowsReady || modelsLoading ? "pws.modelsLoading" : "pws.modelOwnershipLoading")}</p>}
       {mutation && (mutation.outcome === "unconfirmed" || mutation.refreshPending) && !modelsLoadFailed && ownershipError !== ownershipKey &&
         <button type="button" className="btn btn-ghost btn-sm" onClick={retry} disabled={requestPending}>{t("common.retry")}</button>}
+      {/* Above the search box, matching the Models page group: the same filter must not sit on
+          opposite sides of the search input on the two surfaces that offer it. */}
+      {pricingKnown && <div className="row">
+        <Switch on={freeOnly} onClick={() => setFreeOnly(!freeOnly)} label={t("models.freeOnly")} showLabel />
+      </div>}
       <input ref={searchRef} type="search" className="input pws-model-search" placeholder={t("pws.modelSearchPlaceholder")}
         value={query} onChange={event => setQuery(event.target.value)} aria-label={t("pws.modelSearchPlaceholder")} />
       {modelRows !== null && visible.length === 0 ? <p className="muted">{t("pws.noModels")}</p>
-        : filtered.length === 0 && modelRows !== null ? <p className="muted" role="status">{t("pws.noModelMatch")}</p>
+        : filtered.length === 0 && modelRows !== null
+          ? <p className="muted" role="status">{t(freeOnlyActive && priced.length === 0 ? "models.noFreeMatch" : "pws.noModelMatch")}</p>
         : <ul className="pws-model-list">{filtered.slice(0, CHIP_RENDER_CAP).map(row => <ProviderModelChip key={row.namespaced}
           row={row} disambiguate={(labels.get(row.id) ?? 0) > 1} copied={copiedId === row.namespaced}
           isDefault={row.id === item.defaultModel} selected={row.native !== true && selectedSet.has(row.id)}
diff --git a/gui/src/i18n/de.ts b/gui/src/i18n/de.ts
index b92691411ab..3b45878d574 100644
--- a/gui/src/i18n/de.ts
+++ b/gui/src/i18n/de.ts
@@ -650,6 +650,8 @@ export const de: Record<TKey, string> = {
   "models.loading": "Lädt…",
   "models.search": "Modelle suchen…",
   "models.showMore": "{n} weitere anzeigen",
+  "models.freeOnly": "Nur kostenlose",
+  "models.noFreeMatch": "Hier gibt es keine kostenlosen Modelle. Schalte „Nur kostenlose“ aus, um die übrigen zu sehen.",
   "models.allowlistLabel": "Nur ausgewählte",
   "models.allowlistHint": "Nur geprüfte Modelle gehen in den Katalog (leer = alle). Nützlich für Anbieter mit tausenden Modellen.",
   "models.selectedCount": "{n} ausgewählt",
diff --git a/gui/src/i18n/en.ts b/gui/src/i18n/en.ts
index a8f6cf20a0f..00bfdf3a0f2 100644
--- a/gui/src/i18n/en.ts
+++ b/gui/src/i18n/en.ts
@@ -679,6 +679,8 @@ export const en = {
   "models.loading": "Loading…",
   "models.search": "Search models…",
   "models.showMore": "Show {n} more",
+  "models.freeOnly": "Free only",
+  "models.noFreeMatch": "No free models here. Turn off Free only to see the rest.",
   "models.allowlistLabel": "Only selected",
   "models.allowlistHint": "Only checked models ship to the catalog (empty = all). Useful for providers exposing thousands of models.",
   "models.selectedCount": "{n} selected",
diff --git a/gui/src/i18n/fr.ts b/gui/src/i18n/fr.ts
index 855a8a146f0..64005501c8b 100644
--- a/gui/src/i18n/fr.ts
+++ b/gui/src/i18n/fr.ts
@@ -664,6 +664,8 @@ export const fr: Record<TKey, string> = {
   "models.loading": "Chargement…",
   "models.search": "Rechercher des modèles…",
   "models.showMore": "Afficher {n} de plus",
+  "models.freeOnly": "Gratuits uniquement",
+  "models.noFreeMatch": "Aucun modèle gratuit ici. Désactivez « Gratuits uniquement » pour voir les autres.",
   "models.allowlistLabel": "Sélection uniquement",
   "models.allowlistHint": "Seuls les modèles cochés sont inclus dans le catalogue (vide = tous). Utile pour les fournisseurs proposant des milliers de modèles.",
   "models.selectedCount": "{n} sélectionnés",
diff --git a/gui/src/i18n/ja.ts b/gui/src/i18n/ja.ts
index be78373e777..729ecdbcdec 100644
--- a/gui/src/i18n/ja.ts
+++ b/gui/src/i18n/ja.ts
@@ -608,6 +608,8 @@ export const ja: Record<TKey, string> = {
   "models.loading": "読み込み中…",
   "models.search": "モデルを検索…",
   "models.showMore": "さらに {n} 件表示",
+  "models.freeOnly": "無料のみ",
+  "models.noFreeMatch": "ここに無料モデルはありません。「無料のみ」をオフにすると残りが表示されます。",
   "models.allowlistLabel": "選択のみ",
   "models.allowlistHint": "チェックしたモデルのみカタログに送信します(空 = すべて)。数千のモデルを公開するプロバイダーで有用です。",
   "models.selectedCount": "{n} 件選択",
diff --git a/gui/src/i18n/ko.ts b/gui/src/i18n/ko.ts
index 49b3b4f203c..f8e500f7470 100644
--- a/gui/src/i18n/ko.ts
+++ b/gui/src/i18n/ko.ts
@@ -661,6 +661,8 @@ export const ko: Record<TKey, string> = {
   "models.loading": "불러오는 중…",
   "models.search": "모델 검색…",
   "models.showMore": "{n}개 더 보기",
+  "models.freeOnly": "무료만",
+  "models.noFreeMatch": "여기에는 무료 모델이 없어요. ‘무료만’을 끄면 나머지가 보여요.",
   "models.allowlistLabel": "선택만 노출",
   "models.allowlistHint": "체크한 모델만 카탈로그에 노출돼요 (비우면 전체). 수천 개 모델을 노출하는 프로바이더에 유용해요.",
   "models.selectedCount": "{n}개 선택",
diff --git a/gui/src/i18n/ru.ts b/gui/src/i18n/ru.ts
index 72df6bb9db2..fe654314a11 100644
--- a/gui/src/i18n/ru.ts
+++ b/gui/src/i18n/ru.ts
@@ -663,6 +663,8 @@ export const ru: Record<TKey, string> = {
   "models.loading": "Загрузка…",
   "models.search": "Поиск моделей…",
   "models.showMore": "Показать ещё {n}",
+  "models.freeOnly": "Только бесплатные",
+  "models.noFreeMatch": "Здесь нет бесплатных моделей. Отключите «Только бесплатные», чтобы увидеть остальные.",
   "models.allowlistLabel": "Только выбранные",
   "models.allowlistHint": "В каталог попадают только отмеченные модели (пусто = все). Полезно для провайдеров, предоставляющих тысячи моделей.",
   "models.selectedCount": "Выбрано: {n}",
diff --git a/gui/src/i18n/tr.ts b/gui/src/i18n/tr.ts
index da99115c81d..d6d37d1469b 100644
--- a/gui/src/i18n/tr.ts
+++ b/gui/src/i18n/tr.ts
@@ -666,6 +666,8 @@ export const tr: Record<TKey, string> = {
   "models.loading": "Yükleniyor…",
   "models.search": "Modellerde ara…",
   "models.showMore": "{n} tane daha göster",
+  "models.freeOnly": "Yalnızca ücretsiz",
+  "models.noFreeMatch": "Burada ücretsiz model yok. Diğerlerini görmek için „Yalnızca ücretsiz“ seçeneğini kapatın.",
   "models.allowlistLabel": "Sadece seçilenler",
   "models.allowlistHint": "Sadece işaretli modeller kataloğa gönderilir.",
   "models.selectedCount": "{n} seçildi",
diff --git a/gui/src/i18n/zh-TW.ts b/gui/src/i18n/zh-TW.ts
index 7f5f06a7708..c1675c4a246 100644
--- a/gui/src/i18n/zh-TW.ts
+++ b/gui/src/i18n/zh-TW.ts
@@ -527,6 +527,8 @@ export const zhTW: Record<TKey, string> = {
   "models.loading": "載入中…",
   "models.search": "搜尋模型…",
   "models.showMore": "再顯示 {n} 個",
+  "models.freeOnly": "僅免費",
+  "models.noFreeMatch": "這裡沒有免費模型。關閉「僅免費」即可看到其餘模型。",
   "models.allowlistLabel": "僅所選",
   "models.allowlistHint": "僅勾選的模型進入目錄（留空 = 全部）。適用於暴露成千上萬模型的供應商。",
   "models.selectedCount": "已選 {n} 個",
diff --git a/gui/src/i18n/zh.ts b/gui/src/i18n/zh.ts
index 628f458030a..06dceef46fc 100644
--- a/gui/src/i18n/zh.ts
+++ b/gui/src/i18n/zh.ts
@@ -658,6 +658,8 @@ export const zh: Record<TKey, string> = {
   "models.loading": "加载中…",
   "models.search": "搜索模型…",
   "models.showMore": "再显示 {n} 个",
+  "models.freeOnly": "仅免费",
+  "models.noFreeMatch": "这里没有免费模型。关闭“仅免费”即可看到其余模型。",
   "models.allowlistLabel": "仅所选",
   "models.allowlistHint": "仅勾选的模型进入目录（留空 = 全部）。适用于暴露成千上万模型的提供商。",
   "models.selectedCount": "已选 {n} 个",
diff --git a/gui/src/pages/Models.tsx b/gui/src/pages/Models.tsx
index d14a81005d3..67690a9d1c8 100644
--- a/gui/src/pages/Models.tsx
+++ b/gui/src/pages/Models.tsx
@@ -67,6 +67,9 @@ import {
   THREAD_OPTIONS,
   writeCollapsedProviders,
   discoveryFailureLabel,
+  filterFreeModelRows,
+  freeOnlyInForce,
+  modelPricingKnown,
   REASONING_EFFORT_LEVELS,
   type ModelRow,
   type ProviderContextCapsResponse,
@@ -242,6 +245,10 @@ export default function Models({ apiBase, restartEpoch = 0 }: { apiBase: string;
   const [disabled, setDisabled] = useState<Set<string>>(() => new Set(cached?.disabled ?? []));
   const [selectedModels, setSelectedModels] = useState<ProviderModelMap | null>(() => cached?.selectedModels ?? null);
   const [search, setSearch] = useState<Record<string, string>>({});
+  // Per-provider Free-only narrowing (#3666). Session UX, not persisted config: it answers
+  // "what can I run for nothing right now", which is a question about this sitting, and the
+  // provider list it applies to changes underneath a stored value.
+  const [freeOnly, setFreeOnly] = useState<Record<string, boolean>>({});
   const [limit, setLimit] = useState<Record<string, number>>({});
   const [contextCaps, setContextCaps] = useState<Record<string, number>>(() => cached?.contextCaps ?? {});
   const [contextCapValues, setContextCapValues] = useState<Record<string, number>>(() => cached?.contextCapValues ?? {});
@@ -1396,7 +1403,26 @@ export default function Models({ apiBase, restartEpoch = 0 }: { apiBase: string;
       model.native === true,
       disabled.has(model.namespaced),
     );
-    const activeCount = rows.filter(isVisible).length;
+    const freeOnlyOn = freeOnly[provider] === true;
+    // The control is offered only where the provider actually published per-token prices.
+    // A provider whose rows are all unclassified — Ollama, a static catalog, anything with no
+    // pricing in /models — would otherwise get a switch whose only possible effect is to empty
+    // the list, which reads as a bug rather than as "this provider does not say".
+    const pricingKnown = modelPricingKnown(rows);
+    // Free-only narrows BEFORE the header counts, search, the enabled-first sort, and the PAGE
+    // slice below. Filtering after the slice would leave free models stranded behind Show more
+    // on a 200-row OpenRouter list, which is the exact case the issue reports.
+    //
+    // `scoped` is the set every count and bulk action reads. Search is deliberately NOT part of
+    // it: the search box has always been a transient find-as-you-type that leaves the counts
+    // alone, while Free only is a narrowing the user holds on, so a header still reading the
+    // whole provider would claim more models than the list under it shows.
+    // Gated on `pricingKnown` through `freeOnlyInForce`: the switch below is hidden when the
+    // provider stops publishing prices, so a narrowing left on from an earlier render must lapse
+    // with it rather than empty the list behind a control that is no longer there.
+    const freeOnlyActive = freeOnlyInForce(freeOnlyOn, rows);
+    const scoped = filterFreeModelRows(rows, freeOnlyActive);
+    const activeCount = scoped.filter(isVisible).length;
     const recentForProvider = modelDiscovery?.recentArrivals[provider] ?? [];
     const recentIds = new Set(recentForProvider.map(row => row.id));
     const capOn = contextCaps[provider] !== undefined;
@@ -1409,7 +1435,7 @@ export default function Models({ apiBase, restartEpoch = 0 }: { apiBase: string;
     const capOptionSet = group.nativeProviderGroup ? NATIVE_CAP_OPTION_SET : CAP_OPTION_SET;
     const discoveryFailure = liveModels && discovery?.status === "failed" ? discovery : undefined;
     const q = (search[provider] ?? "").trim().toLowerCase();
-    const filtered = q ? rows.filter(m => m.id.toLowerCase().includes(q)) : rows;
+    const filtered = q ? scoped.filter(m => m.id.toLowerCase().includes(q)) : scoped;
     // Display-only: enabled models float to the top of each provider group so they
     // stay findable in long lists. The sort is stable, so the server order is kept
     // inside each partition, and this does not affect the picker order above
@@ -1420,16 +1446,20 @@ export default function Models({ apiBase, restartEpoch = 0 }: { apiBase: string;
     const remaining = filtered.length - visible.length;
      // An empty provider has nothing to send: keep both bulk buttons inert so we never PUT an
      // empty target list (the management API rejects it with 400).
-     const hasRows = rows.length > 0;
+     // Bulk follows the same scoped set as the counts it sits beside: with Free only on, an
+     // "All on" that enabled the 197 paid rows the header is not counting would be the exact
+     // surprise the header fix exists to prevent. Pending stays keyed to the whole provider,
+     // because initial discovery is a provider state that no display filter can clear.
+     const hasRows = scoped.length > 0;
      const selectionPending = rows.some(model => model.initialSelectionPending);
-     const allOn = !hasRows || rows.every(isVisible);
-     const allOff = !hasRows || rows.every(m => !isVisible(m));
+     const allOn = !hasRows || scoped.every(isVisible);
+     const allOff = !hasRows || scoped.every(m => !isVisible(m));
      const bulkToggle = (enable: boolean) => {
        if (!hasRows || selectionPending) return;
        void applyVisibility(
          "provider",
          provider,
-         rows.map(m => ({ id: m.id, native: m.native === true })),
+         scoped.map(m => ({ id: m.id, native: m.native === true })),
          enable,
        );
      };
@@ -1456,7 +1486,7 @@ export default function Models({ apiBase, restartEpoch = 0 }: { apiBase: string;
              {t("models.discoveryFailedBadge")}
            </span>
          )}
-          <span className="muted mono text-label">{t("models.active", { active: activeCount, total: rows.length })}</span>
+          <span className="muted mono text-label">{t("models.active", { active: activeCount, total: scoped.length })}</span>
           {recentForProvider.length > 0 && <span className="models-chip mono text-caption">{t("models.newCount", { count: recentForProvider.length })}</span>}
           </button>
            <div className="row models-provider-actions">
@@ -1650,6 +1680,21 @@ export default function Models({ apiBase, restartEpoch = 0 }: { apiBase: string;
             {rows.length === 0 && (
               <EmptyProviderHint liveModels={liveModels} discovery={discovery} showFailureBadge={false} />
             )}
+            {pricingKnown && (
+              <div className="row models-provider-hint">
+                <Switch
+                  on={freeOnlyOn}
+                  onClick={() => setFreeOnly(prev => ({ ...prev, [provider]: !freeOnlyOn }))}
+                  label={t("models.freeOnly")}
+                  showLabel
+                />
+              </div>
+            )}
+            {/* Reads `scoped`, not `filtered`: with a search term that matches nothing, the
+                honest message is the search one, not "this provider has no free models". */}
+            {freeOnlyActive && scoped.length === 0 && rows.length > 0 && (
+              <p className="muted text-label" role="status">{t("models.noFreeMatch")}</p>
+            )}
             {rows.length > PAGE / 2 && (
               <input
                 className="input"
diff --git a/gui/src/pages/models-shared.ts b/gui/src/pages/models-shared.ts
index 19d9bb67f7f..7ff08ea9967 100644
--- a/gui/src/pages/models-shared.ts
+++ b/gui/src/pages/models-shared.ts
@@ -38,6 +38,12 @@ export interface ModelRow {
   displayNameOverride?: string;
   displayNameSource?: "operator" | "provider" | "fallback";
   manualPricing?: boolean;
+  /**
+   * Provider-published cost class from model discovery (#3666). Absent means unknown — either
+   * the provider publishes no per-token rates, or the row was cached by a build that predates
+   * the field. Absent is never treated as free.
+   */
+  pricingStatus?: "free" | "paid";
   inputModalities?: string[];
   contextWindow?: number;
   contextCap?: number;
@@ -46,6 +52,47 @@ export interface ModelRow {
   reasoningEfforts?: string[];
 }
 
+/** The pricing shape both Free-only consumers read; keeps the helpers usable from either page. */
+export type PricedRow = { pricingStatus?: "free" | "paid" };
+
+/**
+ * Whether a Free-only control should be offered for this set of rows at all (#3666).
+ *
+ * A provider that publishes no per-token prices — Ollama, a static catalog, anything whose
+ * /models rows carry no usable rate pair — leaves every row unclassified, so a Free switch
+ * there could only ever empty the list. That reads as a broken filter rather than as "this
+ * provider does not say", so the control is hidden instead.
+ */
+export function modelPricingKnown(rows: readonly PricedRow[]): boolean {
+  return rows.some(row => row.pricingStatus !== undefined);
+}
+
+/**
+ * Apply the Free-only narrowing (#3666).
+ *
+ * Absent `pricingStatus` is never free: the discovery classifier omits the field exactly when
+ * the provider's rates were missing, one-sided, non-numeric, or negative, and a cached row from
+ * an older build has no field either. Both consumers call this BEFORE their own search, sort,
+ * and page slice, or free models stay stranded behind Show more on a long provider list.
+ */
+export function filterFreeModelRows<T extends PricedRow>(rows: readonly T[], freeOnly: boolean): T[] {
+  return freeOnly ? rows.filter(row => row.pricingStatus === "free") : [...rows];
+}
+
+/**
+ * Whether the Free-only narrowing is actually in force for this set of rows.
+ *
+ * The switch is offered only where discovery returned prices, but the operator's choice is
+ * component state that outlives the rows it was made against. When the evidence goes away —
+ * a refresh that comes back without pricing, a re-auth, a discovery fallback to a static
+ * catalog — the control disappears while the stale `true` keeps filtering, and every row is
+ * unclassified, so the list empties with no visible way to turn it off. Gate the filter on the
+ * same condition that gates the switch and the narrowing lapses with the control.
+ */
+export function freeOnlyInForce(freeOnly: boolean, rows: readonly PricedRow[]): boolean {
+  return freeOnly && modelPricingKnown(rows);
+}
+
 function containsDisplayNameControlCharacter(value: string): boolean {
   return [...value].some(character => {
     const codePoint = character.codePointAt(0)!;
diff --git a/scripts/test-layout/layout.json b/scripts/test-layout/layout.json
index a82018a5ff0..d14401975ab 100644
--- a/scripts/test-layout/layout.json
+++ b/scripts/test-layout/layout.json
@@ -265,6 +265,7 @@
     "bun-stream-caps.test.ts": "lib",
     "cancel-body-on-abort.test.ts": "server",
     "catalog-cursor-search.test.ts": "codex-integration",
+    "catalog-free-pricing-status.test.ts": "codex-integration",
     "catalog-full-picker-order.test.ts": "codex-integration",
     "catalog-go-exact-efforts.test.ts": "codex-integration",
     "catalog-hub-context-window.test.ts": "codex-integration",
@@ -338,6 +339,7 @@
     "cli-help.test.ts": "cli",
     "cli-json-contract.test.ts": "cli",
     "cli-management-auth.test.ts": "cli",
+    "cli-models-free-only.test.ts": "cli",
     "cli-models-price.test.ts": "cli",
     "cli-models-reasoning.test.ts": "cli",
     "cli-models-runtime-dispatch.test.ts": "cli",
@@ -832,6 +834,7 @@
     "model-selection-guidance.test.ts": "cli",
     "model-visibility-management-api.test.ts": "codex-integration",
     "models-feedback-callback.test.ts": "gui",
+    "models-free-filter.test.ts": "gui",
     "models-page-groups.test.ts": "gui",
     "models-workspace-tabs.test.ts": "gui",
     "moonshot-endpoints.test.ts": "providers",
diff --git a/src/cli/models-runtime.ts b/src/cli/models-runtime.ts
index 129f2fb53b5..0608c324c85 100644
--- a/src/cli/models-runtime.ts
+++ b/src/cli/models-runtime.ts
@@ -21,7 +21,7 @@ import { MAX_COST4_RATE } from "../usage/expected-prices";
 import { isValidCost4Rate } from "../usage/user-cost-overlays";
 
 const USAGE = `Usage:
-  ocx models live [--provider <name>] [--json]
+  ocx models live [--provider <name>] [--free-only] [--json]
   ocx models price <provider/model> [--json]
   ocx models set-price <provider/model> --input N --output N [--cache-read N] [--cache-write N] [--json]
   ocx models set-price <provider/model> --auto [--json]
@@ -52,17 +52,22 @@ type ModelRow = {
   custom?: boolean;
   customId?: string;
   displayName?: string;
+  pricingStatus?: "free" | "paid";
 };
 
 async function live(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   const args = [...argv];
   const wantsJson = takeFlag(args, "--json");
   const provider = takeOption(args, "--provider");
+  // Absent pricingStatus means the provider published no usable per-token pair, so it is
+  // excluded here for the same fail-closed reason the classifier omits it (#3666).
+  const freeOnly = takeFlag(args, "--free-only");
   rejectArgs(args, USAGE);
   const rows = await runtimeRequest<ModelRow[]>("/api/models", {}, deps);
-  const filtered = provider ? rows.filter(row => row.provider === provider) : rows;
+  const byProvider = provider ? rows.filter(row => row.provider === provider) : rows;
+  const filtered = freeOnly ? byProvider.filter(row => row.pricingStatus === "free") : byProvider;
   printData(filtered, wantsJson, filtered.map(row => {
-    const flags = [row.native ? "native" : "routed", row.custom ? "custom" : "", row.initialSelectionPending ? "initial discovery pending" : row.disabled ? "disabled" : "enabled"].filter(Boolean);
+    const flags = [row.native ? "native" : "routed", row.custom ? "custom" : "", row.pricingStatus === "free" ? "free" : "", row.initialSelectionPending ? "initial discovery pending" : row.disabled ? "disabled" : "enabled"].filter(Boolean);
     return `${row.namespaced ?? `${row.provider}/${row.id}`}  [${flags.join(", ")}]`;
   }));
 }
diff --git a/src/codex/catalog/parsing.ts b/src/codex/catalog/parsing.ts
index 0677da9a8ab..19e04905122 100644
--- a/src/codex/catalog/parsing.ts
+++ b/src/codex/catalog/parsing.ts
@@ -144,6 +144,18 @@ export interface CatalogModel {
   codexToolMode?: "code_mode_only" | "shell";
   /** Normalized upstream capability names retained for management/API consumers (#485 follow-up). */
   capabilities?: string[];
+  /**
+   * Discovered per-token cost class for this routed model (#3666). "free" means the provider's
+   * own /models row reported a numeric zero for BOTH the prompt and the completion rate;
+   * "paid" means at least one rate is above zero. ABSENT means unknown — the provider published
+   * no usable pair, or this row never came from a models API at all.
+   *
+   * Fail closed: a partial, non-numeric, or negative rate leaves the field absent, never "free",
+   * because showing a paid model under a Free filter costs the user money while hiding a free
+   * one costs a click. This is a management/Dashboard projection only — deriveEntry never
+   * serializes it into the Codex catalog, and it never affects routing or visibility.
+   */
+  pricingStatus?: "free" | "paid";
   /** OpenCodex-only catalog ownership marker; Codex ignores the serialized extension field. */
   catalogKind?: typeof CODEX_CUSTOM_MODEL_CATALOG_KIND | typeof CODEX_PROVIDER_MODEL_CATALOG_KIND;
 }
diff --git a/src/codex/catalog/provider-fetch.ts b/src/codex/catalog/provider-fetch.ts
index 9b50636f8f3..25bdc0ce9c3 100644
--- a/src/codex/catalog/provider-fetch.ts
+++ b/src/codex/catalog/provider-fetch.ts
@@ -1401,6 +1401,51 @@ function modelInputModalities(
   return undefined;
 }
 
+/**
+ * A per-token rate exactly as a /models row publishes it, or undefined when the value is not a
+ * usable non-negative number. Providers ship these both as JSON numbers and as decimal strings —
+ * OpenRouter encodes free as the string `"0.00000000"` — so both shapes are accepted and nothing
+ * else is. The explicit numeric-shape test has to run BEFORE any coercion: `Number("")` and
+ * `Number(" ")` are both 0 and `Number(true)` is 1, so a bare `Number(value)` would classify a
+ * row with an empty price string as free.
+ */
+const DISCOVERED_PRICING_RATE_PATTERN = /^-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?$/;
+
+function discoveredPricingRate(value: unknown): number | undefined {
+  const numeric = typeof value === "number"
+    ? value
+    : typeof value === "string" && DISCOVERED_PRICING_RATE_PATTERN.test(value.trim())
+      ? Number(value.trim())
+      : undefined;
+  if (numeric === undefined || !Number.isFinite(numeric) || numeric < 0) return undefined;
+  return numeric;
+}
+
+/**
+ * Cost class for one discovered row, read from the provider's own `pricing` object (#3666).
+ *
+ * Fail closed. Only a complete pair of non-negative numeric rates classifies at all; a missing,
+ * one-sided, non-numeric, or negative rate is "unknown" and therefore excluded from a free-only
+ * filter. Showing a paid model under a Free filter spends the user's money, while hiding a free
+ * one costs a click.
+ *
+ * Two things that look like evidence and are not. A `:free` id suffix is an OpenRouter naming
+ * convention, not a price — Nous ships `:free` slugs on a provider whose `freeTier` is false on
+ * purpose. And the operator's own `modelCosts` overlay is an estimate they typed, not something
+ * the provider published, so a zeroed overlay never reaches this field either.
+ *
+ * Classification is on numeric zero and never on a unit conversion: OpenRouter quotes USD per
+ * token while the cost overlays and the jawcode bundle quote per 1M, and zero is zero in both.
+ */
+export function discoveredPricingStatus(item: ProviderModelsApiItem): "free" | "paid" | "unknown" {
+  const pricing = plainRecord(item.pricing) ?? plainRecord(plainRecord(item.metadata)?.pricing);
+  if (!pricing) return "unknown";
+  const prompt = discoveredPricingRate(pricing.prompt ?? pricing.input);
+  const completion = discoveredPricingRate(pricing.completion ?? pricing.output);
+  if (prompt === undefined || completion === undefined) return "unknown";
+  return prompt === 0 && completion === 0 ? "free" : "paid";
+}
+
 export function catalogHintsFromModelsApiItem(providerName: string, item: ProviderModelsApiItem): Partial<CatalogModel> {
   const metadata = plainRecord(item.metadata);
   const capabilityRecord = plainRecord(metadata?.capabilities) ?? plainRecord(item.capabilities);
@@ -1465,6 +1510,7 @@ export function catalogHintsFromModelsApiItem(providerName: string, item: Provid
       : undefined;
   const capabilities = modelCapabilities(item);
   const inputModalities = modelInputModalities(item, capabilities);
+  const pricingStatus = discoveredPricingStatus(item);
   return {
     ...(contextWindow && contextWindow > 0 ? { contextWindow } : {}),
     ...(maxInputTokens && maxInputTokens > 0 ? { maxInputTokens } : {}),
@@ -1472,6 +1518,11 @@ export function catalogHintsFromModelsApiItem(providerName: string, item: Provid
     ...(reasoningEfforts !== undefined ? { reasoningEfforts } : {}),
     ...(inputModalities ? { inputModalities } : {}),
     ...(capabilities ? { capabilities } : {}),
+    // Omitted when the classification is "unknown", following this function's existing
+    // contract that an unknown property is absent rather than present-and-empty. Callers
+    // that need to tell "provider published no prices" from "this build does not classify"
+    // call discoveredPricingStatus directly.
+    ...(pricingStatus !== "unknown" ? { pricingStatus } : {}),
   };
 }
 
diff --git a/tests/cli/cli-models-free-only.test.ts b/tests/cli/cli-models-free-only.test.ts
new file mode 100644
index 00000000000..a77b3915184
--- /dev/null
+++ b/tests/cli/cli-models-free-only.test.ts
@@ -0,0 +1,67 @@
+import { describe, expect, test } from "bun:test";
+import { handleModelsRuntimeCommand } from "../../src/cli/models-runtime";
+
+/**
+ * Regression coverage for #3666 — the CLI half.
+ *
+ * The issue asks for `ocx model list --free-only`. That command does not exist; the live
+ * catalog listing is `ocx models live`, so the flag lands there, on the same
+ * `pricingStatus` the Dashboard filter reads. Absent `pricingStatus` is excluded for the
+ * same fail-closed reason the classifier omits it: a model the provider never priced is not
+ * evidence of a free one.
+ */
+const ROWS = [
+  { provider: "openrouter", id: "gemma:free", namespaced: "openrouter/gemma:free", pricingStatus: "free" },
+  { provider: "openrouter", id: "claude-sonnet-5", namespaced: "openrouter/claude-sonnet-5", pricingStatus: "paid" },
+  { provider: "openrouter", id: "mystery", namespaced: "openrouter/mystery" },
+  { provider: "ollama", id: "llama3.2", namespaced: "ollama/llama3.2", pricingStatus: "free" },
+];
+
+async function runLive(args: string[]): Promise<{ code: number | null; out: string[] }> {
+  const out: string[] = [];
+  const original = console.log;
+  console.log = (...parts: unknown[]) => { out.push(parts.map(String).join(" ")); };
+  try {
+    const code = await handleModelsRuntimeCommand("live", args, {
+      baseUrl: "http://127.0.0.1:1",
+      fetchImpl: (async () => Response.json(ROWS)) as unknown as typeof fetch,
+    });
+    return { code, out };
+  } finally {
+    console.log = original;
+  }
+}
+
+describe("ocx models live --free-only (#3666)", () => {
+  test("--free-only keeps only rows the provider priced at zero", async () => {
+    const { code, out } = await runLive(["--free-only", "--json"]);
+    expect(code).toBe(0);
+    const rows = JSON.parse(out.join("\n")) as Array<{ namespaced: string }>;
+    expect(rows.map(row => row.namespaced)).toEqual(["openrouter/gemma:free", "ollama/llama3.2"]);
+  });
+
+  test("--free-only composes with --provider instead of replacing it", async () => {
+    const { out } = await runLive(["--provider", "openrouter", "--free-only", "--json"]);
+    const rows = JSON.parse(out.join("\n")) as Array<{ namespaced: string }>;
+    expect(rows.map(row => row.namespaced)).toEqual(["openrouter/gemma:free"]);
+  });
+
+  test("without the flag every row is still listed", async () => {
+    const { out } = await runLive(["--json"]);
+    expect((JSON.parse(out.join("\n")) as unknown[]).length).toBe(ROWS.length);
+  });
+
+  test("the human listing marks a free row so the flag is discoverable", async () => {
+    const { out } = await runLive([]);
+    // Read the bracketed flag list, not the whole line: "openrouter/gemma:free" contains the
+    // word "free" in its own id, so a substring check on the line would pass vacuously.
+    const flags = (prefix: string): string => {
+      const line = out.find(entry => entry.startsWith(prefix)) ?? "";
+      return line.slice(line.indexOf("["));
+    };
+    expect(flags("ollama/llama3.2")).toContain("free");
+    expect(flags("openrouter/gemma:free")).toContain("free");
+    expect(flags("openrouter/claude-sonnet-5")).not.toContain("free");
+    expect(flags("openrouter/mystery")).not.toContain("free");
+  });
+});
diff --git a/tests/codex-integration/catalog-free-pricing-status.test.ts b/tests/codex-integration/catalog-free-pricing-status.test.ts
new file mode 100644
index 00000000000..8fc0294d503
--- /dev/null
+++ b/tests/codex-integration/catalog-free-pricing-status.test.ts
@@ -0,0 +1,148 @@
+import { describe, expect, test } from "bun:test";
+import { catalogHintsFromModelsApiItem, discoveredPricingStatus } from "../../src/codex/catalog/provider-fetch";
+import { deriveEntry } from "../../src/codex/catalog/sync";
+import { clearModelCache } from "../../src/codex/model-cache";
+import { listManagementModelRows } from "../../src/server/management/model-rows";
+import { withStubbedProviderFetch } from "../helpers/catalog-provider-fetch";
+import type { OcxConfig } from "../../src/types";
+
+/**
+ * Regression coverage for #3666 — no way to filter free models in the Dashboard catalog.
+ *
+ * Live `/models` rows already carried `pricing`, but nothing downstream kept it:
+ * `catalogHintsFromModelsApiItem` returned only window / modalities / reasoning / capabilities,
+ * so `CatalogModel` had no cost field and both Dashboard lists could only substring-search. The
+ * "Free" UI that existed was PROVIDER tier (`freeTier` / `keyOptional`), which is exactly why
+ * OpenRouter — `freeTier` unset, paid and `:free` slugs mixed in one catalog — could not be
+ * narrowed to $0 models.
+ *
+ * The classifier is deliberately fail-closed. Showing a paid model under a Free filter spends
+ * the user's money; hiding a free one costs a click. So only a complete pair of non-negative
+ * numeric rates classifies at all, and everything else stays unknown.
+ */
+describe("discovered model pricing classification (#3666)", () => {
+  test("an OpenRouter free row classifies free from zero rate strings", () => {
+    // OpenRouter quotes USD PER TOKEN as decimal strings; "0.00000000" is how it writes free.
+    const item = { id: "google/gemma-3-1b-it:free", pricing: { prompt: "0.00000000", completion: "0" } };
+    expect(discoveredPricingStatus(item)).toBe("free");
+    expect(catalogHintsFromModelsApiItem("openrouter", item).pricingStatus).toBe("free");
+  });
+
+  test("numeric zeros classify free too", () => {
+    expect(discoveredPricingStatus({ id: "local/free", pricing: { prompt: 0, completion: 0 } })).toBe("free");
+  });
+
+  test("a priced row classifies paid", () => {
+    const item = { id: "anthropic/claude-sonnet-5", pricing: { prompt: "0.000003", completion: "0.000015" } };
+    expect(discoveredPricingStatus(item)).toBe("paid");
+    expect(catalogHintsFromModelsApiItem("openrouter", item).pricingStatus).toBe("paid");
+  });
+
+  test("a single non-zero rate is enough to be paid", () => {
+    // A free prompt with a billed completion is still a model that charges.
+    expect(discoveredPricingStatus({ id: "half", pricing: { prompt: "0", completion: "0.000001" } })).toBe("paid");
+    expect(discoveredPricingStatus({ id: "half2", pricing: { prompt: "1e-6", completion: "0" } })).toBe("paid");
+  });
+
+  test("a provider that publishes no pricing is unknown, and the hint field is absent", () => {
+    expect(discoveredPricingStatus({ id: "llama3.2" })).toBe("unknown");
+    // Absent rather than present-and-"unknown": catalogHintsFromModelsApiItem's contract is that
+    // an unknown property does not appear, which several provider contract tests deep-equal.
+    expect(catalogHintsFromModelsApiItem("ollama", { id: "llama3.2" }).pricingStatus).toBeUndefined();
+    expect(Object.hasOwn(catalogHintsFromModelsApiItem("ollama", { id: "llama3.2" }), "pricingStatus")).toBe(false);
+  });
+
+  test("a one-sided pair never classifies free", () => {
+    expect(discoveredPricingStatus({ id: "prompt-only", pricing: { prompt: "0" } })).toBe("unknown");
+    expect(discoveredPricingStatus({ id: "completion-only", pricing: { completion: 0 } })).toBe("unknown");
+  });
+
+  test("negative and non-numeric rates never classify free", () => {
+    expect(discoveredPricingStatus({ id: "neg", pricing: { prompt: -1, completion: 0 } })).toBe("unknown");
+    expect(discoveredPricingStatus({ id: "word", pricing: { prompt: "free", completion: "free" } })).toBe("unknown");
+    // The shape test has to run before coercion: Number("") and Number(" ") are both 0, and
+    // Number(true) is 1, so a bare Number() would have called each of these free or paid.
+    expect(discoveredPricingStatus({ id: "empty", pricing: { prompt: "", completion: "" } })).toBe("unknown");
+    expect(discoveredPricingStatus({ id: "blank", pricing: { prompt: " ", completion: " " } })).toBe("unknown");
+    expect(discoveredPricingStatus({ id: "bool", pricing: { prompt: true, completion: true } })).toBe("unknown");
+    expect(discoveredPricingStatus({ id: "nan", pricing: { prompt: Number.NaN, completion: 0 } })).toBe("unknown");
+    expect(discoveredPricingStatus({ id: "inf", pricing: { prompt: Number.POSITIVE_INFINITY, completion: 0 } })).toBe("unknown");
+    expect(discoveredPricingStatus({ id: "null", pricing: null })).toBe("unknown");
+  });
+
+  test("input/output are accepted as the rate names, and metadata.pricing is read", () => {
+    expect(discoveredPricingStatus({ id: "io", pricing: { input: 0, output: 0 } })).toBe("free");
+    expect(discoveredPricingStatus({ id: "io-paid", pricing: { input: "0.5", output: "1.5" } })).toBe("paid");
+    expect(discoveredPricingStatus({ id: "nested", metadata: { pricing: { prompt: 0, completion: 0 } } })).toBe("free");
+  });
+
+  test("a :free id suffix is not evidence by itself", () => {
+    // Nous ships :free slugs on a provider whose freeTier is false on purpose, so the naming
+    // convention must never stand in for a published price.
+    expect(discoveredPricingStatus({ id: "nousresearch/hermes-4-70b:free" })).toBe("unknown");
+    expect(discoveredPricingStatus({
+      id: "vendor/model:free",
+      pricing: { prompt: "0.000002", completion: "0.000004" },
+    })).toBe("paid");
+  });
+
+  test("the field is a management projection and never reaches the written Codex catalog", () => {
+    const entry = deriveEntry(null, "openrouter/gemma-free", "desc", 10, {
+      id: "gemma-free",
+      provider: "openrouter",
+      pricingStatus: "free",
+    });
+    expect(JSON.stringify(entry)).not.toContain("pricing");
+  });
+});
+
+/**
+ * The classifier above is only useful if the field survives the whole projection. It is set on a
+ * discovery hint, merged by `applyProviderConfigHints`, spread by `listManagementModelRows`, and
+ * read by the Dashboard and the CLI off `GET /api/models` — four hops, none of which names the
+ * field explicitly, so any one of them could drop it without a single unit test noticing.
+ */
+describe("pricingStatus on the /api/models wire (#3666)", () => {
+  const PROVIDER = "pricing-wire-test";
+
+  function fixture(): OcxConfig {
+    return withStubbedProviderFetch({
+      port: 10100,
+      modelCacheTtlMs: 0,
+      providers: {
+        [PROVIDER]: {
+          adapter: "openai-chat",
+          // A literal address: discovery pins the peer, so a hostname would need real DNS.
+          baseUrl: "https://93.184.216.34/v1",
+          apiKey: "sk-test",
+        },
+      },
+    } as OcxConfig);
+  }
+
+  test("a discovered free row carries the field to the management row list", async () => {
+    const previousFetch = globalThis.fetch;
+    globalThis.fetch = (async () => Response.json({
+      data: [
+        { id: "gemma-free", pricing: { prompt: "0.00000000", completion: "0" } },
+        { id: "sonnet-paid", pricing: { prompt: "0.000003", completion: "0.000015" } },
+        { id: "unpriced" },
+      ],
+    })) as typeof fetch;
+    try {
+      const rows = await listManagementModelRows(fixture(), { entitlementWaitMs: 0 });
+      const byId = (id: string) => rows.find(row => row.provider === PROVIDER && row.id === id);
+      expect(byId("gemma-free")?.pricingStatus).toBe("free");
+      expect(byId("sonnet-paid")?.pricingStatus).toBe("paid");
+      // Absent, not "unknown": the same omission contract the hint follows reaches the wire, so
+      // a client that treats a missing field as not-free is reading the intended signal.
+      expect(byId("unpriced")).toBeDefined();
+      expect(Object.hasOwn(byId("unpriced")!, "pricingStatus")).toBe(false);
+      // Orthogonal to the operator's own overlay marker, which no row here has.
+      expect(rows.every(row => !Object.hasOwn(row, "manualPricing"))).toBe(true);
+    } finally {
+      globalThis.fetch = previousFetch;
+      clearModelCache(PROVIDER);
+    }
+  });
+});
diff --git a/tests/fixtures/test-layout-expected.json b/tests/fixtures/test-layout-expected.json
index b5fc9651da5..d35003e6c8c 100644
--- a/tests/fixtures/test-layout-expected.json
+++ b/tests/fixtures/test-layout-expected.json
@@ -100,6 +100,7 @@
   "bun-stream-caps.test.ts": "lib",
   "cancel-body-on-abort.test.ts": "server",
   "catalog-cursor-search.test.ts": "codex-integration",
+  "catalog-free-pricing-status.test.ts": "codex-integration",
   "catalog-full-picker-order.test.ts": "codex-integration",
   "catalog-go-exact-efforts.test.ts": "codex-integration",
   "catalog-hub-context-window.test.ts": "codex-integration",
@@ -173,6 +174,7 @@
   "cli-help.test.ts": "cli",
   "cli-json-contract.test.ts": "cli",
   "cli-management-auth.test.ts": "cli",
+  "cli-models-free-only.test.ts": "cli",
   "cli-models-price.test.ts": "cli",
   "cli-models-reasoning.test.ts": "cli",
   "cli-models-runtime-dispatch.test.ts": "cli",
@@ -667,6 +669,7 @@
   "model-selection-guidance.test.ts": "cli",
   "model-visibility-management-api.test.ts": "codex-integration",
   "models-feedback-callback.test.ts": "gui",
+  "models-free-filter.test.ts": "gui",
   "models-page-groups.test.ts": "gui",
   "models-workspace-tabs.test.ts": "gui",
   "moonshot-endpoints.test.ts": "providers",
diff --git a/tests/gui/models-free-filter.test.ts b/tests/gui/models-free-filter.test.ts
new file mode 100644
index 00000000000..f32cd748256
--- /dev/null
+++ b/tests/gui/models-free-filter.test.ts
@@ -0,0 +1,177 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import {
+  filterFreeModelRows,
+  freeOnlyInForce,
+  modelPricingKnown,
+  type ModelRow,
+} from "../../gui/src/pages/models-shared";
+import { repoPath } from "../helpers/repo-root";
+
+/**
+ * Regression coverage for #3666 — the Dashboard half.
+ *
+ * Both catalog surfaces (the Models page provider group and the provider workspace inventory)
+ * share one predicate so they cannot drift into disagreeing about what "free" means. The
+ * filter runs BEFORE each surface's own search, enabled-first sort, and page slice: applying
+ * it afterwards would leave free models stranded behind Show more on a 200-row OpenRouter
+ * list, which is exactly the case the issue reports.
+ */
+function row(id: string, pricingStatus?: "free" | "paid"): ModelRow {
+  return {
+    provider: "openrouter",
+    id,
+    namespaced: `openrouter/${id}`,
+    disabled: false,
+    ...(pricingStatus ? { pricingStatus } : {}),
+  };
+}
+
+describe("Dashboard free-only model filter (#3666)", () => {
+  const rows = [row("gemma:free", "free"), row("claude-sonnet-5", "paid"), row("mystery")];
+
+  test("free-only keeps exactly the rows the provider priced at zero", () => {
+    expect(filterFreeModelRows(rows, true).map(r => r.id)).toEqual(["gemma:free"]);
+  });
+
+  test("an unclassified row is never treated as free", () => {
+    // Absent pricingStatus means the provider published no usable rate pair, or the row came
+    // from a cache written before the field existed. Neither is evidence of $0.
+    expect(filterFreeModelRows([row("mystery")], true)).toEqual([]);
+  });
+
+  test("off, the filter passes every row through unchanged and in order", () => {
+    expect(filterFreeModelRows(rows, false).map(r => r.id)).toEqual(rows.map(r => r.id));
+  });
+
+  test("the control is offered only where discovery actually returned prices", () => {
+    // A provider whose rows are all unclassified would otherwise get a switch whose only
+    // possible effect is to empty its own list, which reads as a broken filter.
+    expect(modelPricingKnown([row("llama3.2"), row("qwen3")])).toBe(false);
+    expect(modelPricingKnown(rows)).toBe(true);
+    expect(modelPricingKnown([row("claude-sonnet-5", "paid")])).toBe(true);
+    expect(modelPricingKnown([])).toBe(false);
+  });
+
+  test("filtering does not mutate the caller's list", () => {
+    const source = [...rows];
+    filterFreeModelRows(source, true);
+    expect(source.map(r => r.id)).toEqual(rows.map(r => r.id));
+  });
+});
+
+/**
+ * The predicate cases above pin WHAT is kept. They cannot see WHERE the filter runs, and the
+ * placement is the half that actually closes #3666: a build that filtered after
+ * `sorted.slice(0, shown)` would keep every predicate case green while leaving free models
+ * stranded behind Show more on a 200-row OpenRouter list — the exact symptom reported.
+ *
+ * Both consumers are read as source because the ordering is a property of the pipeline, not of
+ * any value either component returns.
+ */
+describe("free-only runs before the page slice (#3666)", () => {
+  const modelsPage = readFileSync(repoPath("gui", "src", "pages", "Models.tsx"), "utf8");
+  const inventory = readFileSync(
+    repoPath("gui", "src", "components", "provider-workspace", "ProviderModels.tsx"),
+    "utf8",
+  );
+
+  /** Index of one landmark, asserted present so a rename fails loudly instead of vacuously. */
+  function at(source: string, needle: string): number {
+    const index = source.indexOf(needle);
+    expect(index, `landmark not found: ${needle}`).toBeGreaterThan(-1);
+    return index;
+  }
+
+  test("the Models page filters, then searches, then sorts, then slices", () => {
+    const filter = at(modelsPage, "const scoped = filterFreeModelRows(rows, freeOnlyActive)");
+    const search = at(modelsPage, "scoped.filter(m => m.id.toLowerCase().includes(q))");
+    const sort = at(modelsPage, "filtered.toSorted(");
+    const slice = at(modelsPage, "sorted.slice(0, shown)");
+    expect(filter).toBeLessThan(search);
+    expect(search).toBeLessThan(sort);
+    expect(sort).toBeLessThan(slice);
+  });
+
+  test("the provider inventory filters before its chip render cap", () => {
+    const filter = at(inventory, "filterFreeModelRows(visible, freeOnlyActive)");
+    const slice = at(inventory, "filtered.slice(0, CHIP_RENDER_CAP)");
+    expect(filter).toBeLessThan(slice);
+  });
+
+  test("the group header counts the scoped set, not the whole provider", () => {
+    // With Free only on, a header reading `rows.length` claims more models than the list under
+    // it shows. The bulk actions read the same set, so "All on" cannot reach rows the header is
+    // not counting.
+    //
+    // Scoped to the renderGroup body on purpose. The provider rail further down the file renders
+    // the same models.active label from its own locally computed activeCount, and it SHOULD keep
+    // reading the whole provider: it is a navigation index answering "how big is this provider",
+    // not a description of the list the user is currently looking at.
+    const start = at(modelsPage, "const renderGroup = (group:");
+    const end = at(modelsPage, "models-workspace-rail-row");
+    expect(start).toBeLessThan(end);
+    const group = modelsPage.slice(start, end);
+    expect(group).toContain('t("models.active", { active: activeCount, total: scoped.length })');
+    expect(group).toContain("const activeCount = scoped.filter(isVisible).length");
+    expect(group).toContain("scoped.map(m => ({ id: m.id, native: m.native === true }))");
+    expect(group).not.toContain('total: rows.length })');
+  });
+
+  test("both surfaces gate the narrowing on the same condition that shows the switch", () => {
+    // The switch renders under `pricingKnown`, but the operator's choice is component state that
+    // outlives the rows it was made against. If the filter kept reading the raw flag, a refresh
+    // that came back without pricing would hide the control and empty the list at the same time,
+    // leaving no way to undo it. Both consumers must read the derived flag.
+    expect(modelsPage).toContain("const freeOnlyActive = freeOnlyInForce(freeOnlyOn, rows)");
+    expect(modelsPage).not.toContain("filterFreeModelRows(rows, freeOnlyOn)");
+    expect(inventory).toContain("const freeOnlyActive = freeOnlyInForce(freeOnly, visible)");
+    expect(inventory).not.toContain("filterFreeModelRows(visible, freeOnly)");
+  });
+
+  test("the empty-state copy is bound to the same derived flag", () => {
+    // `models.noFreeMatch` reads "turn off Free only". Printing it while the switch is hidden
+    // tells the user to use a control that is not on screen.
+    expect(modelsPage).toContain("{freeOnlyActive && scoped.length === 0 && rows.length > 0 && (");
+    expect(inventory).toContain('t(freeOnlyActive && priced.length === 0 ? "models.noFreeMatch"');
+  });
+});
+
+/**
+ * The stale-evidence path.
+ *
+ * `freeOnly` is per-provider component state with no reset. `pricingKnown` is derived from the
+ * rows on every render. They can disagree, and the only dangerous direction is on-with-no-prices:
+ * the switch is gone, every row is unclassified, and an ungated filter returns nothing.
+ */
+describe("free-only lapses when the pricing evidence does", () => {
+  const priced = [row("gemma:free", "free"), row("claude-sonnet-5", "paid")];
+  const unpriced = [row("llama3.2"), row("qwen3")];
+
+  test("on, with prices, the narrowing is in force", () => {
+    expect(freeOnlyInForce(true, priced)).toBe(true);
+  });
+
+  test("on, after the prices disappear, the narrowing lapses instead of emptying the list", () => {
+    expect(freeOnlyInForce(true, unpriced)).toBe(false);
+    expect(filterFreeModelRows(unpriced, freeOnlyInForce(true, unpriced)).map(r => r.id))
+      .toEqual(["llama3.2", "qwen3"]);
+    // Ungated, this is the reported trap: an empty list under a switch that is no longer drawn.
+    expect(filterFreeModelRows(unpriced, true)).toEqual([]);
+  });
+
+  test("an empty provider never leaves the narrowing in force", () => {
+    expect(freeOnlyInForce(true, [])).toBe(false);
+  });
+
+  test("off is off regardless of the evidence", () => {
+    expect(freeOnlyInForce(false, priced)).toBe(false);
+    expect(freeOnlyInForce(false, unpriced)).toBe(false);
+  });
+
+  test("the gate agrees with the condition that renders the control", () => {
+    for (const rows of [priced, unpriced, []]) {
+      expect(freeOnlyInForce(true, rows)).toBe(modelPricingKnown(rows));
+    }
+  });
+});