codex-copilot-dx 0.6.20 → 0.7.0

package/src/doctor.mjs

@@ -4,16 +4,13 @@ import os from "node:os";
 import net from "node:net";
 import { githubTokenPath, readGithubTokenMetadata, validateGithubToken } from "./auth.mjs";
 import {
-  AUTH_PROFILE_CLAUDE,
   AUTH_PROFILE_CODEX,
   readAuthProfileCredentials,
 } from "./auth-profile.mjs";
-import { claudeDesktopPaths } from "./claude-desktop-config.mjs";
 import { status } from "./status.mjs";
 import { buildHeaders, FALLBACK_VSCODE_VERSION, parseApiBase } from "./copilot.mjs";
 import { adapterBaseUrl, checkRunningAdapter } from "./running-adapter.mjs";
-import { CODEX_AUTO_REVIEW_MODEL, isClaudeCopilotModel } from "./models.mjs";
-import { loadModelCache } from "./model-cache.mjs";
+import { CODEX_AUTO_REVIEW_MODEL } from "./models.mjs";
 
 function localGatewayBaseUrl(host, port) {
   const safeHost = String(host || "127.0.0.1");
@@ -24,18 +21,8 @@ function localGatewayBaseUrl(host, port) {
 function readText(filePath) {
   try {
     return { ok: true, text: fs.readFileSync(filePath, "utf8") };
-  } catch (e) {
-    return { ok: false, missing: e?.code === "ENOENT", error: e };
-  }
-}
-
-function readJson(filePath) {
-  const raw = readText(filePath);
-  if (!raw.ok) return raw;
-  try {
-    return { ok: true, json: JSON.parse(raw.text) };
-  } catch (e) {
-    return { ok: false, parseError: true, error: e };
+  } catch (error) {
+    return { ok: false, missing: error?.code === "ENOENT", error };
   }
 }
 
@@ -64,21 +51,18 @@ function modelEndpoints(model) {
   return Array.isArray(model?.supported_endpoints) ? model.supported_endpoints : [];
 }
 
-export function selectCompatibilityModels(models, { claudeModels = models } = {}) {
-  const data = copilotModelData(models).filter((model) => model?.model_picker_enabled !== false);
-  const claudeData = copilotModelData(claudeModels);
-  const responsesCandidates = data.filter((model) => {
-    const id = String(model?.id || "");
-    const endpoints = modelEndpoints(model);
-    return id.startsWith("gpt-") && (endpoints.includes("/responses") || endpoints.includes("/v1/responses"));
-  });
-  const responsesOnly = [...responsesCandidates].reverse()
+export function selectCompatibilityModels(models) {
+  const candidates = copilotModelData(models)
+    .filter((model) => model?.model_picker_enabled !== false)
+    .filter((model) => {
+      const id = String(model?.id || "");
+      const endpoints = modelEndpoints(model);
+      return id.startsWith("gpt-")
+        && (endpoints.includes("/responses") || endpoints.includes("/v1/responses"));
+    });
+  const responsesOnly = [...candidates].reverse()
     .find((model) => !modelEndpoints(model).includes("/chat/completions"));
-  const claude = claudeData.find(isClaudeCopilotModel);
-  return {
-    responsesModel: String((responsesOnly || responsesCandidates[0])?.id || ""),
-    claudeModel: String(claude?.id || ""),
-  };
+  return { responsesModel: String((responsesOnly || candidates[0])?.id || "") };
 }
 
 async function fetchTextWithTimeout(fetchImpl, url, init, timeoutMs) {
@@ -113,8 +97,8 @@ async function runCompatibilityCheck(checks, label, task) {
     const value = await task();
     checks.push({ kind: "ok", message: `${label} passed (${Date.now() - started}ms)` });
     return value;
-  } catch (e) {
-    const reason = e?.name === "AbortError" ? "timed out" : e?.message || "unknown error";
+  } catch (error) {
+    const reason = error?.name === "AbortError" ? "timed out" : error?.message || "unknown error";
     checks.push({ kind: "err", message: `${label} failed: ${reason}` });
     return null;
   }
@@ -140,8 +124,6 @@ export async function inspectAdapterCompatibility({
   port = 2026,
   fetchImpl = fetch,
   timeoutMs = 120000,
-  claudeMode = "inherited",
-  claudeModels,
 } = {}) {
   const baseUrl = localGatewayBaseUrl(connectHost(host), port);
   const checks = [];
@@ -154,9 +136,7 @@ export async function inspectAdapterCompatibility({
   });
   if (!models) return checks;
 
-  const { responsesModel, claudeModel } = selectCompatibilityModels(models, {
-    claudeModels: claudeMode === "isolated" ? (claudeModels || { data: [] }) : models,
-  });
+  const { responsesModel } = selectCompatibilityModels(models);
   if (!responsesModel) {
     checks.push({ kind: "err", message: "Compatibility Responses check failed: no GPT model advertises /responses" });
     return checks;
@@ -201,23 +181,6 @@ export async function inspectAdapterCompatibility({
     parseCompactionResponse(text);
   });
 
-  if (!claudeModel) {
-    const reason = claudeMode === "isolated"
-      ? "the isolated Claude model cache is unavailable or advertises no Claude chat model; restart ccdx to refresh it"
-      : "no Claude chat model was advertised";
-    checks.push({ kind: "warn", message: `Anthropic stream compatibility was not verified because ${reason}` });
-    return checks;
-  }
-
-  await runCompatibilityCheck(checks, `Anthropic Messages stream (${claudeModel})`, async () => {
-    const text = await compatibilityRequest(fetchImpl, `${baseUrl}/v1/messages`, {
-      model: claudeModel,
-      max_tokens: 16,
-      stream: true,
-      messages: [{ role: "user", content: "Reply with OK only." }],
-    }, timeoutMs);
-    if (!/^event:\s*message_stop\s*$/m.test(text)) throw new Error("stream did not contain message_stop");
-  });
   return checks;
 }
 
@@ -236,73 +199,36 @@ export function inspectGitHubToken({ home = os.homedir() } = {}) {
 }
 
 export function inspectAuthProfiles({ home = os.homedir() } = {}) {
-  const checks = [
+  return [
     ...inspectGitHubToken({ home }),
     { kind: "ok", message: "Codex authentication profile uses the legacy path" },
   ];
-  try {
-    const claude = readAuthProfileCredentials(AUTH_PROFILE_CLAUDE, { home });
-    if (!claude.configured) {
-      checks.push({ kind: "ok", message: "Claude authentication profile is not isolated and inherits Codex" });
-    } else if (!claude.valid) {
-      checks.push({
-        kind: "err",
-        message: `Claude isolated authentication profile is invalid: ${claude.reason}`,
-        fix: "ccdx auth login claude --reauth",
-      });
-    } else {
-      const account = claude.identity?.login ? ` for ${claude.identity.login}` : "";
-      checks.push({ kind: "ok", message: `Claude isolated authentication profile is configured${account}` });
-    }
-  } catch {
-    checks.push({ kind: "err", message: "Claude isolated authentication profile could not be inspected" });
-  }
-  return checks;
 }
 
 function checkedDoctorProfile(profile = AUTH_PROFILE_CODEX) {
   const value = String(profile || AUTH_PROFILE_CODEX).trim().toLowerCase();
-  if (![AUTH_PROFILE_CODEX, AUTH_PROFILE_CLAUDE, "all"].includes(value)) {
-    throw new Error(`Doctor profile must be codex, claude, or all: ${profile}`);
+  if (value !== AUTH_PROFILE_CODEX) {
+    throw new Error(`Doctor profile must be codex: ${profile}`);
   }
   return value;
 }
 
-function onlineMessage(profile, message, inherited = false) {
-  if (profile === AUTH_PROFILE_CODEX) return message;
-  return `${inherited ? "Claude inherited Codex" : "Claude profile"}: ${message}`;
-}
-
 export async function inspectGitHubTokenOnline({
   home = os.homedir(),
   profile = AUTH_PROFILE_CODEX,
   fetchImpl = fetch,
   timeoutMs = 10000,
 } = {}) {
-  const requestedProfile = checkedDoctorProfile(profile);
-  if (requestedProfile === "all") throw new Error("inspectGitHubTokenOnline accepts one profile at a time");
-  let inherited = false;
+  checkedDoctorProfile(profile);
   let credentials;
   try {
-    credentials = readAuthProfileCredentials(requestedProfile, { home });
-    if (requestedProfile === AUTH_PROFILE_CLAUDE && !credentials.configured) {
-      inherited = true;
-      credentials = readAuthProfileCredentials(AUTH_PROFILE_CODEX, { home });
-    }
+    credentials = readAuthProfileCredentials(AUTH_PROFILE_CODEX, { home });
   } catch {
-    return [{ kind: "warn", message: onlineMessage(requestedProfile, "Online Copilot check failed while reading the local credential", inherited) }];
+    return [{ kind: "warn", message: "Online Copilot check failed while reading the local credential" }];
   }
 
-  const checks = [];
-  if (inherited) {
-    checks.push({ kind: "ok", message: "Claude profile is not separately configured and inherits Codex authentication" });
-  }
   if (!credentials.valid) {
-    const reason = requestedProfile === AUTH_PROFILE_CODEX
-      ? "the GitHub token is missing"
-      : credentials.reason;
-    checks.push({ kind: "warn", message: onlineMessage(requestedProfile, `Online Copilot check skipped because ${reason}`, inherited) });
-    return checks;
+    return [{ kind: "warn", message: "Online Copilot check skipped because the GitHub token is missing" }];
   }
 
   const controller = new AbortController();
@@ -314,11 +240,10 @@ export async function inspectGitHubTokenOnline({
     });
     if (!validation.ok) {
       const statusText = validation.status ? ` (HTTP ${validation.status})` : "";
-      checks.push({
+      return [{
         kind: validation.transient ? "warn" : "err",
-        message: onlineMessage(requestedProfile, `GitHub Copilot authentication failed: ${validation.reason}${statusText}`, inherited),
-      });
-      return checks;
+        message: `GitHub Copilot authentication failed: ${validation.reason}${statusText}`,
+      }];
     }
 
     const tokenData = validation.copilotTokenData;
@@ -331,64 +256,35 @@ export async function inspectGitHubTokenOnline({
     });
     const modelResp = await fetchImpl(`${apiBase}/models`, { headers, signal: controller.signal });
     if (!modelResp.ok) {
-      checks.push(
-        { kind: "ok", message: onlineMessage(requestedProfile, `GitHub Copilot access verified for ${validation.login || "current account"}`, inherited) },
-        { kind: "err", message: onlineMessage(requestedProfile, `Copilot models endpoint returned HTTP ${modelResp.status}`, inherited) },
-      );
-      return checks;
+      return [
+        { kind: "ok", message: `GitHub Copilot access verified for ${validation.login || "current account"}` },
+        { kind: "err", message: `Copilot models endpoint returned HTTP ${modelResp.status}` },
+      ];
     }
     const models = await modelResp.json();
     const data = Array.isArray(models) ? models : models?.data;
-    checks.push(
-      { kind: "ok", message: onlineMessage(requestedProfile, `GitHub Copilot access verified for ${validation.login || "current account"}`, inherited) },
-      { kind: "ok", message: onlineMessage(requestedProfile, `Copilot models endpoint returned ${Array.isArray(data) ? data.length : 0} models`, inherited) },
-    );
-    return checks;
-  } catch (e) {
-    const errorCode = e?.cause?.code || e?.code || "";
-    const reason = e?.name === "AbortError"
+    return [
+      { kind: "ok", message: `GitHub Copilot access verified for ${validation.login || "current account"}` },
+      { kind: "ok", message: `Copilot models endpoint returned ${Array.isArray(data) ? data.length : 0} models` },
+    ];
+  } catch (error) {
+    const errorCode = error?.cause?.code || error?.code || "";
+    const reason = error?.name === "AbortError"
       ? `timed out after ${timeoutMs}ms`
       : `request failed${errorCode ? ` (${errorCode})` : ""}`;
-    checks.push({ kind: "warn", message: onlineMessage(requestedProfile, `Online Copilot check failed: ${reason}`, inherited) });
-    return checks;
+    return [{ kind: "warn", message: `Online Copilot check failed: ${reason}` }];
   } finally {
     clearTimeout(timer);
   }
 }
 
-export async function inspectAuthProfilesOnline({
-  home = os.homedir(),
-  profile = AUTH_PROFILE_CODEX,
-  fetchImpl = fetch,
-  timeoutMs = 10000,
-} = {}) {
-  const selected = checkedDoctorProfile(profile);
-  if (selected !== "all") {
-    return inspectGitHubTokenOnline({ home, profile: selected, fetchImpl, timeoutMs });
-  }
-
-  let claudeConfigured = false;
-  let claudeReadFailed = false;
-  try {
-    claudeConfigured = readAuthProfileCredentials(AUTH_PROFILE_CLAUDE, { home }).configured;
-  } catch {
-    claudeReadFailed = true;
-  }
-  const [codexChecks, claudeChecks] = await Promise.all([
-    inspectGitHubTokenOnline({ home, profile: AUTH_PROFILE_CODEX, fetchImpl, timeoutMs }),
-    claudeReadFailed
-      ? Promise.resolve([{ kind: "err", message: "Claude isolated authentication profile could not be inspected" }])
-      : claudeConfigured
-      ? inspectGitHubTokenOnline({ home, profile: AUTH_PROFILE_CLAUDE, fetchImpl, timeoutMs })
-      : Promise.resolve([{ kind: "ok", message: "Claude profile is not separately configured and inherits Codex authentication" }]),
-  ]);
-  return [...codexChecks, ...claudeChecks];
+export async function inspectAuthProfilesOnline(options = {}) {
+  return inspectGitHubTokenOnline(options);
 }
 
 export function inspectCodexConfig({ home = os.homedir(), host = "127.0.0.1", port = 2026 } = {}) {
   const filePath = path.join(home, ".codex", "config.toml");
-  const expectedAnthropicBaseUrl = adapterBaseUrl(host, port);
-  const expectedBaseUrl = `${expectedAnthropicBaseUrl}/v1`;
+  const expectedBaseUrl = `${adapterBaseUrl(host, port)}/v1`;
   const config = readText(filePath);
   if (!config.ok) {
     return [{ kind: "warn", message: `Codex config not found at ${displayPath(home, filePath)}` }];
@@ -403,84 +299,12 @@ export function inspectCodexConfig({ home = os.homedir(), host = "127.0.0.1", po
   const missing = [];
   if (tomlString(config.text, "OPENAI_BASE_URL") !== expectedBaseUrl) missing.push("OPENAI_BASE_URL");
   if (tomlString(config.text, "OPENAI_API_KEY") !== "dummy") missing.push("OPENAI_API_KEY");
-  if (tomlString(config.text, "ANTHROPIC_BASE_URL") !== expectedAnthropicBaseUrl) missing.push("ANTHROPIC_BASE_URL");
-  if (tomlString(config.text, "ANTHROPIC_AUTH_TOKEN") !== "dummy") missing.push("ANTHROPIC_AUTH_TOKEN");
   checks.push(missing.length === 0
     ? { kind: "ok", message: "Codex shell env local API keys are configured" }
     : { kind: "warn", message: `Codex shell env local API keys need update: ${missing.join(", ")}` });
   return checks;
 }
 
-export function inspectClaudeCodeConfig({ home = os.homedir(), host = "127.0.0.1", port = 2026 } = {}) {
-  const filePath = path.join(home, ".claude", "settings.json");
-  const expectedBaseUrl = adapterBaseUrl(host, port);
-  const settings = readJson(filePath);
-  if (!settings.ok) {
-    const reason = settings.parseError ? `could not parse: ${settings.error.message}` : `not found at ${displayPath(home, filePath)}`;
-    return [{ kind: settings.parseError ? "err" : "warn", message: `Claude Code settings ${reason}` }];
-  }
-
-  const env = settings.json?.env || {};
-  const missing = [];
-  if (env.ANTHROPIC_BASE_URL !== expectedBaseUrl) missing.push("ANTHROPIC_BASE_URL");
-  if (env.ANTHROPIC_AUTH_TOKEN !== "dummy") missing.push("ANTHROPIC_AUTH_TOKEN");
-  return [missing.length === 0
-    ? { kind: "ok", message: `Claude Code points to ${expectedBaseUrl}` }
-    : { kind: "warn", message: `Claude Code settings need update: ${missing.join(", ")}` }];
-}
-
-export function inspectClaudeAppConfig({
-  home = os.homedir(),
-  platform = process.platform,
-  env = process.env,
-  host = "127.0.0.1",
-  port = 2026,
-} = {}) {
-  const paths = claudeDesktopPaths(home, platform, env);
-  const expectedBaseUrl = localGatewayBaseUrl(host, port);
-  const checks = [];
-
-  const normalConfig = readJson(paths.normalConfigPath);
-  const threepConfig = readJson(paths.threepConfigPath);
-  if (normalConfig.ok && threepConfig.ok
-    && normalConfig.json?.deploymentMode === "3p"
-    && threepConfig.json?.deploymentMode === "3p") {
-    checks.push({ kind: "ok", message: "Claude App deployment mode is 3p" });
-  } else {
-    checks.push({ kind: "warn", message: "Claude App deployment mode is not fully configured for 3p" });
-  }
-
-  const meta = readJson(paths.metaPath);
-  const appliedId = meta.ok ? String(meta.json?.appliedId || "").trim() : "";
-  if (!appliedId) {
-    checks.push({
-      kind: "warn",
-      message: "Claude App gateway profile is not configured",
-      fix: "ccdx start --configure-claude-app",
-    });
-    return checks;
-  }
-
-  const profilePath = path.join(paths.configLibraryPath, `${appliedId}.json`);
-  const profile = readJson(profilePath);
-  if (!profile.ok) {
-    checks.push({ kind: "warn", message: `Claude App active gateway profile not found at ${displayPath(home, profilePath)}` });
-    return checks;
-  }
-
-  const p = profile.json || {};
-  const missing = [];
-  if (p.inferenceProvider !== "gateway") missing.push("inferenceProvider");
-  if (p.inferenceGatewayBaseUrl !== expectedBaseUrl) missing.push(`inferenceGatewayBaseUrl expected "${expectedBaseUrl}"`);
-  if (p.inferenceGatewayAuthScheme !== "bearer") missing.push("inferenceGatewayAuthScheme");
-  if (!String(p.inferenceGatewayApiKey || "").trim()) missing.push("inferenceGatewayApiKey");
-  if (!String(p.inferenceModels || "").trim()) missing.push("inferenceModels");
-  checks.push(missing.length === 0
-    ? { kind: "ok", message: `Claude App gateway profile points to ${expectedBaseUrl}` }
-    : { kind: "warn", message: `Claude App gateway profile needs update: ${missing.join(", ")}` });
-  return checks;
-}
-
 function connectHost(host) {
   const normalized = String(host || "127.0.0.1").replace(/^\[(.*)\]$/, "$1");
   if (normalized === "0.0.0.0") return "127.0.0.1";
@@ -505,12 +329,9 @@ export function checkAdapterListening({ host = "127.0.0.1", port = 2026, timeout
 
 export async function collectDoctorChecks({
   home = os.homedir(),
-  platform = process.platform,
-  env = process.env,
   host = "127.0.0.1",
   port = 2026,
   checkAdapter = true,
-  checkPmStudio = checkAdapter,
   checkAdapterListeningFn = checkAdapterListening,
   checkRunningAdapterFn = checkRunningAdapter,
   online = false,
@@ -520,13 +341,11 @@ export async function collectDoctorChecks({
   onlineTimeoutMs = 10000,
   compatTimeoutMs = 120000,
   inspectAdapterCompatibilityFn = inspectAdapterCompatibility,
-  inspectPmStudioHealthFn,
 } = {}) {
+  checkedDoctorProfile(profile);
   const checks = [
     ...inspectAuthProfiles({ home }),
     ...inspectCodexConfig({ home, host, port }),
-    ...inspectClaudeCodeConfig({ home, host, port }),
-    ...inspectClaudeAppConfig({ home, platform, env, host, port }),
   ];
 
   if (online) {
@@ -564,80 +383,15 @@ export async function collectDoctorChecks({
     }
   }
 
-  if (checkPmStudio && platform === "darwin") {
-    const inspect = inspectPmStudioHealthFn || (async (options) => {
-      const module = await import("./pm-studio-status.mjs");
-      return module.inspectPmStudioStatus(options);
-    });
-    const pm = await inspect({ home });
-    const version = pm.app.metadata ? `${pm.app.metadata.version} build ${pm.app.metadata.build}` : "";
-    if (pm.app.state === "patched") {
-      checks.push({ kind: "ok", message: `PM Studio ${version} patch is verified` });
-      if (!pm.claude.valid) {
-        checks.push({
-          kind: "warn",
-          message: "PM Studio Claude routing requires a valid isolated Claude profile",
-          fix: "ccdx auth login claude --reauth",
-        });
-      }
-      if (!pm.adapter?.ok) {
-        checks.push({ kind: "warn", message: "PM Studio relay is not currently available", fix: "ccdx start" });
-      } else if (!pm.runtime?.ok) {
-        checks.push({
-          kind: "warn",
-          message: "PM Studio relay is running, but its isolated routing is not ready",
-          fix: "stop the running adapter, then run ccdx start",
-        });
-      }
-    } else if (pm.app.state === "predecessor") {
-      checks.push({
-        kind: "warn",
-        message: `PM Studio ${version} has a verified predecessor split patch`,
-        fix: "ccdx pms setup",
-      });
-    } else if (pm.app.state === "clean") {
-      checks.push({
-        kind: "warn",
-        message: `PM Studio ${version} has a compatible local patch structure but is not patched`,
-        fix: "ccdx pms setup",
-      });
-    } else if (pm.app.state === "unsupported") {
-      checks.push({ kind: "warn", message: `PM Studio ${version} does not expose one uniquely compatible patch structure; no files will be changed` });
-    } else if (pm.app.state === "drift" || pm.app.state === "error") {
-      checks.push({ kind: "err", message: `PM Studio integrity check failed: ${pm.app.issues.join("; ")}` });
-    }
-  }
-
   if (compat) {
     if (!running?.ok) {
       checks.push({ kind: "err", message: "Compatibility checks require a running, version-compatible codex-copilot-dx adapter" });
     } else {
-      let claudeMode = "inherited";
-      let claudeModels;
-      try {
-        const claudeCredentials = readAuthProfileCredentials(AUTH_PROFILE_CLAUDE, { home });
-        if (claudeCredentials.configured) {
-          claudeMode = "isolated";
-          if (claudeCredentials.valid) {
-            claudeModels = loadModelCache({
-              home,
-              profile: AUTH_PROFILE_CLAUDE,
-              credentialFingerprint: claudeCredentials.metadata?.token_fingerprint,
-            });
-          }
-        }
-      } catch {
-        // A configured-but-unreadable optional profile must not borrow the
-        // Codex catalog. Compatibility will report the Claude path unverified.
-        claudeMode = "isolated";
-      }
       checks.push(...await inspectAdapterCompatibilityFn({
         host,
         port,
         fetchImpl,
         timeoutMs: compatTimeoutMs,
-        claudeMode,
-        claudeModels,
       }));
     }
   }
@@ -647,11 +401,10 @@ export async function collectDoctorChecks({
 
 export async function runDoctor(options = {}) {
   const log = options.log || console.log;
-  const profile = checkedDoctorProfile(options.profile);
+  checkedDoctorProfile(options.profile);
   const flags = [
     options.online ? "--online" : "",
     options.compat ? "--compat" : "",
-    profile !== AUTH_PROFILE_CODEX ? `--profile ${profile}` : "",
   ].filter(Boolean);
   log(`${options.commandName || "ccdx"} doctor${flags.length ? ` ${flags.join(" ")}` : ""}`);
   const checks = await collectDoctorChecks(options);

package/src/model-cache.mjs

@@ -4,14 +4,9 @@ import path from "node:path";
 
 export const MODEL_CACHE_SOFT_TTL_MS = 2 * 60 * 60 * 1000;
 export const MODEL_CACHE_HARD_TTL_MS = 7 * 24 * 60 * 60 * 1000;
-const MODEL_CACHE_PROFILES = new Set(["codex", "claude"]);
 
-export function modelCachePath(home = os.homedir(), profile = "codex") {
-  if (!MODEL_CACHE_PROFILES.has(profile)) throw new Error(`Unknown model cache profile: ${profile}`);
-  const root = path.join(home, ".local", "share", "codex-copilot-dx");
-  return profile === "codex"
-    ? path.join(root, "models.json")
-    : path.join(root, "profiles", profile, "models.json");
+export function modelCachePath(home = os.homedir()) {
+  return path.join(home, ".local", "share", "codex-copilot-dx", "models.json");
 }
 
 function modelData(models) {
@@ -30,7 +25,6 @@ function normalizedTtl(value, fallback) {
 
 export function loadModelCacheEntry({
   home = os.homedir(),
-  profile = "codex",
   credentialFingerprint = "",
   softTtlMs = MODEL_CACHE_SOFT_TTL_MS,
   hardTtlMs,
@@ -38,7 +32,7 @@ export function loadModelCacheEntry({
   now = Date.now,
 } = {}) {
   try {
-    const parsed = JSON.parse(fs.readFileSync(modelCachePath(home, profile), "utf8"));
+    const parsed = JSON.parse(fs.readFileSync(modelCachePath(home), "utf8"));
     const savedAt = Date.parse(parsed.saved_at);
     if (!Number.isFinite(savedAt)) return null;
     const expectedFingerprint = String(credentialFingerprint || "").trim();
@@ -71,14 +65,13 @@ export function loadModelCache(options = {}) {
 
 export function saveModelCache(models, {
   home = os.homedir(),
-  profile = "codex",
   credentialFingerprint = "",
   isCurrent = () => true,
   now = Date.now,
 } = {}) {
   if (!isValidModelList(models)) return false;
   if (typeof isCurrent === "function" && !isCurrent()) return false;
-  const filePath = modelCachePath(home, profile);
+  const filePath = modelCachePath(home);
   const tempPath = `${filePath}.${process.pid}.tmp`;
   const payload = { saved_at: new Date(now()).toISOString(), models };
   const fingerprint = String(credentialFingerprint || "").trim();