theclawbay 0.3.71 → 0.3.73

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

@@ -10,23 +10,33 @@ 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 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 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 TARGET_MODEL_IDS = (0, supported_models_1.getSupportedModelIds)();
+const TARGET_MODEL_ID_SET = new Set(TARGET_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 SEEDED_CACHE_FRESHNESS_ISO = "2099-12-31T23:59:59.000Z";
-const MINIMUM_CATALOG_CLIENT_VERSION = "0.124.0";
+const LEGACY_SEED_MARKER_VALUES = new Set([...TARGET_MODEL_IDS, 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 TARGET_MODEL_LABEL_TEXT = "the current The Claw Bay model catalog";
+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.`;
 function objectRecordOr(value) {
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
         return value;
@@ -65,7 +75,7 @@ function fingerprintModel(model) {
 async function readJsonIfExists(filePath) {
     try {
         const raw = await promises_1.default.readFile(filePath, "utf8");
-        return JSON.parse(raw.replace(/^\uFEFF/, ""));
+        return JSON.parse(raw);
     }
     catch (error) {
         const err = error;
@@ -74,29 +84,6 @@ async function readJsonIfExists(filePath) {
         throw error;
     }
 }
-async function readModelsCacheIfExists(filePath) {
-    try {
-        const raw = await promises_1.default.readFile(filePath, "utf8");
-        const hadBom = raw.charCodeAt(0) === 0xfeff;
-        try {
-            return { exists: true, parsed: JSON.parse(raw.replace(/^\uFEFF/, "")), hadBom };
-        }
-        catch (error) {
-            return {
-                exists: true,
-                parsed: null,
-                hadBom,
-                parseError: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    catch (error) {
-        const err = error;
-        if (err.code === "ENOENT")
-            return { exists: false, parsed: null, hadBom: false };
-        throw error;
-    }
-}
 async function removeFileIfExists(filePath) {
     try {
         await promises_1.default.unlink(filePath);
@@ -111,13 +98,13 @@ function normalizePatchFingerprintMap(state) {
     if (!state)
         return {};
     if (state.version === 1) {
-        if (!TRACKED_MODEL_ID_SET.has(state.modelId))
+        if (!TARGET_MODEL_ID_SET.has(state.modelId))
             return {};
         return state.fingerprint ? { [state.modelId]: state.fingerprint } : {};
     }
     const output = {};
     for (const entry of state.models) {
-        if (!TRACKED_MODEL_ID_SET.has(entry.modelId))
+        if (!TARGET_MODEL_ID_SET.has(entry.modelId))
             continue;
         if (entry.fingerprint)
             output[entry.modelId] = entry.fingerprint;
@@ -158,7 +145,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 = CATALOG_MODEL_IDS.flatMap((modelId) => {
+    const models = TARGET_MODEL_IDS.flatMap((modelId) => {
         const fingerprint = fingerprints[modelId];
         if (!fingerprint)
             return [];
@@ -170,52 +157,91 @@ async function writePatchState(statePath, fingerprints) {
     }, null, 2);
     await promises_1.default.writeFile(statePath, `${contents}\n`, "utf8");
 }
+function findModel(models, slug) {
+    return models.find((entry) => entry.slug === slug) ?? null;
+}
 function hasSeedMarker(model) {
     return LEGACY_SEED_MARKER_VALUES.has(model[SEED_MARKER_KEY]);
 }
-function stripSeedMarker(model) {
-    if (!(SEED_MARKER_KEY in model))
-        return cloneJson(model);
+function applySeedMarker(model) {
     const next = cloneJson(model);
-    delete next[SEED_MARKER_KEY];
+    next[SEED_MARKER_KEY] = SEED_MARKER_VALUE;
     return next;
 }
-function buildCatalogModels() {
-    return cloneJson(CATALOG_MODELS).map((model) => stripSeedMarker(model));
+function seedDescription(modelId) {
+    return SUPPORTED_MODEL_CONFIG.get(modelId)?.note ?? "The Claw Bay model.";
 }
-function buildCatalogModelMap() {
-    return new Map(buildCatalogModels().flatMap((model) => {
-        const slug = typeof model.slug === "string" ? model.slug : "";
-        return slug ? [[slug, model]] : [];
-    }));
-}
-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 hasCatalogModels(models) {
-    return models.some((model) => {
-        const slug = typeof model.slug === "string" ? model.slug : "";
-        return Boolean(slug) && CATALOG_MODEL_ID_SET.has(slug);
-    });
+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 = modelId === "gpt-5.5" ? "xhigh" : "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 (modelId === "gpt-5.5" && typeof seed.minimal_client_version !== "string") {
+        seed.minimal_client_version = "0.124.0";
+    }
+    if (typeof seed.effective_context_window_percent !== "number") {
+        seed.effective_context_window_percent = 95;
+    }
+    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 nextFetchedAtIsoForDocument(doc) {
-    if (!hasCatalogModels(doc.models)) {
-        return new Date().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 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 setCacheFreshnessMetadata(doc, clientVersion) {
     let changed = false;
-    const fetchedAt = nextFetchedAtIsoForDocument(doc);
-    if (doc.fetched_at !== fetchedAt) {
-        doc.fetched_at = fetchedAt;
+    const now = new Date().toISOString();
+    if (doc.fetched_at !== now) {
+        doc.fetched_at = now;
         changed = true;
     }
     if (clientVersion && doc.client_version !== clientVersion) {
@@ -237,204 +263,6 @@ function runVersionCommand(command, args) {
         return null;
     return parseCodexVersion(`${run.stdout ?? ""}\n${run.stderr ?? ""}`);
 }
-function compareCodexVersions(left, right) {
-    const leftParts = left.split(".").map((part) => Number.parseInt(part, 10));
-    const rightParts = right.split(".").map((part) => Number.parseInt(part, 10));
-    const maxLen = Math.max(leftParts.length, rightParts.length);
-    for (let index = 0; index < maxLen; index += 1) {
-        const leftPart = leftParts[index] ?? 0;
-        const rightPart = rightParts[index] ?? 0;
-        if (leftPart !== rightPart)
-            return leftPart - rightPart;
-    }
-    return 0;
-}
-function highestCodexVersion(candidates) {
-    const versions = candidates
-        .map((candidate) => (candidate ? parseCodexVersion(candidate) : null))
-        .filter((candidate) => Boolean(candidate));
-    if (versions.length === 0)
-        return null;
-    versions.sort((left, right) => compareCodexVersions(right, left));
-    return versions[0] ?? null;
-}
-function uniqueStrings(values) {
-    return Array.from(new Set(values.filter(Boolean)));
-}
-function isWslInteropRuntime() {
-    return node_os_1.default.platform() === "linux" && Boolean(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP);
-}
-function readWindowsCommandStdout(command) {
-    const shell = node_os_1.default.platform() === "win32" ? "powershell.exe" : isWslInteropRuntime() ? "powershell.exe" : null;
-    if (!shell)
-        return null;
-    const result = (0, node_child_process_1.spawnSync)(shell, ["-NoProfile", "-Command", command], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-    });
-    if (result.status !== 0)
-        return null;
-    const next = result.stdout.replace(/\r/g, "").trim();
-    return next ? next : null;
-}
-function resolveWindowsPathForHost(input) {
-    if (!input)
-        return null;
-    const trimmed = input.trim();
-    if (!trimmed)
-        return null;
-    if (node_os_1.default.platform() === "win32")
-        return trimmed;
-    const match = /^([A-Za-z]):\\(.*)$/.exec(trimmed);
-    if (!match)
-        return null;
-    const drive = match[1].toLowerCase();
-    const rest = match[2].replace(/\\/g, "/");
-    return node_path_1.default.posix.join("/mnt", drive, rest);
-}
-function resolveWindowsHomeDirForHost() {
-    const reported = readWindowsCommandStdout("$env:USERPROFILE");
-    if (reported)
-        return resolveWindowsPathForHost(reported);
-    if (node_os_1.default.platform() === "win32")
-        return node_os_1.default.homedir();
-    return null;
-}
-function editorExtensionDirCandidates() {
-    const home = node_os_1.default.homedir();
-    const dirs = [];
-    if (node_os_1.default.platform() === "darwin") {
-        dirs.push(node_path_1.default.join(home, ".vscode", "extensions"), node_path_1.default.join(home, ".vscode-insiders", "extensions"), node_path_1.default.join(home, ".cursor", "extensions"), node_path_1.default.join(home, ".windsurf", "extensions"), node_path_1.default.join(home, ".vscode-oss", "extensions"));
-        return uniqueStrings(dirs);
-    }
-    if (node_os_1.default.platform() === "win32") {
-        const homeDir = process.env.USERPROFILE?.trim() || home;
-        dirs.push(node_path_1.default.join(homeDir, ".vscode", "extensions"), node_path_1.default.join(homeDir, ".vscode-insiders", "extensions"), node_path_1.default.join(homeDir, ".cursor", "extensions"), node_path_1.default.join(homeDir, ".windsurf", "extensions"), node_path_1.default.join(homeDir, ".vscode-oss", "extensions"));
-        return uniqueStrings(dirs);
-    }
-    dirs.push(node_path_1.default.join(home, ".vscode", "extensions"), node_path_1.default.join(home, ".vscode-insiders", "extensions"), node_path_1.default.join(home, ".cursor", "extensions"), node_path_1.default.join(home, ".windsurf", "extensions"), node_path_1.default.join(home, ".vscode-oss", "extensions"));
-    if (isWslInteropRuntime()) {
-        const windowsHome = resolveWindowsHomeDirForHost();
-        if (windowsHome) {
-            dirs.push(node_path_1.default.join(windowsHome, ".vscode", "extensions"), node_path_1.default.join(windowsHome, ".vscode-insiders", "extensions"), node_path_1.default.join(windowsHome, ".cursor", "extensions"), node_path_1.default.join(windowsHome, ".windsurf", "extensions"), node_path_1.default.join(windowsHome, ".vscode-oss", "extensions"));
-        }
-    }
-    return uniqueStrings(dirs);
-}
-async function pathExists(filePath) {
-    try {
-        await promises_1.default.access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function codexBinaryCandidatesForBinRoot(binRoot) {
-    const runtimePreferred = node_os_1.default.platform() === "win32"
-        ? [
-            node_path_1.default.join(binRoot, "windows-x86_64", "codex.exe"),
-            node_path_1.default.join(binRoot, "windows-arm64", "codex.exe"),
-        ]
-        : node_os_1.default.platform() === "darwin"
-            ? [
-                node_path_1.default.join(binRoot, "darwin-aarch64", "codex"),
-                node_path_1.default.join(binRoot, "darwin-arm64", "codex"),
-                node_path_1.default.join(binRoot, "darwin-x86_64", "codex"),
-            ]
-            : [
-                node_path_1.default.join(binRoot, "linux-x86_64", "codex"),
-                node_path_1.default.join(binRoot, "linux-arm64", "codex"),
-            ];
-    return uniqueStrings([
-        ...runtimePreferred,
-        node_path_1.default.join(binRoot, "codex"),
-        node_path_1.default.join(binRoot, "codex.exe"),
-    ]);
-}
-async function inferCodexClientVersionsFromInstalledExtensions() {
-    const versions = new Set();
-    for (const extensionDir of editorExtensionDirCandidates()) {
-        let entries = [];
-        try {
-            entries = await promises_1.default.readdir(extensionDir, { withFileTypes: true });
-        }
-        catch (error) {
-            const err = error;
-            if (err.code === "ENOENT")
-                continue;
-            throw error;
-        }
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            if (!entry.name.toLowerCase().startsWith("openai.chatgpt-"))
-                continue;
-            const binRoot = node_path_1.default.join(extensionDir, entry.name, "bin");
-            for (const candidate of codexBinaryCandidatesForBinRoot(binRoot)) {
-                if (!(await pathExists(candidate)))
-                    continue;
-                const parsed = runVersionCommand(candidate, ["--version"]);
-                if (parsed)
-                    versions.add(parsed);
-            }
-        }
-    }
-    return [...versions];
-}
-function desktopAppCodexBinaryCandidates() {
-    const candidates = [];
-    const home = node_os_1.default.homedir();
-    if (node_os_1.default.platform() === "darwin") {
-        for (const appRoot of [
-            "/Applications/Codex.app",
-            "/Applications/OpenAI Codex.app",
-            node_path_1.default.join(home, "Applications", "Codex.app"),
-            node_path_1.default.join(home, "Applications", "OpenAI Codex.app"),
-        ]) {
-            candidates.push(node_path_1.default.join(appRoot, "Contents", "Resources", "codex"), node_path_1.default.join(appRoot, "Contents", "Resources", "app", "resources", "codex"));
-        }
-    }
-    if (node_os_1.default.platform() === "win32" || isWslInteropRuntime()) {
-        const installLocations = readWindowsCommandStdout("Get-AppxPackage OpenAI.Codex | ForEach-Object { $_.InstallLocation }");
-        if (installLocations) {
-            for (const installLocation of installLocations.split("\n")) {
-                const hostPath = resolveWindowsPathForHost(installLocation);
-                if (!hostPath)
-                    continue;
-                candidates.push(node_path_1.default.join(hostPath, "app", "resources", "codex.exe"));
-            }
-        }
-    }
-    return uniqueStrings(candidates);
-}
-async function inferCodexClientVersionsFromInstalledDesktopApps() {
-    const versions = new Set();
-    for (const candidate of desktopAppCodexBinaryCandidates()) {
-        if (!(await pathExists(candidate)))
-            continue;
-        const parsed = runVersionCommand(candidate, ["--version"]);
-        versions.add(parsed ?? MINIMUM_CATALOG_CLIENT_VERSION);
-    }
-    return [...versions];
-}
-function preferredPickerCacheClientVersion(pickerVersions) {
-    const compatible = pickerVersions.some((version) => compareCodexVersions(version, MINIMUM_CATALOG_CLIENT_VERSION) >= 0);
-    if (!compatible)
-        return null;
-    // The shared models_cache.json is accepted by newer picker builds when stamped
-    // with the oldest model-catalog version, but older app builds reject a cache
-    // stamped with a newer VS Code/CLI version.
-    return MINIMUM_CATALOG_CLIENT_VERSION;
-}
-async function inferCodexClientVersionFromVersionJson(codexHome) {
-    const parsed = await readJsonIfExists(node_path_1.default.join(codexHome, "version.json"));
-    const obj = objectRecordOr(parsed);
-    if (!obj)
-        return null;
-    const latestVersion = typeof obj.latest_version === "string" ? obj.latest_version : "";
-    return latestVersion ? parseCodexVersion(latestVersion) : null;
-}
 function resolvePythonCommand() {
     const candidates = [
         { command: "python3", args: ["-c", "import sqlite3"] },
@@ -525,35 +353,20 @@ async function inferCodexClientVersionFromStateDb(codexHome) {
     return null;
 }
 async function inferCodexClientVersion(codexHome) {
-    const versions = [];
     if (node_os_1.default.platform() === "win32") {
         for (const commandLine of ["codex --version", "codex-cli --version", "codex.cmd --version", "codex-cli.cmd --version"]) {
             const parsed = runVersionCommand("cmd.exe", ["/d", "/s", "/c", commandLine]);
             if (parsed)
-                versions.push(parsed);
+                return parsed;
         }
+        return await inferCodexClientVersionFromStateDb(codexHome);
     }
-    else {
-        for (const command of ["codex", "codex-cli"]) {
-            const parsed = runVersionCommand(command, ["--version"]);
-            if (parsed)
-                versions.push(parsed);
-        }
+    for (const command of ["codex", "codex-cli"]) {
+        const parsed = runVersionCommand(command, ["--version"]);
+        if (parsed)
+            return parsed;
     }
-    const pickerVersions = [
-        ...await inferCodexClientVersionsFromInstalledDesktopApps(),
-        ...await inferCodexClientVersionsFromInstalledExtensions(),
-    ];
-    const pickerCacheClientVersion = preferredPickerCacheClientVersion(pickerVersions);
-    if (pickerCacheClientVersion)
-        return pickerCacheClientVersion;
-    const versionJsonVersion = await inferCodexClientVersionFromVersionJson(codexHome);
-    if (versionJsonVersion)
-        versions.push(versionJsonVersion);
-    const stateDbVersion = await inferCodexClientVersionFromStateDb(codexHome);
-    if (stateDbVersion)
-        versions.push(stateDbVersion);
-    return highestCodexVersion(versions);
+    return await inferCodexClientVersionFromStateDb(codexHome);
 }
 function normalizeCacheDocument(value) {
     const doc = objectRecordOr(value);
@@ -569,126 +382,122 @@ async function ensureCodexModelCacheHasGpt54(params) {
     const statePath = node_path_1.default.join(params.codexHome, MODELS_CACHE_STATE_FILE);
     try {
         const existingState = await readPatchState(statePath);
-        const cacheRead = await readModelsCacheIfExists(cachePath);
-        const parsed = cacheRead.parsed;
-        const catalogModels = buildCatalogModels();
-        const catalogModelMap = buildCatalogModelMap();
-        if (!cacheRead.exists || parsed === null) {
+        const parsed = await readJsonIfExists(cachePath);
+        if (parsed === null) {
             const clientVersion = await inferCodexClientVersion(params.codexHome);
             if (!clientVersion) {
                 await removeFileIfExists(statePath);
                 return {
                     action: "skipped",
-                    warning: cacheRead.exists
-                        ? "Codex models cache is not valid JSON, and Codex version could not be inferred for a safe The Claw Bay model catalog repair."
-                        : "Codex models cache was not found, and Codex version could not be inferred for a safe The Claw Bay model catalog refresh.",
+                    warning: `Codex models cache was not found, and Codex version could not be inferred for a safe ${TARGET_MODEL_LABEL_TEXT} 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 docModels = [];
+            const nextState = {};
+            for (const modelId of TARGET_MODEL_IDS) {
+                const seed = buildSeedModel(docModels, modelId);
+                docModels.push(seed);
+                nextState[modelId] = fingerprintModel(seed);
+            }
             const doc = {
-                fetched_at: nextFetchedAtIsoForDocument({ models: docModels }),
+                fetched_at: new Date().toISOString(),
                 client_version: clientVersion,
                 models: docModels,
             };
             await promises_1.default.mkdir(params.codexHome, { recursive: true });
             await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
             await writePatchState(statePath, nextState);
-            return { action: cacheRead.exists ? "refreshed" : "created" };
+            return { action: "created" };
         }
         const doc = normalizeCacheDocument(parsed);
         if (!doc) {
             return {
                 action: "skipped",
-                warning: "Codex models cache exists but is not valid JSON in the expected format; skipped The Claw Bay model catalog refresh.",
+                warning: `Codex models cache exists but is not valid JSON in the expected format; skipped ${TARGET_MODEL_LABEL_TEXT} seed.`,
             };
         }
         const clientVersion = (await inferCodexClientVersion(params.codexHome)) ??
             (typeof doc.client_version === "string" && doc.client_version ? doc.client_version : null);
-        let changed = cacheRead.hadBom;
+        let changed = false;
         let seeded = false;
-        const currentCatalogEntries = new Map();
-        const rest = [];
-        for (const entry of doc.models) {
-            const slug = typeof entry.slug === "string" ? entry.slug : "";
-            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);
+        let stateChanged = false;
+        const nextState = { ...existingState };
+        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;
                 }
-                else {
+                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;
                     changed = true;
+                    stateChanged = true;
+                    continue;
+                }
+                if (trackedFingerprint && trackedFingerprint !== currentFingerprint) {
+                    delete nextState[modelId];
+                    stateChanged = true;
                 }
                 continue;
             }
