diff --git a/apps/src/app/models/page.tsx b/apps/src/app/models/page.tsx
index 7e173a983..298457f58 100644
--- a/apps/src/app/models/page.tsx
+++ b/apps/src/app/models/page.tsx
@@ -34,7 +34,6 @@ import {
 } from "@/components/ui/dialog";
 import {
   Empty,
-  EmptyDescription,
   EmptyHeader,
   EmptyTitle,
 } from "@/components/ui/empty";
@@ -132,6 +131,7 @@ export default function ModelsPage() {
     isLoading,
     isServiceReady,
     refreshRemote,
+    pruneStaleRemoteModels,
     saveModel,
     deleteModel,
     deleteModels,
@@ -139,6 +139,7 @@ export default function ModelsPage() {
     routing,
     canExportCodexCache,
     isRefreshing,
+    isPruningStaleRemote,
     isSaving,
     isDeleting,
     isExporting,
@@ -612,13 +613,25 @@ export default function ModelsPage() {
                     <Button
                       variant="outline"
                       onClick={() => void refreshRemote()}
-                      disabled={isRefreshing}
+                      disabled={isRefreshing || isPruningStaleRemote}
                     >
                       <RefreshCw
                         className={`mr-2 h-4 w-4 ${isRefreshing ? "animate-spin" : ""}`}
                       />
                       {t("远端并入")}
                     </Button>
+                    <Button
+                      variant="outline"
+                      className="border-destructive/40 text-destructive hover:bg-destructive/10 hover:text-destructive"
+                      onClick={() => void pruneStaleRemoteModels()}
+                      disabled={isRefreshing || isPruningStaleRemote}
+                      title={t("仅删除未本地覆写且不再出现在远端目录中的远端模型，不会删除自定义模型。")}
+                    >
+                      <Trash2
+                        className={`mr-2 h-4 w-4 ${isPruningStaleRemote ? "animate-pulse" : ""}`}
+                      />
+                      {t("清理远端旧模型")}
+                    </Button>
                     {canExportCodexCache ? (
                       <Button
                         variant="outline"
diff --git a/apps/src/hooks/useManagedModels.ts b/apps/src/hooks/useManagedModels.ts
index 1ae158f20..bd14c2ea8 100644
--- a/apps/src/hooks/useManagedModels.ts
+++ b/apps/src/hooks/useManagedModels.ts
@@ -180,6 +180,23 @@ export function useManagedModels() {
     },
   });
 
+  const pruneStaleRemoteMutation = useMutation({
+    mutationFn: () => accountClient.pruneStaleRemoteManagedModels(),
+    onSuccess: async (catalog) => {
+      queryClient.setQueryData(MANAGED_MODEL_QUERY_KEY, catalog);
+      const cacheSyncError = await syncCatalogToCodexCache(catalog);
+      await invalidateAll();
+      if (cacheSyncError) {
+        toast.error(`${t("远端旧模型已清理，但同步 Codex 模型缓存失败")}: ${cacheSyncError}`);
+      } else {
+        toast.success(t("远端旧模型已清理"));
+      }
+    },
+    onError: (error: unknown) => {
+      toast.error(`${t("清理远端旧模型失败")}: ${getAppErrorMessage(error)}`);
+    },
+  });
+
   const saveMutation = useMutation({
     mutationFn: (params: ManagedModelPayload) => accountClient.saveManagedModel(params),
     onSuccess: async () => {
@@ -401,6 +418,10 @@ export function useManagedModels() {
       if (!ensureServiceReady("读取模型")) return null;
       return refreshMutation.mutateAsync(false);
     },
+    pruneStaleRemoteModels: async () => {
+      if (!ensureServiceReady("清理远端旧模型")) return null;
+      return pruneStaleRemoteMutation.mutateAsync();
+    },
     saveModel: async (params: ManagedModelPayload) => {
       if (!ensureServiceReady("保存模型")) return null;
       return saveMutation.mutateAsync(params);
@@ -439,6 +460,7 @@ export function useManagedModels() {
       return true;
     },
     isRefreshing: refreshMutation.isPending,
+    isPruningStaleRemote: pruneStaleRemoteMutation.isPending,
     isSaving: saveMutation.isPending,
     isDeleting: deleteMutation.isPending || batchDeleteMutation.isPending,
     isExporting: exportMutation.isPending,
diff --git a/apps/src/lib/api/account-client.ts b/apps/src/lib/api/account-client.ts
index 5b887d7cf..d9293aa78 100644
--- a/apps/src/lib/api/account-client.ts
+++ b/apps/src/lib/api/account-client.ts
@@ -861,6 +861,13 @@ export const accountClient = {
   },
   deleteManagedModel: (slug: string) =>
     invoke("service_model_catalog_delete", withAddr({ slug })),
+  async pruneStaleRemoteManagedModels(): Promise<ManagedModelCatalog> {
+    const result = await invoke<unknown>(
+      "service_model_catalog_prune_stale_remote",
+      withAddr()
+    );
+    return normalizeManagedModelCatalog(result);
+  },
   async readApiKeySecret(keyId: string): Promise<string> {
     const result = await invoke<unknown>(
       "service_apikey_read_secret",
diff --git a/apps/src/lib/api/transport-web-commands.ts b/apps/src/lib/api/transport-web-commands.ts
index 1ab922cb0..94f81988a 100644
--- a/apps/src/lib/api/transport-web-commands.ts
+++ b/apps/src/lib/api/transport-web-commands.ts
@@ -527,8 +527,11 @@ export function createWebCommandMap(
       rpcMethod: "apikey/modelCatalogSave",
       mapParams: (params) => asRecord(asRecord(params)?.payload) ?? {},
     },
-    service_model_catalog_delete: { rpcMethod: "apikey/modelCatalogDelete" },
-    service_model_routing: { rpcMethod: "apikey/modelRouting" },
+    service_model_catalog_delete: { rpcMethod: "apikey/modelCatalogDelete" },
+    service_model_catalog_prune_stale_remote: {
+      rpcMethod: "apikey/modelCatalogPruneStaleRemote",
+    },
+    service_model_routing: { rpcMethod: "apikey/modelRouting" },
     service_model_source_sync: {
       rpcMethod: "apikey/modelSourceSync",
       mapParams: (params) => asRecord(asRecord(params)?.payload) ?? {},
diff --git a/apps/src/lib/i18n/messages/en.ts b/apps/src/lib/i18n/messages/en.ts
index 0419e71fe..99eddb153 100644
--- a/apps/src/lib/i18n/messages/en.ts
+++ b/apps/src/lib/i18n/messages/en.ts
@@ -1436,6 +1436,13 @@ export const EN_MESSAGES: MessageCatalog = {
   "按 slug、显示名称或描述快速定位，并结合来源与覆写状态查看当前目录。":
     "Quickly locate entries by slug, display name, or description, and review the current catalog together with source and override status.",
   "远端并入": "Merge remote",
+  "清理远端旧模型": "Prune stale remote models",
+  "远端旧模型已清理": "Stale remote models pruned",
+  "清理远端旧模型失败": "Failed to prune stale remote models",
+  "远端旧模型已清理，但同步 Codex 模型缓存失败":
+    "Stale remote models were pruned, but syncing the Codex model cache failed",
+  "仅删除未本地覆写且不再出现在远端目录中的远端模型，不会删除自定义模型。":
+    "Only deletes remote models that have no local override and no longer appear in the remote catalog. Custom models are not deleted.",
   "新增自定义模型": "Add custom model",
   "模型总数": "Total models",
   "API 可用": "API available",
diff --git a/crates/core/src/storage/model_groups.rs b/crates/core/src/storage/model_groups.rs
index e9174ab85..94dcaf1b5 100644
--- a/crates/core/src/storage/model_groups.rs
+++ b/crates/core/src/storage/model_groups.rs
@@ -112,6 +112,7 @@ impl Storage {
                AND TRIM(slug) <> ''",
             params![DEFAULT_MODEL_GROUP_ID, now],
         )?;
+        self.prune_default_model_group_models_not_in_catalog()?;
         self.conn.execute(
             "INSERT OR IGNORE INTO user_model_groups (
                 user_id, group_id, status, expires_at, created_at, updated_at
@@ -125,6 +126,34 @@ impl Storage {
         Ok(())
     }
 
+    pub fn prune_default_model_group_models_not_in_catalog(&self) -> Result<()> {
+        self.conn.execute(
+            "DELETE FROM model_group_models
+             WHERE group_id IN (SELECT id FROM model_groups WHERE is_default = 1)
+               AND platform_model_slug NOT IN (
+                   SELECT slug
+                   FROM model_catalog_models
+                   WHERE scope = 'default'
+                     AND COALESCE(supported_in_api, 1) = 1
+                     AND TRIM(slug) <> ''
+               )",
+            [],
+        )?;
+        Ok(())
+    }
+
+    pub fn delete_model_group_model_references(&self, platform_model_slug: &str) -> Result<()> {
+        let slug = platform_model_slug.trim();
+        if slug.is_empty() {
+            return Ok(());
+        }
+        self.conn.execute(
+            "DELETE FROM model_group_models WHERE platform_model_slug = ?1",
+            params![slug],
+        )?;
+        Ok(())
+    }
+
     pub fn default_model_group_id(&self) -> Result<Option<String>> {
         self.conn
             .query_row(
diff --git a/crates/core/src/storage/model_options.rs b/crates/core/src/storage/model_options.rs
index c829fe4b0..59e563f68 100644
--- a/crates/core/src/storage/model_options.rs
+++ b/crates/core/src/storage/model_options.rs
@@ -170,6 +170,7 @@ impl Storage {
             return Ok(());
         }
 
+        self.prune_default_model_group_models_not_in_catalog()?;
         let now = now_ts();
         self.conn.execute(
             "INSERT OR IGNORE INTO model_group_models (
diff --git a/crates/core/src/storage/model_sources.rs b/crates/core/src/storage/model_sources.rs
index 58432a031..fe855537c 100644
--- a/crates/core/src/storage/model_sources.rs
+++ b/crates/core/src/storage/model_sources.rs
@@ -368,4 +368,24 @@ impl Storage {
         )?;
         Ok(())
     }
+
+    pub fn delete_model_source_routes_for_platform_model(
+        &self,
+        platform_model_slug: &str,
+    ) -> Result<()> {
+        let slug = normalize_text(platform_model_slug);
+        if slug.is_empty() {
+            return Ok(());
+        }
+        self.conn.execute(
+            "DELETE FROM model_source_mappings
+             WHERE platform_model_slug = ?1 OR upstream_model = ?1",
+            params![&slug],
+        )?;
+        self.conn.execute(
+            "DELETE FROM model_source_models WHERE upstream_model = ?1",
+            params![&slug],
+        )?;
+        Ok(())
+    }
 }
diff --git a/crates/service/src/apikey/apikey_models.rs b/crates/service/src/apikey/apikey_models.rs
index c7bffb181..a7283114b 100644
--- a/crates/service/src/apikey/apikey_models.rs
+++ b/crates/service/src/apikey/apikey_models.rs
@@ -76,7 +76,7 @@ pub(crate) fn read_managed_model_catalog(
     let cached_catalog = read_managed_model_catalog_from_storage(&storage)?;
     let cached = managed_catalog_to_models_response(&cached_catalog);
     if !refresh_remote && !cached.is_empty() {
-        return Ok(ensure_codex_image_tool_model_in_catalog(&cached_catalog));
+        return Ok(cached_catalog);
     }
 
     match gateway::fetch_models_for_picker() {
@@ -88,7 +88,7 @@ pub(crate) fn read_managed_model_catalog(
                         "event=model_catalog_refresh_ignored_empty_remote cached_models={}",
                         cached_catalog.items.len()
                     );
-                    return Ok(ensure_codex_image_tool_model_in_catalog(&cached_catalog));
+                    return Ok(cached_catalog);
                 }
                 if refresh_remote {
                     return Err(
@@ -96,9 +96,7 @@ pub(crate) fn read_managed_model_catalog(
                     );
                 }
             }
-            let merged_catalog = ensure_codex_image_tool_model_in_catalog(
-                &merge_managed_model_catalog(cached_catalog.clone(), models),
-            );
+            let merged_catalog = merge_managed_model_catalog(cached_catalog.clone(), models);
             if !merged_catalog.items.is_empty() {
                 let _ = save_managed_model_catalog_with_storage(&storage, &merged_catalog);
             }
@@ -106,14 +104,12 @@ pub(crate) fn read_managed_model_catalog(
         }
         Err(err) => {
             if managed_catalog_has_catalog_text_model(&cached_catalog) {
-                return Ok(ensure_codex_image_tool_model_in_catalog(&cached_catalog));
+                return Ok(cached_catalog);
             }
             if refresh_remote {
                 Err(err)
             } else {
-                Ok(ensure_codex_image_tool_model_in_catalog(
-                    &ManagedModelCatalogResult::default(),
-                ))
+                Ok(ManagedModelCatalogResult::default())
             }
         }
     }
@@ -141,6 +137,7 @@ fn managed_catalog_has_catalog_text_model(catalog: &ManagedModelCatalogResult) -
 pub(crate) fn read_managed_model_catalog_from_storage(
     storage: &Storage,
 ) -> Result<ManagedModelCatalogResult, String> {
+    purge_codex_image_tool_model(storage)?;
     let rows = storage
         .list_model_catalog_models(MODEL_CACHE_SCOPE_DEFAULT)
         .map_err(|e| e.to_string())?;
@@ -227,6 +224,12 @@ pub(crate) fn save_managed_model_catalog_model(
     let current_catalog = read_managed_model_catalog_from_storage(&storage)?;
     let normalized_model =
         normalize_model_info(params.model).ok_or_else(|| "模型 slug 不能为空".to_string())?;
+    if is_codex_image_tool_slug(normalized_model.slug.as_str()) {
+        return Err(format!(
+            "模型 `{}` 是 Codex 图片工具的内部模型，不能加入平台模型目录",
+            normalized_model.slug
+        ));
+    }
     let previous_slug = params
         .previous_slug
         .as_deref()
@@ -306,6 +309,25 @@ pub(crate) fn delete_managed_model_catalog_model(slug: &str) -> Result<(), Strin
     delete_model_catalog_entry(&storage, normalized_slug)
 }
 
+pub(crate) fn prune_stale_remote_managed_model_catalog() -> Result<ManagedModelCatalogResult, String>
+{
+    let storage =
+        storage_helpers::open_storage().ok_or_else(|| "storage unavailable".to_string())?;
+    let cached_catalog = read_managed_model_catalog_from_storage(&storage)?;
+    let remote_models = gateway::fetch_models_for_picker()?;
+    let remote_models = normalize_models_response(remote_models);
+    if !models_response_has_catalog_text_model(&remote_models) {
+        return Err("远端模型目录没有返回可用 Codex 文本模型，已拒绝清理本地目录".to_string());
+    }
+
+    let merged_catalog = merge_managed_model_catalog(cached_catalog, remote_models.clone());
+    if !merged_catalog.items.is_empty() {
+        save_managed_model_catalog_with_storage(&storage, &merged_catalog)?;
+    }
+    prune_unedited_remote_model_catalog_entries_missing_from_remote(&storage, &remote_models)?;
+    read_managed_model_catalog_from_storage(&storage)
+}
+
 pub(crate) fn read_managed_model_routing() -> Result<ManagedModelRoutingResult, String> {
     let storage =
         storage_helpers::open_storage().ok_or_else(|| "storage unavailable".to_string())?;
@@ -795,19 +817,12 @@ fn read_account_pool_platform_catalog(
 ) -> Result<ManagedModelCatalogResult, String> {
     let cached_catalog = read_managed_model_catalog_from_storage(storage)?;
     if !cached_catalog.items.is_empty() {
-        let catalog = ensure_codex_image_tool_model_in_catalog(&cached_catalog);
-        if catalog.items.len() != cached_catalog.items.len() {
-            let _ = save_managed_model_catalog_with_storage(storage, &catalog);
-        }
-        return Ok(catalog);
+        return Ok(cached_catalog);
     }
 
     if allow_remote_catalog_fetch {
         if let Ok(models) = gateway::fetch_models_for_picker() {
-            let catalog = ensure_codex_image_tool_model_in_catalog(&merge_managed_model_catalog(
-                cached_catalog.clone(),
-                models,
-            ));
+            let catalog = merge_managed_model_catalog(cached_catalog.clone(), models);
             if !catalog.items.is_empty() {
                 save_managed_model_catalog_with_storage(storage, &catalog)?;
                 return Ok(catalog);
@@ -1071,76 +1086,14 @@ fn generate_mapping_id() -> String {
 }
 
 fn managed_catalog_to_models_response(catalog: &ManagedModelCatalogResult) -> ModelsResponse {
-    ensure_codex_image_tool_model_listed(&ModelsResponse {
+    ModelsResponse {
         models: catalog
             .items
             .iter()
             .map(|item| item.model.clone())
             .collect::<Vec<_>>(),
         extra: catalog.extra.clone(),
-    })
-}
-
-fn codex_image_tool_model_info() -> ModelInfo {
-    let mut model = ModelInfo {
-        slug: CODEX_IMAGE_TOOL_MODEL.to_string(),
-        display_name: "GPT Image 2".to_string(),
-        description: Some("Image generation tool model for Codex image workflows.".to_string()),
-        supported_in_api: true,
-        visibility: Some("list".to_string()),
-        input_modalities: vec!["text".to_string(), "image".to_string()],
-        ..Default::default()
-    };
-    model.extra.insert(
-        "output_modalities".to_string(),
-        serde_json::json!(["image"]),
-    );
-    model
-}
-
-pub(crate) fn ensure_codex_image_tool_model_listed(models: &ModelsResponse) -> ModelsResponse {
-    if models.models.iter().any(|item| {
-        item.slug
-            .trim()
-            .eq_ignore_ascii_case(CODEX_IMAGE_TOOL_MODEL)
-    }) {
-        return models.clone();
     }
-    let mut augmented = models.clone();
-    augmented.models.push(codex_image_tool_model_info());
-    augmented.extra.remove("etag");
-    augmented
-}
-
-fn ensure_codex_image_tool_model_in_catalog(
-    catalog: &ManagedModelCatalogResult,
-) -> ManagedModelCatalogResult {
-    if catalog.items.iter().any(|item| {
-        item.model
-            .slug
-            .trim()
-            .eq_ignore_ascii_case(CODEX_IMAGE_TOOL_MODEL)
-    }) {
-        return catalog.clone();
-    }
-
-    let mut augmented = catalog.clone();
-    let sort_index = augmented
-        .items
-        .iter()
-        .map(|item| item.sort_index)
-        .max()
-        .unwrap_or(-1)
-        + 1;
-    augmented.items.push(ManagedModelCatalogEntry {
-        model: codex_image_tool_model_info(),
-        source_kind: MODEL_SOURCE_KIND_REMOTE.to_string(),
-        user_edited: false,
-        sort_index,
-        updated_at: 0,
-    });
-    augmented.extra.remove("etag");
-    augmented
 }
 
 fn normalize_managed_model_catalog(
@@ -1152,6 +1105,9 @@ fn normalize_managed_model_catalog(
         let Some(model) = normalize_model_info(item.model) else {
             continue;
         };
+        if is_codex_image_tool_slug(model.slug.as_str()) {
+            continue;
+        }
         if !seen.insert(model.slug.clone()) {
             continue;
         }
@@ -1264,6 +1220,9 @@ pub(crate) fn normalize_models_response(response: ModelsResponse) -> ModelsRespo
     let mut seen = HashSet::new();
     for model in response.models {
         if let Some(normalized) = normalize_model_info(model) {
+            if is_codex_image_tool_slug(normalized.slug.as_str()) {
+                continue;
+            }
             if seen.insert(normalized.slug.clone()) {
                 models.push(normalized);
             }
@@ -1557,6 +1516,7 @@ fn save_managed_model_catalog_rows(
     storage
         .upsert_model_catalog_available_in_plans(&available_in_plans)
         .map_err(|e| e.to_string())?;
+    purge_codex_image_tool_model(storage)?;
     Ok(())
 }
 
@@ -1703,6 +1663,12 @@ fn replace_model_catalog_entry(
 }
 
 fn delete_model_catalog_entry(storage: &Storage, slug: &str) -> Result<(), String> {
+    storage
+        .delete_model_group_model_references(slug)
+        .map_err(|e| e.to_string())?;
+    storage
+        .delete_model_source_routes_for_platform_model(slug)
+        .map_err(|e| e.to_string())?;
     storage
         .delete_model_catalog_reasoning_levels(MODEL_CACHE_SCOPE_DEFAULT, slug)
         .map_err(|e| e.to_string())?;
@@ -1732,6 +1698,34 @@ fn delete_model_catalog_entry(storage: &Storage, slug: &str) -> Result<(), Strin
     Ok(())
 }
 
+fn prune_unedited_remote_model_catalog_entries_missing_from_remote(
+    storage: &Storage,
+    remote_models: &ModelsResponse,
+) -> Result<(), String> {
+    let remote_slugs = remote_models
+        .models
+        .iter()
+        .map(|model| model.slug.as_str())
+        .collect::<HashSet<_>>();
+    let rows = storage
+        .list_model_catalog_models(MODEL_CACHE_SCOPE_DEFAULT)
+        .map_err(|e| e.to_string())?;
+    for row in rows {
+        let source_kind = normalize_source_kind(Some(row.source_kind.as_str()));
+        if source_kind == MODEL_SOURCE_KIND_REMOTE
+            && !row.user_edited
+            && !remote_slugs.contains(row.slug.as_str())
+        {
+            delete_model_catalog_entry(storage, row.slug.as_str())?;
+        }
+    }
+    Ok(())
+}
+
+fn purge_codex_image_tool_model(storage: &Storage) -> Result<(), String> {
+    delete_model_catalog_entry(storage, CODEX_IMAGE_TOOL_MODEL)
+}
+
 fn reasoning_records_from_model(
     model: &ModelInfo,
     updated_at: i64,
@@ -2029,20 +2023,22 @@ mod tests {
     use std::collections::BTreeMap;
 
     use codexmanager_core::storage::{
-        now_ts, Account, AggregateApi, ModelSourceMapping, ModelSourceModel, Storage,
+        now_ts, Account, AggregateApi, ModelCatalogModelRecord, ModelGroupModel,
+        ModelSourceMapping, ModelSourceModel, Storage,
     };
     use serde_json::{json, Value};
 
     use super::{
         auto_associate_aggregate_api_source_models, auto_associate_source_models,
         bootstrap_account_pool_model_routes, bootstrap_aggregate_api_model_routes,
-        ensure_codex_image_tool_model_in_catalog, ensure_codex_image_tool_model_listed,
-        managed_catalog_to_models_response, merge_managed_model_catalog, merge_models_response,
-        normalize_models_response, read_managed_model_catalog_from_storage,
-        read_managed_model_routing_from_storage, read_model_options_from_storage,
-        save_managed_model_catalog_with_storage, save_model_options_with_storage,
-        sync_aggregate_api_source_models, sync_aggregate_api_source_models_with_discovery,
-        MODEL_SOURCE_KIND_CUSTOM, MODEL_SOURCE_KIND_REMOTE, ROUTING_SOURCE_KIND_AGGREGATE_API,
+        delete_model_catalog_entry, managed_catalog_to_models_response,
+        merge_managed_model_catalog, merge_models_response, normalize_managed_model_catalog,
+        normalize_models_response, prune_unedited_remote_model_catalog_entries_missing_from_remote,
+        read_managed_model_catalog_from_storage, read_managed_model_routing_from_storage,
+        read_model_options_from_storage, save_managed_model_catalog_with_storage,
+        save_model_options_with_storage, sync_aggregate_api_source_models,
+        sync_aggregate_api_source_models_with_discovery, MODEL_SOURCE_KIND_CUSTOM,
+        MODEL_SOURCE_KIND_REMOTE, ROUTING_SOURCE_KIND_AGGREGATE_API,
         ROUTING_SOURCE_KIND_OPENAI_ACCOUNT,
     };
     use codexmanager_core::rpc::types::{
@@ -2123,6 +2119,45 @@ mod tests {
         save_managed_model_catalog_with_storage(storage, &payload).expect("seed platform catalog");
     }
 
+    fn model_catalog_record(slug: &str) -> ModelCatalogModelRecord {
+        ModelCatalogModelRecord {
+            scope: "default".to_string(),
+            slug: slug.to_string(),
+            display_name: slug.to_string(),
+            source_kind: MODEL_SOURCE_KIND_REMOTE.to_string(),
+            user_edited: false,
+            description: None,
+            default_reasoning_level: None,
+            shell_type: None,
+            visibility: Some("list".to_string()),
+            supported_in_api: Some(true),
+            priority: Some(0),
+            availability_nux_json: None,
+            upgrade_json: None,
+            base_instructions: None,
+            model_messages_json: None,
+            supports_reasoning_summaries: None,
+            default_reasoning_summary: None,
+            support_verbosity: None,
+            default_verbosity_json: None,
+            apply_patch_tool_type: None,
+            web_search_tool_type: None,
+            truncation_mode: None,
+            truncation_limit: None,
+            truncation_extra_json: None,
+            supports_parallel_tool_calls: None,
+            supports_image_detail_original: None,
+            context_window: None,
+            auto_compact_token_limit: None,
+            effective_context_window_percent: None,
+            minimal_client_version_json: None,
+            supports_search_tool: None,
+            extra_json: "{}".to_string(),
+            sort_index: 0,
+            updated_at: now_ts(),
+        }
+    }
+
     #[test]
     fn normalize_models_response_keeps_full_model_metadata() {
         let response = ModelsResponse {
@@ -2257,73 +2292,80 @@ mod tests {
     }
 
     #[test]
-    fn model_options_response_appends_codex_image_tool_model() {
+    fn normalize_models_response_filters_codex_image_tool_model() {
         let response = ModelsResponse {
-            models: vec![ModelInfo {
-                slug: "gpt-5.4-mini".to_string(),
-                display_name: "GPT-5.4 Mini".to_string(),
-                supported_in_api: true,
-                ..Default::default()
-            }],
+            models: vec![
+                ModelInfo {
+                    slug: "gpt-5.4-mini".to_string(),
+                    display_name: "GPT-5.4 Mini".to_string(),
+                    supported_in_api: true,
+                    ..Default::default()
+                },
+                ModelInfo {
+                    slug: "gpt-image-2".to_string(),
+                    display_name: "GPT Image 2".to_string(),
+                    supported_in_api: true,
+                    ..Default::default()
+                },
+            ],
             extra: BTreeMap::from([("etag".to_string(), json!("cached"))]),
         };
 
-        let augmented = ensure_codex_image_tool_model_listed(&response);
+        let normalized = normalize_models_response(response);
 
         assert_eq!(
-            augmented
+            normalized
                 .models
                 .iter()
                 .map(|model| model.slug.as_str())
                 .collect::<Vec<_>>(),
-            vec!["gpt-5.4-mini", "gpt-image-2"]
-        );
-        let image_model = augmented
-            .models
-            .iter()
-            .find(|model| model.slug == "gpt-image-2")
-            .expect("image tool model");
-        assert_eq!(image_model.display_name, "GPT Image 2");
-        assert_eq!(
-            image_model.input_modalities,
-            vec!["text".to_string(), "image".to_string()]
+            vec!["gpt-5.4-mini"]
         );
         assert_eq!(
-            image_model
-                .extra
-                .get("output_modalities")
-                .and_then(Value::as_array)
-                .and_then(|items| items.first())
-                .and_then(Value::as_str),
-            Some("image")
+            normalized.extra.get("etag").and_then(Value::as_str),
+            Some("cached")
         );
-        assert!(!augmented.extra.contains_key("etag"));
     }
 
     #[test]
-    fn managed_catalog_response_appends_codex_image_tool_model_once() {
+    fn normalize_managed_catalog_filters_codex_image_tool_model() {
         let catalog = ManagedModelCatalogResult {
-            items: vec![ManagedModelCatalogEntry {
-                model: ModelInfo {
-                    slug: "gpt-image-2".to_string(),
-                    display_name: "Existing Image Model".to_string(),
-                    supported_in_api: true,
-                    ..Default::default()
+            items: vec![
+                ManagedModelCatalogEntry {
+                    model: ModelInfo {
+                        slug: "gpt-5.4-mini".to_string(),
+                        display_name: "GPT-5.4 Mini".to_string(),
+                        supported_in_api: true,
+                        ..Default::default()
+                    },
+                    source_kind: MODEL_SOURCE_KIND_REMOTE.to_string(),
+                    user_edited: false,
+                    sort_index: 0,
+                    updated_at: 123,
                 },
-                source_kind: MODEL_SOURCE_KIND_CUSTOM.to_string(),
-                user_edited: true,
-                sort_index: 7,
-                updated_at: 123,
-            }],
-            extra: BTreeMap::new(),
+                ManagedModelCatalogEntry {
+                    model: ModelInfo {
+                        slug: "gpt-image-2".to_string(),
+                        display_name: "GPT Image 2".to_string(),
+                        supported_in_api: true,
+                        ..Default::default()
+                    },
+                    source_kind: MODEL_SOURCE_KIND_CUSTOM.to_string(),
+                    user_edited: true,
+                    sort_index: 1,
+                    updated_at: 123,
+                },
+            ],
+            extra: BTreeMap::from([("etag".to_string(), json!("cached"))]),
         };
 
-        let augmented = ensure_codex_image_tool_model_in_catalog(&catalog);
-        let response = managed_catalog_to_models_response(&augmented);
+        let normalized = normalize_managed_model_catalog(catalog);
+        let response = managed_catalog_to_models_response(&normalized);
 
-        assert_eq!(augmented.items.len(), 1);
+        assert_eq!(normalized.items.len(), 1);
+        assert_eq!(normalized.items[0].model.slug, "gpt-5.4-mini");
         assert_eq!(response.models.len(), 1);
-        assert_eq!(response.models[0].display_name, "Existing Image Model");
+        assert_eq!(response.models[0].slug, "gpt-5.4-mini");
     }
 
     #[test]
@@ -2348,10 +2390,12 @@ mod tests {
         save_model_options_with_storage(&storage, &payload).expect("seed structured catalog");
 
         let response = read_model_options_from_storage(&storage).expect("read models");
-        assert_eq!(response.models.len(), 2);
+        assert_eq!(response.models.len(), 1);
         assert_eq!(response.models[0].slug, "gpt-5.4");
-        assert_eq!(response.models[1].slug, "gpt-image-2");
-        assert_eq!(response.extra.get("etag").and_then(Value::as_str), None);
+        assert_eq!(
+            response.extra.get("etag").and_then(Value::as_str),
+            Some("legacy")
+        );
 
         let scope = storage
             .get_model_catalog_scope("default")
@@ -2390,6 +2434,147 @@ mod tests {
         );
     }
 
+    #[test]
+    fn managed_catalog_save_prunes_stale_default_model_group_models() {
+        let storage = Storage::open_in_memory().expect("open storage");
+        storage.init().expect("init storage");
+        let now = now_ts();
+        storage
+            .replace_model_group_models(
+                "mg_default",
+                &[ModelGroupModel {
+                    group_id: "mg_default".to_string(),
+                    platform_model_slug: "gpt-stale".to_string(),
+                    enabled: true,
+                    rate_multiplier_millis: None,
+                    billing_model_slug: None,
+                    note: Some("stale".to_string()),
+                    created_at: now,
+                    updated_at: now,
+                }],
+            )
+            .expect("seed stale default model group model");
+
+        seed_platform_catalog(&storage, &["gpt-current"]);
+
+        let slugs = storage
+            .list_model_group_models_for_group("mg_default")
+            .expect("list default model group models")
+            .into_iter()
+            .map(|model| model.platform_model_slug)
+            .collect::<Vec<_>>();
+        assert_eq!(slugs, vec!["gpt-current"]);
+    }
+
+    #[test]
+    fn managed_catalog_save_preserves_catalog_rows_absent_from_payload() {
+        let storage = Storage::open_in_memory().expect("open storage");
+        storage.init().expect("init storage");
+        seed_platform_catalog(&storage, &["gpt-old"]);
+
+        seed_platform_catalog(&storage, &["gpt-current"]);
+
+        let mut catalog_slugs = storage
+            .list_model_catalog_models("default")
+            .expect("list catalog")
+            .into_iter()
+            .map(|model| model.slug)
+            .collect::<Vec<_>>();
+        catalog_slugs.sort();
+        let mut group_slugs = storage
+            .list_model_group_models_for_group("mg_default")
+            .expect("list default model group models")
+            .into_iter()
+            .map(|model| model.platform_model_slug)
+            .collect::<Vec<_>>();
+        group_slugs.sort();
+        assert_eq!(catalog_slugs, vec!["gpt-current", "gpt-old"]);
+        assert_eq!(group_slugs, vec!["gpt-current", "gpt-old"]);
+    }
+
+    #[test]
+    fn delete_model_catalog_entry_removes_model_group_and_source_routes() {
+        let storage = Storage::open_in_memory().expect("open storage");
+        storage.init().expect("init storage");
+        seed_platform_catalog(&storage, &["gpt-delete"]);
+        storage
+            .upsert_discovered_model_source_models(
+                ROUTING_SOURCE_KIND_OPENAI_ACCOUNT,
+                "acc-delete",
+                &["gpt-delete".to_string()],
+                "synced",
+            )
+            .expect("seed source model");
+        let now = now_ts();
+        storage
+            .upsert_model_source_mapping(&ModelSourceMapping {
+                id: "mapping-delete".to_string(),
+                platform_model_slug: "gpt-delete".to_string(),
+                source_kind: ROUTING_SOURCE_KIND_OPENAI_ACCOUNT.to_string(),
+                source_id: "acc-delete".to_string(),
+                upstream_model: "gpt-delete".to_string(),
+                enabled: true,
+                priority: 0,
+                weight: 1,
+                billing_model_slug: None,
+                created_at: now,
+                updated_at: now,
+            })
+            .expect("seed mapping");
+
+        delete_model_catalog_entry(&storage, "gpt-delete").expect("delete catalog entry");
+
+        assert!(storage
+            .list_model_catalog_models("default")
+            .expect("list catalog")
+            .is_empty());
+        assert!(storage
+            .list_model_group_models_for_group("mg_default")
+            .expect("list default model group models")
+            .is_empty());
+        assert!(storage
+            .list_model_source_models(Some(ROUTING_SOURCE_KIND_OPENAI_ACCOUNT), Some("acc-delete"))
+            .expect("list source models")
+            .is_empty());
+        assert!(storage
+            .list_model_source_mappings(Some("gpt-delete"))
+            .expect("list mappings")
+            .is_empty());
+    }
+
+    #[test]
+    fn read_managed_catalog_purges_existing_codex_image_tool_rows() {
+        let storage = Storage::open_in_memory().expect("open storage");
+        storage.init().expect("init storage");
+        storage
+            .upsert_model_catalog_models(&[model_catalog_record("gpt-image-2")])
+            .expect("seed legacy image catalog row");
+
+        assert!(storage
+            .list_model_catalog_models("default")
+            .expect("list catalog before purge")
+            .iter()
+            .any(|model| model.slug == "gpt-image-2"));
+        assert!(storage
+            .list_model_group_models_for_group("mg_default")
+            .expect("list default model group models before purge")
+            .iter()
+            .any(|model| model.platform_model_slug == "gpt-image-2"));
+
+        let response =
+            read_managed_model_catalog_from_storage(&storage).expect("read managed catalog");
+
+        assert!(response.items.is_empty());
+        assert!(storage
+            .list_model_catalog_models("default")
+            .expect("list catalog after purge")
+            .is_empty());
+        assert!(storage
+            .list_model_group_models_for_group("mg_default")
+            .expect("list default model group models after purge")
+            .is_empty());
+    }
+
     #[test]
     fn managed_catalog_round_trip_preserves_source_kind_and_user_overrides() {
         let storage = Storage::open_in_memory().expect("open storage");
@@ -2468,6 +2653,143 @@ mod tests {
         assert!(merged.items[0].user_edited);
     }
 
+    #[test]
+    fn merge_managed_catalog_preserves_unedited_remote_entries_missing_from_remote() {
+        let cached = ManagedModelCatalogResult {
+            items: vec![
+                ManagedModelCatalogEntry {
+                    model: serde_json::from_value(json!({
+                        "slug": "gpt-stale",
+                        "display_name": "GPT Stale",
+                        "supported_in_api": true
+                    }))
+                    .expect("parse stale model"),
+                    source_kind: MODEL_SOURCE_KIND_REMOTE.to_string(),
+                    user_edited: false,
+                    sort_index: 0,
+                    updated_at: 10,
+                },
+                ManagedModelCatalogEntry {
+                    model: serde_json::from_value(json!({
+                        "slug": "gpt-custom",
+                        "display_name": "GPT Custom",
+                        "supported_in_api": true
+                    }))
+                    .expect("parse custom model"),
+                    source_kind: MODEL_SOURCE_KIND_CUSTOM.to_string(),
+                    user_edited: false,
+                    sort_index: 1,
+                    updated_at: 11,
+                },
+            ],
+            extra: BTreeMap::new(),
+        };
+        let incoming = ModelsResponse {
+            models: vec![serde_json::from_value(json!({
+                "slug": "gpt-current",
+                "display_name": "GPT Current",
+                "supported_in_api": true
+            }))
+            .expect("parse incoming model")],
+            extra: BTreeMap::new(),
+        };
+
+        let merged = merge_managed_model_catalog(cached, incoming);
+
+        assert_eq!(
+            merged
+                .items
+                .iter()
+                .map(|item| item.model.slug.as_str())
+                .collect::<Vec<_>>(),
+            vec!["gpt-current", "gpt-stale", "gpt-custom"]
+        );
+    }
+
+    #[test]
+    fn prune_stale_remote_models_only_deletes_unedited_remote_entries() {
+        let storage = Storage::open_in_memory().expect("open storage");
+        storage.init().expect("init storage");
+        let payload = ManagedModelCatalogResult {
+            items: vec![
+                ManagedModelCatalogEntry {
+                    model: serde_json::from_value(json!({
+                        "slug": "gpt-current",
+                        "display_name": "GPT Current",
+                        "supported_in_api": true
+                    }))
+                    .expect("parse current model"),
+                    source_kind: MODEL_SOURCE_KIND_REMOTE.to_string(),
+                    user_edited: false,
+                    sort_index: 0,
+                    updated_at: 10,
+                },
+                ManagedModelCatalogEntry {
+                    model: serde_json::from_value(json!({
+                        "slug": "gpt-stale-remote",
+                        "display_name": "GPT Stale Remote",
+                        "supported_in_api": true
+                    }))
+                    .expect("parse stale remote model"),
+                    source_kind: MODEL_SOURCE_KIND_REMOTE.to_string(),
+                    user_edited: false,
+                    sort_index: 1,
+                    updated_at: 11,
+                },
+                ManagedModelCatalogEntry {
+                    model: serde_json::from_value(json!({
+                        "slug": "gpt-stale-edited",
+                        "display_name": "GPT Stale Edited",
+                        "supported_in_api": true
+                    }))
+                    .expect("parse stale edited model"),
+                    source_kind: MODEL_SOURCE_KIND_REMOTE.to_string(),
+                    user_edited: true,
+                    sort_index: 2,
+                    updated_at: 12,
+                },
+                ManagedModelCatalogEntry {
+                    model: serde_json::from_value(json!({
+                        "slug": "gpt-custom",
+                        "display_name": "GPT Custom",
+                        "supported_in_api": true
+                    }))
+                    .expect("parse custom model"),
+                    source_kind: MODEL_SOURCE_KIND_CUSTOM.to_string(),
+                    user_edited: false,
+                    sort_index: 3,
+                    updated_at: 13,
+                },
+            ],
+            extra: BTreeMap::new(),
+        };
+        save_managed_model_catalog_with_storage(&storage, &payload)
+            .expect("seed managed model catalog");
+
+        let remote = ModelsResponse {
+            models: vec![serde_json::from_value(json!({
+                "slug": "gpt-current",
+                "display_name": "GPT Current",
+                "supported_in_api": true
+            }))
+            .expect("parse remote model")],
+            extra: BTreeMap::new(),
+        };
+        prune_unedited_remote_model_catalog_entries_missing_from_remote(&storage, &remote)
+            .expect("prune stale remote models");
+
+        let catalog =
+            read_managed_model_catalog_from_storage(&storage).expect("read managed catalog");
+        assert_eq!(
+            catalog
+                .items
+                .iter()
+                .map(|item| item.model.slug.as_str())
+                .collect::<Vec<_>>(),
+            vec!["gpt-current", "gpt-stale-edited", "gpt-custom"]
+        );
+    }
+
     #[test]
     fn account_pool_bootstrap_links_catalog_models_on_first_load() {
         let storage = Storage::open_in_memory().expect("open storage");
diff --git a/crates/service/src/gateway/request/local_models.rs b/crates/service/src/gateway/request/local_models.rs
index b3e0d8a02..0bb259cb5 100644
--- a/crates/service/src/gateway/request/local_models.rs
+++ b/crates/service/src/gateway/request/local_models.rs
@@ -42,8 +42,7 @@ fn serialize_models_response_body(models: &ModelsResponse) -> String {
 }
 
 fn serialize_models_response(models: &ModelsResponse) -> String {
-    let models = crate::apikey_models::ensure_codex_image_tool_model_listed(models);
-    serialize_models_response_body(&models)
+    serialize_models_response_body(models)
 }
 
 fn filter_models_for_key(
@@ -192,11 +191,6 @@ pub(super) fn maybe_respond_local_models(
     } else {
         serialize_models_response_body(&output_models)
     };
-    let output_models = if include_implicit_models {
-        crate::apikey_models::ensure_codex_image_tool_model_listed(&output_models)
-    } else {
-        output_models
-    };
     let extra_headers = models_etag_header(&output_models)?.into_iter().collect();
     super::local_response::respond_local_json_with_headers(
         request,
diff --git a/crates/service/src/gateway/request/tests/local_models_tests.rs b/crates/service/src/gateway/request/tests/local_models_tests.rs
index 3d3ef5c3f..4307ecb0f 100644
--- a/crates/service/src/gateway/request/tests/local_models_tests.rs
+++ b/crates/service/src/gateway/request/tests/local_models_tests.rs
@@ -45,7 +45,7 @@ fn serialize_models_response_outputs_codex_and_api_shapes() {
         .get("data")
         .and_then(Value::as_array)
         .expect("OpenAI-compatible data array");
-    assert_eq!(data.len(), 3);
+    assert_eq!(data.len(), 2);
     assert_eq!(
         data[0].get("id").and_then(Value::as_str),
         Some("gpt-5.3-codex")
@@ -56,15 +56,11 @@ fn serialize_models_response_outputs_codex_and_api_shapes() {
         Some("codexmanager")
     );
     assert_eq!(data[1].get("id").and_then(Value::as_str), Some("gpt-4o"));
-    assert_eq!(
-        data[2].get("id").and_then(Value::as_str),
-        Some("gpt-image-2")
-    );
     let models = value
         .get("models")
         .and_then(Value::as_array)
         .expect("models array");
-    assert_eq!(models.len(), 3);
+    assert_eq!(models.len(), 2);
     assert_eq!(
         models[0].get("slug").and_then(Value::as_str),
         Some("gpt-5.3-codex")
@@ -81,10 +77,6 @@ fn serialize_models_response_outputs_codex_and_api_shapes() {
         models[1].get("visibility").and_then(Value::as_str),
         Some("list")
     );
-    assert_eq!(
-        models[2].get("slug").and_then(Value::as_str),
-        Some("gpt-image-2")
-    );
     assert_eq!(value.as_object().map(|object| object.len()), Some(3));
     assert!(value.get("etag").is_none());
 }
@@ -113,7 +105,7 @@ fn serialize_models_response_preserves_description_for_codex_clients() {
         .get("data")
         .and_then(Value::as_array)
         .expect("OpenAI-compatible data array");
-    assert_eq!(models.len(), 2);
+    assert_eq!(models.len(), 1);
     assert_eq!(
         models[0].get("description").and_then(Value::as_str),
         Some("Latest frontier agentic coding model.")
@@ -125,11 +117,11 @@ fn serialize_models_response_preserves_description_for_codex_clients() {
 }
 
 #[test]
-fn serialize_models_response_appends_codex_image_tool_model_once() {
+fn serialize_models_response_does_not_invent_codex_image_tool_model() {
     let items = ModelsResponse {
         models: vec![ModelInfo {
-            slug: "gpt-image-2".to_string(),
-            display_name: "GPT Image 2".to_string(),
+            slug: "gpt-5.4-mini".to_string(),
+            display_name: "GPT-5.4 Mini".to_string(),
             supported_in_api: true,
             visibility: Some("list".to_string()),
             ..Default::default()
@@ -147,7 +139,7 @@ fn serialize_models_response_appends_codex_image_tool_model_once() {
     assert_eq!(models.len(), 1);
     assert_eq!(
         models[0].get("slug").and_then(Value::as_str),
-        Some("gpt-image-2")
+        Some("gpt-5.4-mini")
     );
 }
 
@@ -185,7 +177,6 @@ fn serialize_models_response_filters_api_data_to_supported_models() {
         .collect::<Vec<_>>();
 
     assert!(ids.contains(&"gpt-supported"));
-    assert!(ids.contains(&"gpt-image-2"));
     assert!(!ids.contains(&"gpt-hidden"));
 }
 
diff --git a/crates/service/src/model_groups.rs b/crates/service/src/model_groups.rs
index f479850b2..4ad0d4b44 100644
--- a/crates/service/src/model_groups.rs
+++ b/crates/service/src/model_groups.rs
@@ -85,6 +85,7 @@ fn user_group_entry(assignment: UserModelGroup) -> UserModelGroupEntry {
 }
 
 fn result_from_storage(storage: &Storage) -> Result<ModelGroupListResult, String> {
+    crate::apikey_models::read_managed_model_catalog_from_storage(storage)?;
     storage
         .bootstrap_default_model_group()
         .map_err(|err| format!("bootstrap default model group failed: {err}"))?;
@@ -330,6 +331,9 @@ pub(crate) fn allowed_model_slugs_for_api_key(
     if user.role == "admin" {
         return Ok(None);
     }
+    storage
+        .prune_default_model_group_models_not_in_catalog()
+        .map_err(|err| format!("prune default model group failed: {err}"))?;
     let slugs = storage
         .allowed_model_slugs_for_user(user_id, now_ts())
         .map_err(|err| format!("read allowed model groups failed: {err}"))?
diff --git a/crates/service/src/rpc_dispatch/apikey.rs b/crates/service/src/rpc_dispatch/apikey.rs
index 6b126be19..d82fa5f8b 100644
--- a/crates/service/src/rpc_dispatch/apikey.rs
+++ b/crates/service/src/rpc_dispatch/apikey.rs
@@ -191,6 +191,10 @@ pub(super) fn try_handle(req: &JsonRpcRequest, actor: &RpcActor) -> Option<JsonR
             let slug = super::str_param(req, "slug").unwrap_or("");
             super::ok_or_error(apikey_models::delete_managed_model_catalog_model(slug))
         }
+        "apikey/modelCatalogPruneStaleRemote" => super::value_or_error(
+            apikey_models::prune_stale_remote_managed_model_catalog()
+                .and_then(|catalog| filter_catalog_for_actor(actor, catalog)),
+        ),
         "apikey/modelRouting" => {
             if actor.is_admin() {
                 super::value_or_error(apikey_models::read_managed_model_routing())
diff --git a/crates/service/src/rpc_dispatch/mod.rs b/crates/service/src/rpc_dispatch/mod.rs
index fe3eaf055..4e7c3d030 100644
--- a/crates/service/src/rpc_dispatch/mod.rs
+++ b/crates/service/src/rpc_dispatch/mod.rs
@@ -201,6 +201,7 @@ const MEMBER_METHOD_ALLOWLIST: &[&str] = &[
     "apikey/enable",
     "apikey/list",
     "apikey/modelCatalogList",
+    "apikey/modelCatalogPruneStaleRemote",
     "apikey/modelRouting",
     "apikey/models",
     "apikey/readSecret",