theclawbay 0.3.67 → 0.3.69

package/dist/commands/logout.js

@@ -1548,10 +1548,10 @@ class LogoutCommand extends base_command_1.BaseCommand {
                 this.log("- Codex login state: no cleanup needed.");
             }
             if (modelCacheCleanup.action === "removed") {
-                this.log("- Codex model cache: removed the Claw Bay GPT-5.4 / GPT-5.4 Mini seed.");
+                this.log("- Codex model cache: removed the Claw Bay managed model catalog.");
             }
             else if (modelCacheCleanup.action === "preserved") {
-                this.log("- Codex model cache: preserved an existing GPT-5.4 / GPT-5.4 Mini entry.");
+                this.log("- Codex model cache: preserved an existing model catalog entry.");
             }
             else if (modelCacheCleanup.warning) {
                 this.log(`- Codex model cache: ${modelCacheCleanup.warning}`);

package/dist/commands/setup.js

@@ -28,7 +28,9 @@ const DEFAULT_PROVIDER_ID = "theclawbay";
 const CLI_HTTP_USER_AGENT = "theclawbay-cli";
 const SUPPORTED_MODEL_IDS = (0, supported_models_1.getSupportedModelIds)();
 const MODEL_DISPLAY_NAMES = (0, supported_models_1.getSupportedModelDisplayNames)();
-const DEFAULT_CODEX_MODEL = SUPPORTED_MODEL_IDS.includes("gpt-5.4") ? "gpt-5.4" : (SUPPORTED_MODEL_IDS[0] ?? "gpt-5.4");
+const DEFAULT_CODEX_MODEL = (["gpt-5.5", "gpt-5.4"].find((modelId) => SUPPORTED_MODEL_IDS.includes(modelId)) ??
+    SUPPORTED_MODEL_IDS[0] ??
+    "gpt-5.4");
 const DEFAULT_CONTINUE_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_CLINE_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_OPENCLAW_MODEL = DEFAULT_CODEX_MODEL;
@@ -3245,6 +3247,9 @@ class SetupCommand extends base_command_1.BaseCommand {
             if (desktopModelPickerMigration?.action === "patched") {
                 summaryNotes.add("Desktop model pickers were refreshed so current VS Code and Codex app builds stop labeling supported The Claw Bay models like GPT-5.5 as Custom.");
             }
+            if (selectedSetupClients.has("codex")) {
+                summaryNotes.add("If Codex updates later, rerun `theclawbay setup` once to refresh its local model catalog.");
+            }
             if (selectedSetupClients.has("codex") && !migrateCodexConversations) {
                 summaryNotes.add("Left existing Codex conversations untouched.");
             }

package/dist/lib/codex-desktop-model-picker.js

@@ -9,8 +9,8 @@ const promises_1 = __importDefault(require("node:fs/promises"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const paths_1 = require("./config/paths");
-const supported_models_1 = require("./supported-models");
-const DESKTOP_MODEL_IDS = Array.from(new Set((0, supported_models_1.getSupportedModelIds)()));
+const codex_model_catalog_1 = require("./codex-model-catalog");
+const DESKTOP_MODEL_IDS = Array.from(new Set((0, codex_model_catalog_1.getVisibleHardcodedCodexModelIds)()));
 const STATSIG_MODEL_PICKER_CONFIG_ID = "107580212";
 function uniqueStrings(values) {
     return Array.from(new Set(values.filter((value) => Boolean(value))));
@@ -40,6 +40,16 @@ function readWindowsCommandStdout(command) {
     const output = result.stdout.replace(/\r/g, "").trim();
     return output || null;
 }
+function desktopClientsLikelyRunning() {
+    if (node_os_1.default.platform() === "win32" || isWslInteropRuntime()) {
+        const running = readWindowsCommandStdout("Get-Process Code,Codex -ErrorAction SilentlyContinue | Select-Object -ExpandProperty ProcessName");
+        return Boolean(running);
+    }
+    const result = (0, node_child_process_1.spawnSync)("sh", ["-lc", "pgrep -if '(^|/)(code|codex)$' >/dev/null"], {
+        stdio: "ignore",
+    });
+    return result.status === 0;
+}
 function resolveWindowsPathForHost(input) {
     if (!input)
         return null;
@@ -333,31 +343,18 @@ function buildStatsigPatchScript() {
         "    finally:",
         "        db.close()",
         "    print(json.dumps(result))",
-    ].join("\\n");
+    ].join("\n");
 }
-async function patchDesktopStatsigCaches() {
-    const dbDirs = await desktopStatsigLevelDbCandidates();
-    if (dbDirs.length === 0)
-        return { patched: 0, warnings: [] };
-    const python = await ensureLocalPythonWithLevelDbSupport();
-    if (!python) {
-        return {
-            patched: 0,
-            warnings: [
-                "Could not install the local desktop model-picker helper, so Codex app model labels may stay stale until the next supported cache refresh.",
-            ],
-        };
-    }
-    const run = (0, node_child_process_1.spawnSync)(python.command, [...python.args, "-c", buildStatsigPatchScript(), JSON.stringify(DESKTOP_MODEL_IDS), ...dbDirs], {
+function patchStatsigCache(python, dbDir) {
+    const run = (0, node_child_process_1.spawnSync)(python.command, [...python.args, "-c", buildStatsigPatchScript(), JSON.stringify(DESKTOP_MODEL_IDS), dbDir], {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "pipe"],
     });
     if (run.status !== 0) {
+        const detail = (run.stderr || run.stdout || "").trim();
         return {
             patched: 0,
-            warnings: [
-                "Could not refresh the desktop model-picker cache. Close Codex app / VS Code and rerun setup if the picker still shows Custom.",
-            ],
+            warning: detail ? `${dbDir}: ${detail}` : `${dbDir}: desktop cache helper exited with status ${run.status}`,
         };
     }
     let patched = 0;
@@ -368,7 +365,7 @@ async function patchDesktopStatsigCaches() {
             const parsed = JSON.parse(line);
             patched += typeof parsed.patched === "number" ? parsed.patched : 0;
             if (typeof parsed.error === "string" && parsed.error.trim()) {
-                const dbLabel = typeof parsed.db === "string" ? parsed.db : "desktop cache";
+                const dbLabel = typeof parsed.db === "string" ? parsed.db : dbDir;
                 warnings.push(`${dbLabel}: ${parsed.error.trim()}`);
             }
         }
@@ -376,7 +373,45 @@ async function patchDesktopStatsigCaches() {
             continue;
         }
     }
-    return { patched, warnings };
+    return { patched, warning: warnings.length > 0 ? warnings.join(" ") : undefined };
+}
+async function patchDesktopStatsigCaches() {
+    const dbDirs = await desktopStatsigLevelDbCandidates();
+    if (dbDirs.length === 0)
+        return { patched: 0, warnings: [] };
+    const python = await ensureLocalPythonWithLevelDbSupport();
+    if (!python) {
+        return {
+            patched: 0,
+            warnings: [
+                "Could not install the local desktop model-picker helper, so Codex app model labels may stay stale until the next supported cache refresh.",
+            ],
+        };
+    }
+    let patched = 0;
+    const warnings = [];
+    for (const dbDir of dbDirs) {
+        const result = patchStatsigCache(python, dbDir);
+        patched += result.patched;
+        if (result.warning)
+            warnings.push(result.warning);
+    }
+    if (patched === 0 && warnings.length > 0) {
+        const prefix = desktopClientsLikelyRunning()
+            ? "Could not refresh the desktop model-picker cache because VS Code or Codex app is still running."
+            : "Could not refresh the desktop model-picker cache.";
+        return {
+            patched,
+            warnings: [`${prefix} ${warnings.join(" ")}`],
+        };
+    }
+    if (patched > 0 && warnings.length > 0) {
+        const filteredWarnings = warnings.filter((warning) => !/does not exist|No such file/i.test(warning));
+        if (filteredWarnings.length > 0) {
+            return { patched, warnings: filteredWarnings };
+        }
+    }
+    return { patched, warnings: [] };
 }
 async function ensureCodexDesktopModelPickerSupport() {
     try {

package/dist/lib/codex-model-cache-migration.js

@@ -10,36 +10,22 @@ const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const node_os_1 = __importDefault(require("node:os"));
+const codex_model_catalog_1 = require("./codex-model-catalog");
 const supported_models_1 = require("./supported-models");
 const MODELS_CACHE_FILE = "models_cache.json";
 const MODELS_CACHE_STATE_FILE = "theclawbay.models-cache.json";
 const STATE_DB_FILE_PATTERN = /^state_\d+\.sqlite$/;
-const TARGET_MODEL_IDS = (0, supported_models_1.getSupportedModelIds)();
+const CATALOG_MODELS = (0, codex_model_catalog_1.getHardcodedCodexModelCatalog)();
+const CATALOG_MODEL_IDS = (0, codex_model_catalog_1.getHardcodedCodexModelIds)();
 const LEGACY_REMOVED_MODEL_IDS = (0, supported_models_1.getLegacyRemovedModelIds)();
-const TARGET_MODEL_ID_SET = new Set(TARGET_MODEL_IDS);
-const TRACKED_MODEL_ID_SET = new Set([...TARGET_MODEL_IDS, ...LEGACY_REMOVED_MODEL_IDS]);
+const CATALOG_MODEL_ID_SET = new Set(CATALOG_MODEL_IDS);
+const TRACKED_MODEL_ID_SET = new Set([...CATALOG_MODEL_IDS, ...LEGACY_REMOVED_MODEL_IDS]);
 const LEGACY_REMOVED_MODEL_ID_SET = new Set(LEGACY_REMOVED_MODEL_IDS);
 const SEED_MARKER_KEY = "_theclawbay_seeded";
 // Older releases stored the model id as the marker value; accept those so cleanup still works.
 const SEED_MARKER_VALUE = "theclawbay";
 const LEGACY_SEED_MARKER_VALUES = new Set([...TRACKED_MODEL_ID_SET, SEED_MARKER_VALUE, true]);
-const SUPPORTED_MODELS = (0, supported_models_1.getSupportedModels)();
-const SUPPORTED_MODEL_CONFIG = new Map(SUPPORTED_MODELS.map((model) => [model.id, model]));
-const TEMPLATE_MODEL_IDS = TARGET_MODEL_IDS;
-const DEFAULT_REASONING_LEVELS = [
-    { effort: "low", description: "Fast responses with lighter reasoning" },
-    { effort: "medium", description: "Balances speed and reasoning depth for everyday tasks" },
-    { effort: "high", description: "Greater reasoning depth for complex problems" },
-    { effort: "xhigh", description: "Extra high reasoning depth for complex problems" },
-];
-const FALLBACK_BASE_INSTRUCTIONS = `You are Codex, a coding agent based on GPT-5. You and the user share the same workspace and collaborate to achieve the user's goals.
-
-## General
-
-- Prefer rg or rg --files for search when available.
-- Make safe, minimal code changes that preserve user work.
-- Explain what changed and any remaining risk clearly.`;
-const SEEDED_CACHE_FRESHNESS_YEARS = 10;
+const SEEDED_CACHE_FRESHNESS_ISO = "2099-12-31T23:59:59.000Z";
 function objectRecordOr(value) {
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
         return value;
@@ -148,7 +134,7 @@ async function readPatchState(statePath) {
 }
 async function writePatchState(statePath, fingerprints) {
     await promises_1.default.mkdir(node_path_1.default.dirname(statePath), { recursive: true });
-    const models = TARGET_MODEL_IDS.flatMap((modelId) => {
+    const models = CATALOG_MODEL_IDS.flatMap((modelId) => {
         const fingerprint = fingerprints[modelId];
         if (!fingerprint)
             return [];
@@ -166,93 +152,43 @@ function findModel(models, slug) {
 function hasSeedMarker(model) {
     return LEGACY_SEED_MARKER_VALUES.has(model[SEED_MARKER_KEY]);
 }
-function applySeedMarker(model) {
+function stripSeedMarker(model) {
+    if (!(SEED_MARKER_KEY in model))
+        return cloneJson(model);
     const next = cloneJson(model);
-    next[SEED_MARKER_KEY] = SEED_MARKER_VALUE;
+    delete next[SEED_MARKER_KEY];
     return next;
 }
-function seedDescription(modelId) {
-    return SUPPORTED_MODEL_CONFIG.get(modelId)?.note ?? "The Claw Bay model.";
+function buildCatalogModels() {
+    return cloneJson(CATALOG_MODELS).map((model) => stripSeedMarker(model));
 }
-function normalizeSeedModel(template, modelId) {
-    const modelConfig = SUPPORTED_MODEL_CONFIG.get(modelId);
-    const seed = applySeedMarker(template ?? {});
-    seed.slug = modelId;
-    seed.display_name = modelConfig?.label ?? modelId;
-    seed.description = seedDescription(modelId);
-    if (typeof seed.default_reasoning_level !== "string") {
-        seed.default_reasoning_level = "medium";
-    }
-    if (!Array.isArray(seed.supported_reasoning_levels) || seed.supported_reasoning_levels.length === 0) {
-        seed.supported_reasoning_levels = cloneJson(DEFAULT_REASONING_LEVELS);
-    }
-    if (typeof seed.shell_type !== "string") {
-        seed.shell_type = "shell_command";
-    }
-    seed.visibility = "list";
-    seed.supported_in_api = true;
-    seed.priority = 0;
-    seed.upgrade = null;
-    if (typeof seed.base_instructions !== "string" || !seed.base_instructions.trim()) {
-        seed.base_instructions = FALLBACK_BASE_INSTRUCTIONS;
-    }
-    if (typeof seed.supports_reasoning_summaries !== "boolean") {
-        seed.supports_reasoning_summaries = true;
-    }
-    if (typeof seed.support_verbosity !== "boolean") {
-        seed.support_verbosity = true;
-    }
-    if (seed.default_verbosity === undefined) {
-        seed.default_verbosity = "low";
-    }
-    if (seed.apply_patch_tool_type === undefined) {
-        seed.apply_patch_tool_type = "freeform";
-    }
-    const truncationPolicy = objectRecordOr(seed.truncation_policy);
-    if (!truncationPolicy || typeof truncationPolicy.mode !== "string" || typeof truncationPolicy.limit !== "number") {
-        seed.truncation_policy = { mode: "tokens", limit: 10000 };
-    }
-    if (typeof seed.supports_parallel_tool_calls !== "boolean") {
-        seed.supports_parallel_tool_calls = true;
-    }
-    if (typeof seed.context_window !== "number") {
-        seed.context_window = 272000;
-    }
-    if (typeof seed.effective_context_window_percent !== "number") {
-        seed.effective_context_window_percent = 95;
-    }
-    if (!Array.isArray(seed.experimental_supported_tools)) {
-        seed.experimental_supported_tools = [];
-    }
-    if (!Array.isArray(seed.input_modalities) || seed.input_modalities.length === 0) {
-        seed.input_modalities = ["text", "image"];
-    }
-    if (typeof seed.prefer_websockets !== "boolean") {
-        seed.prefer_websockets = true;
-    }
-    return seed;
+function buildCatalogModelMap() {
+    return new Map(buildCatalogModels().flatMap((model) => {
+        const slug = typeof model.slug === "string" ? model.slug : "";
+        return slug ? [[slug, model]] : [];
+    }));
 }
-function buildSeedModel(models, modelId) {
-    for (const candidate of TEMPLATE_MODEL_IDS) {
-        const template = findModel(models, candidate);
-        if (template)
-            return normalizeSeedModel(template, modelId);
-    }
-    return normalizeSeedModel(null, modelId);
+function sameFingerprintMaps(left, right) {
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    return leftKeys.every((key, index) => key === rightKeys[index] && left[key] === right[key]);
 }
-function hasSeededTheClawBayModel(models) {
-    return models.some((model) => hasSeedMarker(model));
+function hasCatalogModels(models) {
+    return models.some((model) => {
+        const slug = typeof model.slug === "string" ? model.slug : "";
+        return Boolean(slug) && CATALOG_MODEL_ID_SET.has(slug);
+    });
 }
 function nextFetchedAtIsoForDocument(doc) {
-    if (!hasSeededTheClawBayModel(doc.models)) {
+    if (!hasCatalogModels(doc.models)) {
         return new Date().toISOString();
     }
-    // Current desktop Codex builds only consult models_cache.json for custom-provider
-    // catalogs in API-key mode, then silently fall back to compiled OpenAI models once
-    // the five-minute TTL expires. Keep the seeded cache durable until setup refreshes it.
-    const next = new Date();
-    next.setUTCFullYear(next.getUTCFullYear() + SEEDED_CACHE_FRESHNESS_YEARS);
-    return next.toISOString();
+    // Current Codex builds only consult models_cache.json for custom-provider
+    // catalogs in API-key mode. Pin the cache freshness far into the future so
+    // setup can refresh the catalog on demand without the five-minute TTL.
+    return SEEDED_CACHE_FRESHNESS_ISO;
 }
 function setCacheFreshnessMetadata(doc, clientVersion) {
     let changed = false;
@@ -562,22 +498,22 @@ async function ensureCodexModelCacheHasGpt54(params) {
     try {
         const existingState = await readPatchState(statePath);
         const parsed = await readJsonIfExists(cachePath);
+        const catalogModels = buildCatalogModels();
+        const catalogModelMap = buildCatalogModelMap();
         if (parsed === null) {
             const clientVersion = await inferCodexClientVersion(params.codexHome);
             if (!clientVersion) {
                 await removeFileIfExists(statePath);
                 return {
                     action: "skipped",
-                    warning: "Codex models cache was not found, and Codex version could not be inferred for a safe The Claw Bay model seed.",
+                    warning: "Codex models cache was not found, and Codex version could not be inferred for a safe The Claw Bay model catalog refresh.",
                 };
             }
-            const docModels = [];
-            const nextState = {};
-            for (const modelId of TARGET_MODEL_IDS) {
-                const seed = buildSeedModel(docModels, modelId);
-                docModels.push(seed);
-                nextState[modelId] = fingerprintModel(seed);
-            }
+            const docModels = cloneJson(catalogModels);
+            const nextState = Object.fromEntries(docModels.flatMap((model) => {
+                const slug = typeof model.slug === "string" ? model.slug : "";
+                return slug ? [[slug, fingerprintModel(model)]] : [];
+            }));
             const doc = {
                 fetched_at: nextFetchedAtIsoForDocument({ models: docModels }),
                 client_version: clientVersion,
@@ -592,105 +528,92 @@ async function ensureCodexModelCacheHasGpt54(params) {
         if (!doc) {
             return {
                 action: "skipped",
-                warning: "Codex models cache exists but is not valid JSON in the expected format; skipped The Claw Bay model seed.",
+                warning: "Codex models cache exists but is not valid JSON in the expected format; skipped The Claw Bay model catalog refresh.",
             };
         }
         const clientVersion = (await inferCodexClientVersion(params.codexHome)) ??
             (typeof doc.client_version === "string" && doc.client_version ? doc.client_version : null);
         let changed = false;
         let seeded = false;
-        let stateChanged = false;
-        const nextState = { ...existingState };
-        const legacyRemovedBefore = doc.models.length;
-        doc.models = doc.models.filter((entry) => {
+        const currentCatalogEntries = new Map();
+        const rest = [];
+        for (const entry of doc.models) {
             const slug = typeof entry.slug === "string" ? entry.slug : "";
-            if (!slug || !LEGACY_REMOVED_MODEL_ID_SET.has(slug))
-                return true;
-            if (!hasSeedMarker(entry))
-                return true;
-            delete nextState[slug];
-            stateChanged = true;
-            return false;
-        });
-        if (doc.models.length !== legacyRemovedBefore) {
-            changed = true;
-        }
-        for (const modelId of TARGET_MODEL_IDS) {
-            const existingModel = findModel(doc.models, modelId);
-            const trackedFingerprint = existingState[modelId];
-            if (existingModel) {
-                const currentFingerprint = fingerprintModel(existingModel);
-                if (hasSeedMarker(existingModel)) {
-                    if (!trackedFingerprint || trackedFingerprint !== currentFingerprint) {
-                        nextState[modelId] = currentFingerprint;
-                        stateChanged = true;
-                    }
-                    continue;
+            if (!slug) {
+                rest.push(entry);
+                continue;
+            }
+            if (LEGACY_REMOVED_MODEL_ID_SET.has(slug) && hasSeedMarker(entry)) {
+                changed = true;
+                continue;
+            }
+            if (CATALOG_MODEL_ID_SET.has(slug)) {
+                if (!currentCatalogEntries.has(slug)) {
+                    currentCatalogEntries.set(slug, entry);
                 }
-                if (trackedFingerprint && trackedFingerprint === currentFingerprint) {
-                    const seededModel = applySeedMarker(existingModel);
-                    doc.models = doc.models.map((entry) => (entry.slug === modelId ? seededModel : entry));
-                    nextState[modelId] = fingerprintModel(seededModel);
-                    seeded = true;
+                else {
                     changed = true;
-                    stateChanged = true;
-                    continue;
-                }
-                if (trackedFingerprint && trackedFingerprint !== currentFingerprint) {
-                    delete nextState[modelId];
-                    stateChanged = true;
                 }
                 continue;
             }
-            const seed = buildSeedModel(doc.models, modelId);
-            doc.models = [seed, ...doc.models];
-            nextState[modelId] = fingerprintModel(seed);
-            seeded = true;
-            changed = true;
-            stateChanged = true;
+            const normalized = stripSeedMarker(entry);
+            if (fingerprintModel(normalized) !== fingerprintModel(entry)) {
+                changed = true;
+            }
+            rest.push(normalized);
         }
-        // Keep The Claw Bay seeds grouped at the top for easy discovery in the picker.
-        const bySlug = new Map();
-        const rest = [];
-        for (const entry of doc.models) {
-            const slug = typeof entry.slug === "string" ? entry.slug : "";
-            if (slug && TARGET_MODEL_ID_SET.has(slug) && !bySlug.has(slug)) {
-                bySlug.set(slug, entry);
+        const orderedCatalog = [];
+        const nextState = {};
+        for (const modelId of CATALOG_MODEL_IDS) {
+            const desiredModel = catalogModelMap.get(modelId);
+            if (!desiredModel)
+                continue;
+            const desiredFingerprint = fingerprintModel(desiredModel);
+            const trackedFingerprint = existingState[modelId];
+            const existingModel = currentCatalogEntries.get(modelId);
+            if (!existingModel) {
+                orderedCatalog.push(cloneJson(desiredModel));
+                nextState[modelId] = desiredFingerprint;
+                changed = true;
+                seeded = true;
                 continue;
             }
-            rest.push(entry);
-        }
-        const orderedTargets = [];
-        for (const id of TARGET_MODEL_IDS) {
-            const entry = bySlug.get(id);
-            if (entry)
-                orderedTargets.push(entry);
+            const normalizedExisting = stripSeedMarker(existingModel);
+            const existingFingerprint = fingerprintModel(normalizedExisting);
+            if (existingFingerprint === desiredFingerprint && !hasSeedMarker(existingModel)) {
+                orderedCatalog.push(normalizedExisting);
+                if (trackedFingerprint === desiredFingerprint) {
+                    nextState[modelId] = trackedFingerprint;
+                }
+                continue;
+            }
+            orderedCatalog.push(cloneJson(desiredModel));
+            nextState[modelId] = desiredFingerprint;
+            changed = true;
+            seeded = true;
         }
-        doc.models = [...orderedTargets, ...rest];
+        doc.models = [...orderedCatalog, ...rest];
         if (setCacheFreshnessMetadata(doc, clientVersion)) {
             changed = true;
         }
+        const stateChanged = !sameFingerprintMaps(existingState, nextState);
         if (changed) {
             await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
         }
-        const hasAnyTracked = TARGET_MODEL_IDS.some((id) => Boolean(nextState[id]));
+        const hasAnyTracked = CATALOG_MODEL_IDS.some((id) => Boolean(nextState[id]));
         if (!hasAnyTracked) {
             if (Object.keys(existingState).length > 0) {
                 await removeFileIfExists(statePath);
             }
         }
-        else if (stateChanged || seeded) {
+        else if (stateChanged) {
             await writePatchState(statePath, nextState);
         }
         if (seeded)
             return { action: "seeded" };
         if (changed || stateChanged)
             return { action: "refreshed" };
-        const allSeeded = TARGET_MODEL_IDS.every((id) => {
-            const model = findModel(doc.models, id);
-            return Boolean(model && hasSeedMarker(model));
-        });
-        return { action: allSeeded ? "already_seeded" : "already_present" };
+        return { action: hasAnyTracked ? "already_seeded" : "already_present" };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -724,9 +647,17 @@ async function cleanupSeededCodexModelCache(params) {
         let preserved = 0;
         doc.models = doc.models.filter((entry) => {
             const slug = typeof entry.slug === "string" ? entry.slug : "";
-            if (!slug || !TRACKED_MODEL_ID_SET.has(slug))
+            if (!slug)
+                return true;
+            if (LEGACY_REMOVED_MODEL_ID_SET.has(slug) && hasSeedMarker(entry)) {
+                removed += 1;
+                return false;
+            }
+            const trackedFingerprint = state[slug];
+            if (!trackedFingerprint)
                 return true;
-            if (!hasSeedMarker(entry)) {
+            const normalized = stripSeedMarker(entry);
+            if (fingerprintModel(normalized) !== trackedFingerprint) {
                 preserved += 1;
                 return true;
             }

package/dist/lib/codex-model-catalog.d.ts

@@ -0,0 +1,5 @@
+type JsonObject = Record<string, unknown>;
+export declare function getHardcodedCodexModelCatalog(): JsonObject[];
+export declare function getHardcodedCodexModelIds(): string[];
+export declare function getVisibleHardcodedCodexModelIds(): string[];
+export {};

package/dist/lib/codex-model-catalog.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHardcodedCodexModelCatalog = getHardcodedCodexModelCatalog;
+exports.getHardcodedCodexModelIds = getHardcodedCodexModelIds;
+exports.getVisibleHardcodedCodexModelIds = getVisibleHardcodedCodexModelIds;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+function configPath() {
+    return node_path_1.default.resolve(__dirname, "..", "..", "theclawbay-codex-model-catalog.json");
+}
+function parseCodexModelCatalog(raw) {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+        throw new Error("codex model catalog must be an array");
+    }
+    return parsed.map((entry) => {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+            throw new Error("codex model catalog contains an invalid entry");
+        }
+        return entry;
+    });
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+let cachedCatalog = null;
+function getHardcodedCodexModelCatalog() {
+    if (!cachedCatalog) {
+        cachedCatalog = parseCodexModelCatalog((0, node_fs_1.readFileSync)(configPath(), "utf8"));
+    }
+    return cloneJson(cachedCatalog);
+}
+function getHardcodedCodexModelIds() {
+    return getHardcodedCodexModelCatalog()
+        .map((model) => (typeof model.slug === "string" ? model.slug.trim() : ""))
+        .filter(Boolean);
+}
+function getVisibleHardcodedCodexModelIds() {
+    return getHardcodedCodexModelCatalog()
+        .filter((model) => model.visibility === "list")
+        .map((model) => (typeof model.slug === "string" ? model.slug.trim() : ""))
+        .filter(Boolean);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theclawbay",
-  "version": "0.3.67",
+  "version": "0.3.69",
   "description": "CLI for connecting Codex, Continue, Cline, GSD, OpenClaw, OpenCode, Kilo, Roo Code, Aider, experimental Trae, and experimental Zo to The Claw Bay.",
   "license": "MIT",
   "repository": {
@@ -27,6 +27,7 @@
   },
   "files": [
     "dist",
+    "theclawbay-codex-model-catalog.json",
     "theclawbay-supported-models.json",
     "README.md",
     "LICENSE"