-            const normalized = stripSeedMarker(entry);
-            if (fingerprintModel(normalized) !== fingerprintModel(entry)) {
-                changed = true;
-            }
-            rest.push(normalized);
+            const seed = buildSeedModel(doc.models, modelId);
+            doc.models = [seed, ...doc.models];
+            nextState[modelId] = fingerprintModel(seed);
+            seeded = true;
+            changed = true;
+            stateChanged = true;
         }
-        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;
-            }
-            const normalizedExisting = stripSeedMarker(existingModel);
-            const existingFingerprint = fingerprintModel(normalizedExisting);
-            if (existingFingerprint === desiredFingerprint && !hasSeedMarker(existingModel)) {
-                orderedCatalog.push(normalizedExisting);
-                if (trackedFingerprint === desiredFingerprint) {
-                    nextState[modelId] = trackedFingerprint;
-                }
+        // 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);
                 continue;
             }
-            orderedCatalog.push(cloneJson(desiredModel));
-            nextState[modelId] = desiredFingerprint;
-            changed = true;
-            seeded = true;
+            rest.push(entry);
+        }
+        const orderedTargets = [];
+        for (const id of TARGET_MODEL_IDS) {
+            const entry = bySlug.get(id);
+            if (entry)
+                orderedTargets.push(entry);
         }
-        doc.models = [...orderedCatalog, ...rest];
+        doc.models = [...orderedTargets, ...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 = CATALOG_MODEL_IDS.some((id) => Boolean(nextState[id]));
+        const hasAnyTracked = TARGET_MODEL_IDS.some((id) => Boolean(nextState[id]));
         if (!hasAnyTracked) {
             if (Object.keys(existingState).length > 0) {
                 await removeFileIfExists(statePath);
             }
         }
-        else if (stateChanged) {
+        else if (stateChanged || seeded) {
             await writePatchState(statePath, nextState);
         }
         if (seeded)
             return { action: "seeded" };
         if (changed || stateChanged)
             return { action: "refreshed" };
-        return { action: hasAnyTracked ? "already_seeded" : "already_present" };
+        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" };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -715,24 +524,16 @@ async function cleanupSeededCodexModelCache(params) {
         if (!doc) {
             return {
                 action: "none",
-                warning: "Codex models cache exists but is not valid JSON in the expected format; left The Claw Bay model cache patch state untouched.",
+                warning: `Codex models cache exists but is not valid JSON in the expected format; left ${TARGET_MODEL_LABEL_TEXT} cache patch state untouched.`,
             };
         }
         let removed = 0;
         let preserved = 0;
         doc.models = doc.models.filter((entry) => {
             const slug = typeof entry.slug === "string" ? entry.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)
+            if (!slug || !TARGET_MODEL_ID_SET.has(slug))
                 return true;
-            const normalized = stripSeedMarker(entry);
-            if (fingerprintModel(normalized) !== trackedFingerprint) {
+            if (!hasSeedMarker(entry)) {
                 preserved += 1;
                 return true;
             }