@bman654/clodex 2.1.4 → 2.1.5

package/dist/cli.js

@@ -4,6 +4,7 @@ import {
   ensureSecureAppHome,
   findClaudeBinary,
   getAppHome,
+  getClaudeVersionForBinary,
   getCredentialCleanupPath,
   getCredentialMutationLockPath,
   getCredentialStateRoot,
@@ -38,7 +39,7 @@ import {
   withProviderMutationLock,
   withRegistryWriteLock,
   withRegistryWriteLockSync
-} from "./chunk-OVO6OUZG.js";
+} from "./chunk-VQOX3AXE.js";
 
 // src/cli.ts
 import pc13 from "picocolors";
@@ -216,7 +217,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.1.4",
+  version: "2.1.5",
   publishConfig: {
     access: "public"
   },
@@ -5538,6 +5539,7 @@ async function createLanguageModel(spec) {
 }
 var ANTHROPIC_EFFORT_LEVELS = ["low", "medium", "high"];
 var OPENAI_EFFORT_LEVELS = ["low", "medium", "high", "xhigh"];
+var GPT_56_EFFORT_LEVELS = ["none", "low", "medium", "high", "xhigh", "max"];
 var GEMINI_EFFORT_LEVELS = ["low", "medium", "high"];
 var MISTRAL_EFFORT_LEVELS = ["high", "off"];
 var XAI_EFFORT_LEVELS = ["none", "low", "medium", "high"];
@@ -5701,7 +5703,13 @@ function mapCodexEffortToAnthropic(effort) {
       return void 0;
   }
 }
-function mapCodexEffortToOpenAI(effort) {
+function isGpt56Model(modelId) {
+  return /^gpt-5\.6(?:-|$)/i.test(modelId);
+}
+function mapCodexEffortToOpenAI(effort, modelId) {
+  if (modelId && isGpt56Model(modelId) && GPT_56_EFFORT_LEVELS.includes(effort)) {
+    return effort;
+  }
   if (effort === "xhigh") return "high";
   const allowed = ["low", "medium", "high"];
   return allowed.includes(effort) ? effort : void 0;
@@ -5782,7 +5790,7 @@ function getReasoningCapabilities(npm, modelId, metadata) {
     const prefersResponses = modelPrefersResponsesApi(modelId);
     if (prefersResponses || metadata?.reasoning) {
       return {
-        levels: [...OPENAI_EFFORT_LEVELS],
+        levels: isGpt56Model(modelId) ? [...GPT_56_EFFORT_LEVELS] : [...OPENAI_EFFORT_LEVELS],
         defaultLevel: "medium",
         supportsSummaries: true,
         mode: "controllable",
@@ -5904,6 +5912,24 @@ function getReasoningCapabilities(npm, modelId, metadata) {
   }
   return EMPTY_REASONING;
 }
+function getPatchReasoningCapabilities(npm, modelId, metadata) {
+  if (metadata?.reasoning === false && !hasSupportedParameter(metadata, "reasoning_effort") && !hasSupportedParameter(metadata, "reasoning")) {
+    return EMPTY_REASONING;
+  }
+  const capabilities = getReasoningCapabilities(npm, modelId, metadata);
+  const seenProviderOptions = /* @__PURE__ */ new Set();
+  return {
+    ...capabilities,
+    levels: capabilities.levels.filter((level) => {
+      const providerOptions = effortProviderOptions(npm, level, modelId, metadata);
+      if (!providerOptions) return false;
+      const fingerprint = JSON.stringify(providerOptions);
+      if (seenProviderOptions.has(fingerprint)) return false;
+      seenProviderOptions.add(fingerprint);
+      return true;
+    })
+  };
+}
 function effortProviderOptions(npm, effort, modelId, metadata) {
   if (!effort) return void 0;
   if (isOpenRouterRoute(npm, metadata)) {
@@ -5915,7 +5941,7 @@ function effortProviderOptions(npm, effort, modelId, metadata) {
   }
   if (npm === "@ai-sdk/openai" || npm === "@ai-sdk/azure") {
     if (!modelId || !modelPrefersResponsesApi(modelId)) return void 0;
-    const reasoningEffort = mapCodexEffortToOpenAI(effort);
+    const reasoningEffort = mapCodexEffortToOpenAI(effort, modelId);
     return reasoningEffort ? { openai: { reasoningEffort } } : void 0;
   }
   if (npm === "@ai-sdk/xai") {
@@ -8817,31 +8843,151 @@ function sendJson(res, status, body) {
 }
 
 // src/model-aliases.ts
-var MODEL_ALIAS_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
-function isValidModelAlias(name) {
-  return MODEL_ALIAS_PATTERN.test(name);
+var MODEL_ALIAS_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+var RESERVED_MODEL_ALIASES = /* @__PURE__ */ new Set([
+  "sonnet",
+  "opus",
+  "haiku",
+  "fable",
+  "best",
+  "default",
+  "opusplan",
+  "inherit"
+]);
+function canonicalModelAliasName(name) {
+  return name.trim().toLowerCase();
+}
+function isReservedModelAlias(name) {
+  return RESERVED_MODEL_ALIASES.has(
+    stripOneMContextSuffix(canonicalModelAliasName(name))
+  );
+}
+function isModelAliasNameSyntax(name) {
+  return MODEL_ALIAS_PATTERN.test(canonicalModelAliasName(name));
+}
+function modelAliasMatchesName(value, name) {
+  if (!value || typeof value !== "object" || !("name" in value)) return false;
+  const candidate = value.name;
+  return typeof candidate === "string" && canonicalModelAliasName(candidate) === canonicalModelAliasName(name);
+}
+function modelAliasMatchesStoredName(value, name) {
+  if (!value || typeof value !== "object" || !("name" in value)) return false;
+  const candidate = value.name;
+  if (typeof candidate !== "string") return false;
+  const requested = name.trim();
+  return isModelAliasNameSyntax(requested) ? canonicalModelAliasName(candidate) === canonicalModelAliasName(requested) : candidate.trim() === requested;
+}
+function describeModelAliasRejection(reason) {
+  switch (reason) {
+    case "invalid-name":
+      return "invalid name";
+    case "reserved-name":
+      return "reserved client name";
+    case "invalid-target":
+      return "invalid target";
+    case "conflicting-targets":
+      return "conflicting targets";
+    case "target-not-favorite":
+      return "target is not a saved favorite";
+  }
+}
+function normalizeModelAliases(value) {
+  if (value === void 0) {
+    return { aliases: [], accepted: [], rejected: [], rejections: [] };
+  }
+  if (!Array.isArray(value)) {
+    throw new TypeError('Saved model aliases are malformed: "modelAliases" must be an array.');
+  }
+  const candidates = [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const [index, item] of value.entries()) {
+    if (!item || typeof item !== "object" || typeof item.name !== "string") {
+      throw new TypeError(
+        `Saved model aliases are malformed: "modelAliases[${index}]" must be an object with a string "name".`
+      );
+    }
+    const source = item;
+    const candidate = { source };
+    candidates.push(candidate);
+    if (typeof source.providerId !== "string" || typeof source.modelId !== "string") {
+      candidate.rejectionReason = "invalid-target";
+      continue;
+    }
+    const normalized = {
+      name: canonicalModelAliasName(source.name),
+      providerId: source.providerId,
+      modelId: source.modelId
+    };
+    if (!isModelAliasNameSyntax(normalized.name)) {
+      candidate.rejectionReason = "invalid-name";
+      continue;
+    }
+    if (isReservedModelAlias(normalized.name)) {
+      candidate.rejectionReason = "reserved-name";
+      continue;
+    }
+    if (!normalized.providerId.trim() || !normalized.modelId.trim()) {
+      candidate.rejectionReason = "invalid-target";
+      continue;
+    }
+    candidate.normalized = normalized;
+    const group = groups.get(normalized.name) ?? [];
+    group.push(candidate);
+    groups.set(normalized.name, group);
+  }
+  for (const group of groups.values()) {
+    const targets = new Set(
+      group.map((candidate) => `${candidate.normalized.providerId}\0${candidate.normalized.modelId}`)
+    );
+    if (targets.size === 1) {
+      group[0].accepted = true;
+      group[0].sources = group.map((candidate) => candidate.source);
+    } else {
+      for (const candidate of group) candidate.rejectionReason = "conflicting-targets";
+    }
+  }
+  const rejections = candidates.filter((candidate) => candidate.rejectionReason !== void 0).map((candidate) => ({
+    alias: candidate.source,
+    reason: candidate.rejectionReason
+  }));
+  const accepted = candidates.filter((candidate) => candidate.accepted === true && candidate.normalized !== void 0).map((candidate) => ({
+    alias: candidate.normalized,
+    source: candidate.source,
+    sources: candidate.sources ?? [candidate.source]
+  }));
+  return {
+    aliases: accepted.map((entry) => entry.alias),
+    accepted,
+    rejected: rejections.map((rejection) => rejection.alias),
+    rejections
+  };
 }
 function parseModelAliasAssignment(value) {
   const separator = value.indexOf("=");
   if (separator < 1 || separator === value.length - 1) {
     return { error: "Alias must use name=clodex:<provider-id>:<model-id>." };
   }
-  const name = value.slice(0, separator).trim();
-  if (!isValidModelAlias(name)) {
+  const name = canonicalModelAliasName(value.slice(0, separator));
+  if (!MODEL_ALIAS_PATTERN.test(name)) {
     return { error: "Alias names must be 1-64 letters, numbers, dots, underscores, or hyphens." };
   }
+  if (isReservedModelAlias(name)) {
+    return { error: "That alias name is reserved by the client." };
+  }
   const rawTarget = value.slice(separator + 1).trim();
   const target = rawTarget.startsWith("clodex:") ? rawTarget.slice("clodex:".length) : rawTarget;
   const targetSeparator = target.indexOf(":");
-  if (targetSeparator < 1 || targetSeparator === target.length - 1) {
+  const providerId = target.slice(0, targetSeparator).trim();
+  const modelId = stripOneMContextSuffix(target.slice(targetSeparator + 1).trim());
+  if (targetSeparator < 1 || targetSeparator === target.length - 1 || !providerId || !modelId) {
     return { error: "Alias target must use clodex:<provider-id>:<model-id>." };
   }
   return {
     name,
-    providerId: target.slice(0, targetSeparator),
+    providerId,
     // `models --list` prints Claude's synthetic context suffix. It is a client
     // routing hint, not part of the provider catalog id stored in favorites.
-    modelId: stripOneMContextSuffix(target.slice(targetSeparator + 1))
+    modelId
   };
 }
 function modelAliasTarget(alias) {
@@ -8888,11 +9034,32 @@ function makeRouteResolver(localProviders) {
     return provider && model ? localModelToRoute(provider, model) ?? void 0 : void 0;
   };
 }
-function resolveCatalogModelAliases(modelAliases, resolveRoute) {
-  return modelAliases.map((alias) => ({
-    name: alias.name,
-    routeId: resolveRoute(alias.providerId, alias.modelId)?.aliasId ?? modelAliasTarget(alias)
-  }));
+function resolveCatalogModelAliases(modelAliases, resolveRoute, catalogRoutes = []) {
+  const normalized = normalizeModelAliases(modelAliases);
+  const catalogRouteIds = new Set(
+    catalogRoutes.map((route) => normalizeRouteLookupId(route.aliasId))
+  );
+  return [
+    ...normalized.accepted.map(({ alias, source, sources }) => {
+      const route = resolveRoute(alias.providerId, alias.modelId);
+      const collidesWithCatalog = catalogRouteIds.has(
+        normalizeRouteLookupId(alias.name)
+      );
+      const sourceNames = [...new Set(sources.map((entry) => entry.name))];
+      return {
+        name: alias.name,
+        ...source.name === alias.name ? {} : { savedName: source.name },
+        ...sourceNames.length === 1 && sourceNames[0] === alias.name ? {} : { sourceNames },
+        routeId: route?.aliasId ?? modelAliasTarget(alias),
+        ...collidesWithCatalog ? { unavailableReason: "conflicts with a catalog model id" } : route ? {} : { unavailableReason: "target unavailable" }
+      };
+    }),
+    ...normalized.rejections.map((rejection) => ({
+      name: canonicalModelAliasName(rejection.alias.name),
+      ...rejection.alias.name === canonicalModelAliasName(rejection.alias.name) ? {} : { savedName: rejection.alias.name },
+      unavailableReason: describeModelAliasRejection(rejection.reason)
+    }))
+  ];
 }
 function buildCatalogRoutes(startingRoute, favorites, resolveRoute, max = MAX_MODEL_CATALOG) {
   const droppedFavorites = [];
@@ -8916,7 +9083,7 @@ function httpProxyModelId(providerId, modelId) {
 function httpProxyDisplayName(model, providerName) {
   return `${formatModelLabel(model)} (${providerName})`;
 }
-function buildHttpProxyRoutes(providers, favorites, modelAliases = [], max = MAX_MODEL_CATALOG) {
+function buildHttpProxyRoutes(providers, favorites, modelAliases = void 0, max = MAX_MODEL_CATALOG) {
   const routes = [];
   const unavailable = [];
   const unsupported = [];
@@ -8954,16 +9121,21 @@ function buildHttpProxyRoutes(providers, favorites, modelAliases = [], max = MAX
     routesByFavorite.set(`${favorite.providerId}:${favorite.modelId}`, proxyRoute);
   }
   const aliases = [];
-  const unavailableAliases = [];
-  const seenAliases = /* @__PURE__ */ new Set();
-  for (const alias of modelAliases) {
+  const normalizedAliases = normalizeModelAliases(modelAliases);
+  const unavailableAliases = [...normalizedAliases.rejected];
+  for (const { alias, sources } of normalizedAliases.accepted) {
     const route = routesByFavorite.get(`${alias.providerId}:${alias.modelId}`);
-    if (!isValidModelAlias(alias.name) || seenAliases.has(alias.name) || !route) {
-      unavailableAliases.push(alias);
+    if (!route) {
+      unavailableAliases.push(...sources);
       continue;
     }
-    seenAliases.add(alias.name);
-    aliases.push({ name: alias.name, routeId: route.aliasId, displayName: route.displayName });
+    const sourceNames = [...new Set(sources.map((source) => source.name))];
+    aliases.push({
+      name: alias.name,
+      routeId: route.aliasId,
+      displayName: route.displayName,
+      ...sourceNames.length === 1 && sourceNames[0] === alias.name ? {} : { sourceNames }
+    });
   }
   return { routes, unavailable, unsupported, aliases, unavailableAliases };
 }
@@ -9044,7 +9216,7 @@ function createGatewayModelCatalog(models, opts, modelAliases) {
     const canonicalId = httpProxyModelId(gatewayProviderId(model), model.id);
     if (!byId.has(canonicalId)) byId.set(canonicalId, model);
   }
-  for (const alias of modelAliases ?? []) {
+  for (const alias of normalizeModelAliases(modelAliases).aliases) {
     if (byId.has(alias.name)) continue;
     const target = models.find(
       (model) => gatewayProviderId(model) === alias.providerId && model.id === alias.modelId
@@ -9092,8 +9264,9 @@ function formatOpenAIModels(models) {
 }
 
 // src/route-unavailable.ts
-function routeUnavailableMessage(modelId) {
-  return `Clodex model route '${modelId}' is unavailable. Run \`clodex models --list\` to see available routes, or \`clodex patch\` to refresh saved aliases.`;
+function routeUnavailableMessage(modelId, reason) {
+  const detail = reason ? `: ${reason}` : "";
+  return `Clodex model route '${modelId}' is unavailable${detail}. Run \`clodex models --list\` to inspect saved routes and aliases.`;
 }
 
 // src/upstream-forward.ts
@@ -10256,6 +10429,17 @@ function aliasModelId(realId, providerId) {
 function lookupRoute(byAlias, id) {
   return byAlias.get(normalizeRouteLookupId(id));
 }
+function configuredAliasLookupNames(alias) {
+  const sourceNames = [
+    alias.name,
+    ...alias.savedName === void 0 ? [] : [alias.savedName],
+    ...alias.sourceNames ?? []
+  ];
+  return [...new Set(sourceNames.flatMap((name) => {
+    const trimmed = name.trim();
+    return trimmed === name ? [name] : [name, trimmed];
+  }))].map(normalizeRouteLookupId);
+}
 async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenceLogPath, debugLogPath, webSocketDiagnosticsLogPath, modelAliases) {
   const proxyToken = randomUUID4();
   silenceSdkWarnings();
@@ -10264,9 +10448,13 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
   }
   const byAlias = new Map(routes.map((r) => [normalizeRouteLookupId(r.aliasId), r]));
   const configuredAliasNames = new Set(
-    (modelAliases ?? []).map((alias) => normalizeRouteLookupId(alias.name))
+    (modelAliases ?? []).flatMap(configuredAliasLookupNames)
+  );
+  const unavailableAliasReasons = new Map(
+    (modelAliases ?? []).filter((alias) => alias.unavailableReason !== void 0).flatMap((alias) => configuredAliasLookupNames(alias).map((name) => [name, alias.unavailableReason]))
   );
   for (const alias of modelAliases ?? []) {
+    if (alias.routeId === void 0 || alias.unavailableReason !== void 0) continue;
     const route = lookupRoute(byAlias, alias.routeId);
     const aliasId = normalizeRouteLookupId(alias.name);
     if (route && !byAlias.has(aliasId)) byAlias.set(aliasId, route);
@@ -10341,7 +10529,14 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
       const resolvedRoute = typeof originalModel === "string" ? lookupRoute(byAlias, originalModel) : void 0;
       const configuredModelUnavailable = typeof originalModel === "string" && (normalizeRouteLookupId(originalModel).startsWith("clodex:") || configuredAliasNames.has(normalizeRouteLookupId(originalModel)));
       if (!resolvedRoute && configuredModelUnavailable) {
-        anthropicError(res, 400, routeUnavailableMessage(originalModel));
+        anthropicError(
+          res,
+          400,
+          routeUnavailableMessage(
+            originalModel,
+            unavailableAliasReasons.get(normalizeRouteLookupId(originalModel))
+          )
+        );
         return;
       }
       const route = resolvedRoute ?? defaultRoute;
@@ -12382,6 +12577,10 @@ async function startHttpProxy(options) {
   for (const alias of options.modelAliases ?? []) {
     const aliasId = normalizeRouteLookupId(alias.name);
     reservedModelIds.add(aliasId);
+    for (const sourceName of alias.sourceNames ?? []) {
+      reservedModelIds.add(normalizeRouteLookupId(sourceName));
+      reservedModelIds.add(normalizeRouteLookupId(sourceName.trim()));
+    }
     const route = routesById.get(normalizeRouteLookupId(alias.routeId));
     if (!route) continue;
     routesById.set(aliasId, route);
@@ -12632,13 +12831,17 @@ async function startHttpProxy(options) {
 async function loadHttpProxyRoutes() {
   const prefs = loadPreferences();
   const favorites = prefs.favoriteModels ?? [];
+  const normalizedAliases = normalizeModelAliases(prefs.modelAliases);
   if (favorites.length === 0) {
     return {
       routes: [],
       unavailable: [],
       unsupported: [],
       aliases: [],
-      unavailableAliases: prefs.modelAliases ?? [],
+      unavailableAliases: [
+        ...normalizedAliases.rejected,
+        ...normalizedAliases.accepted.flatMap(({ sources }) => sources)
+      ],
       favoriteCount: 0
     };
   }
@@ -12648,7 +12851,7 @@ async function loadHttpProxyRoutes() {
     apiKey: await resolveLocalProviderApiKey(provider) ?? ""
   })));
   return {
-    ...buildHttpProxyRoutes(catalog, favorites, prefs.modelAliases ?? []),
+    ...buildHttpProxyRoutes(catalog, favorites, prefs.modelAliases),
     favoriteCount: favorites.length
   };
 }
@@ -12682,8 +12885,16 @@ function reportSkippedHttpProxyFavorites(loaded) {
     );
   }
   if (loaded.unavailableAliases.length > 0) {
+    const normalizedAliases = normalizeModelAliases(loaded.unavailableAliases);
+    const reasonByAlias = new Map(
+      normalizedAliases.rejections.map((rejection) => [
+        rejection.alias,
+        describeModelAliasRejection(rejection.reason)
+      ])
+    );
     p8.log.warn(
-      `${loaded.unavailableAliases.length} model alias${loaded.unavailableAliases.length === 1 ? "" : "es"} skipped \u2014 its target must be an available HTTP-proxy favorite.`
+      `${loaded.unavailableAliases.length} model alias${loaded.unavailableAliases.length === 1 ? "" : "es"} skipped. Saved entries were preserved.
+` + loaded.unavailableAliases.map((alias) => `  ${JSON.stringify(alias.name)} \u2014 ${reasonByAlias.get(alias) ?? "target unavailable"}`).join("\n")
     );
   }
 }
@@ -12693,7 +12904,14 @@ function buildConfiguredHttpProxyOptions(loaded, port, debug = false, inferenceL
     port,
     routes: loaded.routes,
     modelAliases: loaded.aliases,
-    reservedModelIds: loaded.unavailableAliases.map((alias) => alias.name),
+    reservedModelIds: [...new Set([
+      ...loaded.aliases.flatMap((alias) => alias.sourceNames ?? []),
+      ...loaded.unavailableAliases.map((alias) => alias.name)
+    ].flatMap((name) => {
+      const trimmedName = name.trim();
+      const canonicalName = canonicalModelAliasName(name);
+      return [name, trimmedName, canonicalName].filter(Boolean);
+    }))],
     debug,
     debugLogPath,
     inferenceLogPath,
@@ -13104,7 +13322,28 @@ async function runServerCommand(options = {}) {
     return 1;
   }
   const gateway = runConfig.maskGatewayIds ? { maskGatewayIds: true } : void 0;
-  const modelAliases = loadPreferences().modelAliases ?? [];
+  const normalizedAliases = normalizeModelAliases(loadPreferences().modelAliases);
+  const baseCatalog = createGatewayModelCatalog(models, gateway);
+  const unavailableAliases = normalizedAliases.accepted.filter(({ alias }) => !models.some((model) => gatewayProviderId(model) === alias.providerId && model.id === alias.modelId));
+  const collidingAliases = normalizedAliases.accepted.filter(({ alias }) => baseCatalog.get(alias.name) !== void 0);
+  const collidingAliasNames = new Set(collidingAliases.map(({ alias }) => alias.name));
+  const targetUnavailableAliases = unavailableAliases.filter(({ alias }) => !collidingAliasNames.has(alias.name));
+  const inactiveAliasNames = /* @__PURE__ */ new Set([
+    ...targetUnavailableAliases.map(({ alias }) => alias.name),
+    ...collidingAliasNames
+  ]);
+  const modelAliases = normalizedAliases.aliases.filter((alias) => !inactiveAliasNames.has(alias.name));
+  const aliasWarnings = [
+    ...normalizedAliases.rejections.map((rejection) => `${JSON.stringify(rejection.alias.name)} \u2014 ${describeModelAliasRejection(rejection.reason)}`),
+    ...targetUnavailableAliases.flatMap(({ sources }) => sources.map((source) => `${JSON.stringify(source.name)} \u2014 target unavailable`)),
+    ...collidingAliases.flatMap(({ sources }) => sources.map((source) => `${JSON.stringify(source.name)} \u2014 conflicts with a catalog model id`))
+  ];
+  if (aliasWarnings.length > 0) {
+    p9.log.warn(
+      `${aliasWarnings.length} saved model alias${aliasWarnings.length === 1 ? "" : "es"} inactive. Saved entries were preserved.
+  ${aliasWarnings.join("\n  ")}`
+    );
+  }
   const inferenceLogPath = getInferenceRequestLogPath();
   const webSocketDiagnosticsLogPath = options.wsDiagnostics ? getSessionLogPath("server-websocket-diagnostics", "jsonl") : void 0;
   const server = await startServer({
@@ -13416,25 +13655,192 @@ function planLaunchWizard(opts) {
 }
 
 // src/patcher.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import {
   copyFileSync,
-  existsSync as existsSync6,
+  existsSync as existsSync7,
+  mkdtempSync,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync8,
-  statSync as statSync3,
+  readFileSync as readFileSync9,
+  renameSync as renameSync3,
+  rmSync,
+  statSync as statSync4,
   unlinkSync as unlinkSync4,
   writeFileSync as writeFileSync7,
   openSync as openSync4,
   closeSync as closeSync4,
   realpathSync
 } from "fs";
-import { homedir as homedir2 } from "os";
-import { basename, join as join7 } from "path";
+import { homedir as homedir3 } from "os";
+import { basename, dirname as dirname5, join as join8 } from "path";
 import pc12 from "picocolors";
 import * as p11 from "@clack/prompts";
 
+// src/patch-backup.ts
+import { createHash as createHash7 } from "crypto";
+import { existsSync as existsSync6, readFileSync as readFileSync8, readdirSync, statSync as statSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join7 } from "path";
+var BACKUP_SHA_PREFIX_LENGTH = 16;
+function backupDir() {
+  return process.env["TWEAKCC_CONFIG_DIR"]?.trim() || join7(homedir2(), ".tweakcc");
+}
+function sha256File(path) {
+  return createHash7("sha256").update(readFileSync8(path)).digest("hex");
+}
+function backupVersionTag(version) {
+  const tag = version.trim().replace(/[^\w.-]+/g, "_");
+  if (!tag) throw new Error("clodex patch: refusing to name a pristine backup for an empty claude version");
+  return tag;
+}
+function contentAddressedBackupPath(version, sha256, dir = backupDir()) {
+  return join7(dir, `claude-${backupVersionTag(version)}-${sha256.slice(0, BACKUP_SHA_PREFIX_LENGTH)}.orig`);
+}
+function tweakccMirrorBackupPath(dir = backupDir()) {
+  return join7(dir, "native-binary.backup");
+}
+function scanPristineBackups(version, dir = backupDir()) {
+  const tag = backupVersionTag(version);
+  const pattern = new RegExp(`^claude-${tag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:-([0-9a-f]{${BACKUP_SHA_PREFIX_LENGTH}}))?\\.orig$`);
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return { valid: [], corrupt: [] };
+  }
+  const valid = [];
+  const corrupt = [];
+  for (const entry of entries.sort()) {
+    const match = pattern.exec(entry);
+    if (!match) continue;
+    const path = join7(dir, entry);
+    let sha256;
+    try {
+      if (!statSync3(path).isFile()) continue;
+      sha256 = sha256File(path);
+    } catch {
+      corrupt.push(path);
+      continue;
+    }
+    const embedded = match[1];
+    if (embedded) {
+      if (sha256.slice(0, BACKUP_SHA_PREFIX_LENGTH) !== embedded) {
+        corrupt.push(path);
+        continue;
+      }
+      valid.push({ path, kind: "content-addressed", sha256 });
+    } else {
+      valid.push({ path, kind: "legacy", sha256 });
+    }
+  }
+  return { valid, corrupt };
+}
+var CLODEX_PATCH_COMMENT_PREFIX = "/*ccpatch:";
+var LEGACY_CLODEX_PATCH_MARKERS = [
+  "Additional custom models: ",
+  // PATCH 4 — Agent tool model description
+  "function(_i){return _i.value===_o.value}",
+  // PATCH 5 — picker dedupe guard
+  '"clodex:'
+  // PATCH 1/3 — canonical ids as model identities
+];
+function isPatchedClaudeSource(source) {
+  return source.includes(CLODEX_PATCH_COMMENT_PREFIX);
+}
+function looksLikeLegacyClodexPatch(source) {
+  return !isPatchedClaudeSource(source) && LEGACY_CLODEX_PATCH_MARKERS.some((marker) => source.includes(marker));
+}
+function noBackupMessage(facts) {
+  const corrupt = facts.corruptBackups?.length ? ` (${facts.corruptBackups.length} backup file(s) for this version failed integrity checks and were ignored)` : "";
+  return `claude ${facts.version} is already patched and no trustworthy pristine backup for that version exists in ${backupDir()}${corrupt}. Reinstall Claude Code to get a pristine binary, then run \`clodex patch\`.`;
+}
+function selectRestoreSource(facts) {
+  const notes = [];
+  const manifest = facts.manifest && facts.manifest.binaryPath === facts.binaryPath ? facts.manifest : null;
+  let chosen = manifest?.pristineSha256 ? facts.backups.find((backup) => backup.sha256 === manifest.pristineSha256) : void 0;
+  if (!chosen && manifest?.backupPath) {
+    chosen = facts.backups.find((backup) => backup.path === manifest.backupPath);
+    if (!chosen) {
+      notes.push(`Recorded pristine backup ${manifest.backupPath} is missing, corrupt, or belongs to another claude version \u2014 ignoring it.`);
+    }
+  }
+  if (!chosen) {
+    const distinct = [...new Set(facts.backups.map((backup) => backup.sha256))];
+    if (distinct.length > 1) {
+      return {
+        action: "error",
+        message: `Found conflicting pristine backups for claude ${facts.version}: ${facts.backups.map((backup) => backup.path).join(", ")}. They do not hold the same bytes, so clodex cannot tell which one is pristine. Remove the wrong one (or reinstall Claude Code), then run \`clodex patch\`.`
+      };
+    }
+    chosen = facts.backups.find((backup) => backup.kind === "content-addressed") ?? facts.backups[0];
+  }
+  if (!chosen) return { action: "error", message: noBackupMessage(facts) };
+  return {
+    action: "restore",
+    backupPath: chosen.path,
+    pristineSha256: chosen.sha256,
+    // A legacy name carries no hash, so its bytes could be anything — including
+    // another version's binary, stored under a mislabeled name by an older
+    // clodex. Executing it is the only evidence available; require it.
+    probeVersion: chosen.kind === "legacy",
+    notes
+  };
+}
+function planPristineSource(facts) {
+  const identical = facts.backups.find((backup) => backup.sha256 === facts.liveSha256 && backup.kind === "content-addressed") ?? facts.backups.find((backup) => backup.sha256 === facts.liveSha256);
+  if (identical) {
+    return { action: "reuse", backupPath: identical.path, pristineSha256: identical.sha256, notes: [] };
+  }
+  const manifest = facts.manifest;
+  if (manifest && manifest.binaryPath === facts.binaryPath && manifest.patchedSha256 === facts.liveSha256) {
+    return selectRestoreSource(facts);
+  }
+  return { action: "inspect" };
+}
+function planInspectedPristineSource(facts, inspection) {
+  if (inspection.patched) return selectRestoreSource(facts);
+  const notes = [];
+  const conflicting = facts.backups.filter((backup) => backup.sha256 !== facts.liveSha256);
+  if (conflicting.length) {
+    notes.push(
+      `Existing backup(s) for claude ${facts.version} hold different bytes (${conflicting.map((b) => b.path).join(", ")}); the binary being patched carries no clodex patch marker, so it is being stored under its own content address. Both files are kept.`
+    );
+  }
+  return {
+    action: "snapshot",
+    backupPath: contentAddressedBackupPath(facts.version, facts.liveSha256),
+    pristineSha256: facts.liveSha256,
+    notes
+  };
+}
+function planRestoreOnly(facts) {
+  return selectRestoreSource(facts);
+}
+function collectPristineFacts(args) {
+  const dir = args.dir ?? backupDir();
+  const scan = scanPristineBackups(args.version, dir);
+  return {
+    version: args.version,
+    binaryPath: args.binaryPath,
+    liveSha256: existsSync6(args.binaryPath) ? sha256File(args.binaryPath) : "",
+    manifest: args.manifest,
+    backups: scan.valid,
+    corruptBackups: scan.corrupt
+  };
+}
+
 // src/patch-transforms.ts
+var PATCH_TRANSFORMS_VERSION = 2;
+var NATIVE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+var BASE_EFFORT_LEVELS = ["low", "medium", "high"];
+function projectNativeEffort(effort) {
+  if (!effort || !Array.isArray(effort.levels) || typeof effort.defaultLevel !== "string") return void 0;
+  const declared = new Set(effort.levels);
+  const levels = NATIVE_EFFORT_LEVELS.filter((level) => declared.has(level));
+  if (!BASE_EFFORT_LEVELS.every((level) => declared.has(level))) return void 0;
+  if (!levels.some((level) => level === effort.defaultLevel)) return void 0;
+  return { levels, defaultLevel: "high" };
+}
 var PatchApplyError = class extends Error {
   results;
   constructor(message, results) {
@@ -13449,21 +13855,37 @@ function formatPatchSiteLine(result) {
 function applyClodexPatches(source, config) {
   let js = source;
   const MODEL_CONFIG = config;
-  const ALIAS_TO_ID = {};
+  const ALIAS_TO_ID = /* @__PURE__ */ Object.create(null);
   const IDENTITIES = [];
-  const DISPLAY_BY_IDENTITY = {};
-  const CONTEXT_BY_KEY = {};
+  const DISPLAY_BY_IDENTITY = /* @__PURE__ */ Object.create(null);
+  const CONTEXT_BY_KEY = /* @__PURE__ */ Object.create(null);
+  const CONFIGURED_CAPABILITY_KEYS = /* @__PURE__ */ new Set();
+  const EFFORT_BY_KEY = /* @__PURE__ */ Object.create(null);
   const report = [];
   const fail = (message) => {
     throw new PatchApplyError(message, report);
   };
+  const capabilityKeys = (value) => {
+    const normalized = value.trim().toLowerCase();
+    const bare = normalized.replace(/\[1m\]$/i, "");
+    return [.../* @__PURE__ */ new Set([bare, `${bare}[1m]`])];
+  };
+  const registerCapabilityKeys = (value) => {
+    for (const key of capabilityKeys(value)) {
+      CONFIGURED_CAPABILITY_KEYS.add(key);
+    }
+  };
   for (const [id, value] of Object.entries(MODEL_CONFIG)) {
     const spec = value && typeof value === "object" ? value : { alias: value };
     if (spec.alias !== void 0) {
-      const a = String(spec.alias).trim().toLowerCase();
+      const rawAlias = String(spec.alias).trim();
+      const a = rawAlias.toLowerCase();
       if (!/^[a-z0-9][a-z0-9._-]*(\[1m\])?$/.test(a)) {
         fail('clodex patch: alias "' + spec.alias + '" is not a safe lowercase alias');
       }
+      if (isReservedModelAlias(a)) {
+        fail('clodex patch: reserved alias "' + a + '" cannot be reassigned');
+      }
       ALIAS_TO_ID[a] = String(id);
       IDENTITIES.push(a);
       if (spec.display) DISPLAY_BY_IDENTITY[a] = String(spec.display);
@@ -13471,6 +13893,10 @@ function applyClodexPatches(source, config) {
       IDENTITIES.push(String(id));
       if (spec.display) DISPLAY_BY_IDENTITY[String(id)] = String(spec.display);
     }
+    if (spec.alias !== void 0) {
+      registerCapabilityKeys(String(spec.alias));
+    }
+    registerCapabilityKeys(String(id));
     if (spec.context !== void 0) {
       const n = Number(spec.context);
       if (!Number.isInteger(n) || n <= 0) {
@@ -13484,6 +13910,22 @@ function applyClodexPatches(source, config) {
       if (spec.alias !== void 0) CONTEXT_BY_KEY[String(spec.alias).trim().toLowerCase()] = n;
       CONTEXT_BY_KEY[String(id).trim().toLowerCase()] = n;
     }
+    if (spec.effort) {
+      const effort = projectNativeEffort(spec.effort);
+      if (!effort) {
+        fail(
+          `clodex patch: effort for "${id}" must include low, medium, and high with a native default`
+        );
+      }
+      if (spec.alias !== void 0) {
+        for (const key of capabilityKeys(String(spec.alias))) {
+          EFFORT_BY_KEY[key] = effort;
+        }
+      }
+      for (const key of capabilityKeys(String(id))) {
+        EFFORT_BY_KEY[key] = effort;
+      }
+    }
   }
   const ALIASES = Object.keys(ALIAS_TO_ID);
   const MODELS = Object.keys(MODEL_CONFIG);
@@ -13611,19 +14053,91 @@ function applyClodexPatches(source, config) {
       );
     }
   }
+  function patchEffortCapability(capability, marker, name, anchor) {
+    const verdicts = Object.fromEntries(
+      [...CONFIGURED_CAPABILITY_KEYS].map((key) => {
+        const effort = EFFORT_BY_KEY[key];
+        return [
+          key,
+          effort !== void 0 && (capability === "effort" || effort.levels.includes(capability === "xhigh_effort" ? "xhigh" : "max"))
+        ];
+      })
+    );
+    const hasMarker = js.includes(marker);
+    if (Object.keys(verdicts).length === 0 && !hasMarker) return;
+    const snippet = (arg) => marker + "var _ccv=Object.assign(Object.create(null)," + JSON.stringify(verdicts) + ")[String(" + arg + '||"").trim().toLowerCase()];if(_ccv!==void 0)return _ccv;';
+    if (hasMarker) {
+      const markerPattern = reEsc(marker);
+      applyOnce(
+        name + " (refresh)",
+        new RegExp(
+          markerPattern + 'var _ccv=Object\\.assign\\(Object\\.create\\(null\\),\\{[^{}]*\\}\\)\\[String\\(([\\w$]+)\\|\\|""\\)\\.trim\\(\\)\\.toLowerCase\\(\\)\\];if\\(_ccv!==void 0\\)return _ccv;'
+        ),
+        (_m, arg) => snippet(arg),
+        { required: false, noopIsSkip: true }
+      );
+      return;
+    }
+    applyOnce(
+      name,
+      anchor,
+      (_m, head, arg, body) => head + snippet(arg) + body,
+      { required: false }
+    );
+  }
+  patchEffortCapability(
+    "effort",
+    "/*ccpatch:effort*/",
+    "PATCH 8a: effort capability",
+    /(function [\w$]+\(([\w$]+)\)\{if\([\w$]+\(\2\)\)return!1;)(let [\w$]+=[\w$]+\(\2,"effort"\);)/
+  );
+  patchEffortCapability(
+    "xhigh_effort",
+    "/*ccpatch:xhigh-effort*/",
+    "PATCH 8b: xhigh effort capability",
+    /(function [\w$]+\(([\w$]+)\)\{if\([\w$]+\(\2\)\)return!1;)(let [\w$]+=[\w$]+\(\2,"xhigh_effort"\);)/
+  );
+  patchEffortCapability(
+    "max_effort",
+    "/*ccpatch:max-effort*/",
+    "PATCH 8c: max effort capability",
+    /(function [\w$]+\(([\w$]+)\)\{if\([\w$]+\(\2\)\)return!1;)(let [\w$]+=[\w$]+\(\2,"max_effort"\);)/
+  );
+  const DEFAULT_EFFORT_MARKER = "/*ccpatch:default-effort*/";
+  const defaults = Object.fromEntries(
+    Object.entries(EFFORT_BY_KEY).map(([key, effort]) => [key, effort.defaultLevel])
+  );
+  if (Object.keys(defaults).length || js.includes(DEFAULT_EFFORT_MARKER)) {
+    const snippet = (arg) => DEFAULT_EFFORT_MARKER + "var _cce=Object.assign(Object.create(null)," + JSON.stringify(defaults) + ")[String(" + arg + '||"").trim().toLowerCase()];if(_cce!==void 0)return _cce;';
+    if (js.includes(DEFAULT_EFFORT_MARKER)) {
+      applyOnce(
+        "PATCH 9: default effort (refresh)",
+        /\/\*ccpatch:default-effort\*\/var _cce=Object\.assign\(Object\.create\(null\),\{[^{}]*\}\)\[String\(([\w$]+)\|\|""\)\.trim\(\)\.toLowerCase\(\)\];if\(_cce!==void 0\)return _cce;/,
+        (_m, arg) => snippet(arg),
+        { required: false, noopIsSkip: true }
+      );
+    } else {
+      applyOnce(
+        "PATCH 9: default effort",
+        /(function [\w$]+\(([\w$]+)\)\{)(return [\w$]+\([\w$]+\(\2\)\)\?\.default_effort\?\?"high"\})/,
+        (_m, head, arg, body) => head + snippet(arg) + body,
+        { required: false }
+      );
+    }
+  }
   return { content: js, results: report };
 }
 
 // src/patcher.ts
 function getPatchManifestPath() {
-  return join7(getAppHome(), "patch-state.json");
+  return join8(getAppHome(), "patch-state.json");
 }
 function getPatchLockPath() {
-  return join7(getAppHome(), "patch.lock");
+  return join8(getAppHome(), "patch.lock");
 }
 function readPatchManifest(path = getPatchManifestPath()) {
   try {
-    const parsed = JSON.parse(readFileSync8(path, "utf8"));
+    const parsed = JSON.parse(readFileSync9(path, "utf8"));
     if (parsed && typeof parsed.binaryPath === "string" && typeof parsed.configHash === "string") {
       return parsed;
     }
@@ -13639,7 +14153,20 @@ function writePatchManifest(manifest, path = getPatchManifestPath()) {
 function buildPatchModelConfig(favorites, aliases, modelMetaFor) {
   const config = {};
   const unknownWindows = [];
-  const aliasByFavorite = new Map(aliases.map((a) => [`${a.providerId}:${a.modelId}`, a.name]));
+  const normalizedAliases = normalizeModelAliases(aliases);
+  const favoriteTargets = new Set(
+    favorites.map((favorite) => `${favorite.providerId}:${favorite.modelId}`)
+  );
+  const targetRejections = normalizedAliases.accepted.filter(({ alias }) => !favoriteTargets.has(`${alias.providerId}:${alias.modelId}`)).flatMap(({ sources }) => sources.map((source) => ({
+    alias: source,
+    reason: "target-not-favorite"
+  })));
+  const aliasByFavorite = new Map(
+    normalizedAliases.aliases.filter((alias) => favoriteTargets.has(`${alias.providerId}:${alias.modelId}`)).map((alias) => [
+      `${alias.providerId}:${alias.modelId}`,
+      alias.name
+    ])
+  );
   for (const favorite of favorites) {
     const id = stripOneMContextSuffix(httpProxyModelId(favorite.providerId, favorite.modelId));
     if (config[id]) continue;
@@ -13652,29 +14179,68 @@ function buildPatchModelConfig(favorites, aliases, modelMetaFor) {
     else if (context !== 2e5) entry.context = context;
     const display = meta?.displayName?.trim();
     if (display) entry.display = display;
+    const effort = projectNativeEffort(meta?.effort);
+    if (effort) entry.effort = effort;
     config[id] = entry;
   }
-  return { config, unknownWindows };
+  return {
+    config,
+    unknownWindows,
+    rejectedAliases: [
+      ...normalizedAliases.rejected,
+      ...targetRejections.map((rejection) => rejection.alias)
+    ],
+    rejectedAliasRejections: [
+      ...normalizedAliases.rejections,
+      ...targetRejections
+    ]
+  };
 }
-function computePatchConfigHash(config) {
+function reportRejectedModelAliases(rejections) {
+  for (const rejection of rejections) {
+    p11.log.warn(
+      `Saved model alias ${JSON.stringify(rejection.alias.name)} was not patched \u2014 ${describeModelAliasRejection(rejection.reason)}. The saved entry was preserved.`
+    );
+  }
+}
+function computePatchConfigHash(config, transformsVersion = PATCH_TRANSFORMS_VERSION) {
   const canonical = Object.keys(config).sort().map((key) => {
     const entry = config[key];
-    return [key, entry.alias ?? null, entry.context ?? null, entry.display ?? null];
+    return [
+      key,
+      entry.alias ?? null,
+      entry.context ?? null,
+      entry.display ?? null,
+      entry.effort?.levels ?? null,
+      entry.effort?.defaultLevel ?? null
+    ];
   });
-  return createHash7("sha256").update(JSON.stringify(canonical)).digest("hex");
+  return createHash8("sha256").update(JSON.stringify([transformsVersion, canonical])).digest("hex");
 }
 function buildDesiredPatchConfig() {
   const prefs = loadPreferences();
   const favorites = prefs.favoriteModels ?? [];
-  const aliases = prefs.modelAliases ?? [];
+  const aliases = prefs.modelAliases;
   const registry = loadRegistry();
   const meta = /* @__PURE__ */ new Map();
   for (const provider of registry.providers) {
     for (const model of provider.modelsCache?.models ?? []) {
+      const npm = model.npm ?? provider.api.npm ?? "";
+      const upstreamModelId2 = model.upstreamModelId ?? model.id;
+      const modelsDev = findModelsDevModel(provider.id, model.id);
+      const effort = getPatchReasoningCapabilities(npm, upstreamModelId2, {
+        providerId: provider.id,
+        apiBaseUrl: model.apiUrl ?? provider.api.url,
+        supportedParameters: model.supportedParameters,
+        reasoning: model.reasoning ?? modelsDev?.reasoning,
+        interleavedReasoningField: model.interleavedReasoningField ?? modelsDev?.interleaved?.field,
+        upstreamModelId: upstreamModelId2
+      });
       meta.set(`${provider.id}:${model.id}`, {
         contextWindow: model.contextWindow && model.contextWindow > 0 ? model.contextWindow : void 0,
         // Same label `clodex server` prints at startup and `models --list` shows.
-        displayName: httpProxyDisplayName(model, provider.name)
+        displayName: httpProxyDisplayName(model, provider.name),
+        effort: effort.mode === "controllable" ? { levels: effort.levels, defaultLevel: effort.defaultLevel } : void 0
       });
     }
   }
@@ -13704,7 +14270,7 @@ function pidIsAlive(pid) {
 function tryAcquirePatchLock(lockPath = getPatchLockPath(), opts = {}) {
   const now = opts.now ?? Date.now();
   const isAlive = opts.isAlive ?? pidIsAlive;
-  mkdirSync7(join7(lockPath, ".."), { recursive: true, mode: 448 });
+  mkdirSync7(join8(lockPath, ".."), { recursive: true, mode: 448 });
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
       const fd = openSync4(lockPath, "wx");
@@ -13720,7 +14286,7 @@ function tryAcquirePatchLock(lockPath = getPatchLockPath(), opts = {}) {
     } catch {
       let stale = false;
       try {
-        const existing = JSON.parse(readFileSync8(lockPath, "utf8"));
+        const existing = JSON.parse(readFileSync9(lockPath, "utf8"));
         stale = !existing.pid || !isAlive(existing.pid) || typeof existing.startedAt === "number" && now - existing.startedAt > PATCH_LOCK_STALE_MS;
       } catch {
         stale = true;
@@ -13734,33 +14300,28 @@ function tryAcquirePatchLock(lockPath = getPatchLockPath(), opts = {}) {
   }
   return null;
 }
-function sha256File(path) {
-  return createHash7("sha256").update(readFileSync8(path)).digest("hex");
-}
 function resolveClaudeBinaryForPatch() {
   const envOverride = process.env["TWEAKCC_CC_INSTALLATION_PATH"];
-  const nativeSymlink = join7(homedir2(), ".local", "bin", "claude");
-  const source = envOverride?.trim() || (existsSync6(nativeSymlink) ? nativeSymlink : null) || findClaudeBinary();
-  if (!source) return null;
+  const nativeSymlink = join8(homedir3(), ".local", "bin", "claude");
+  const source = envOverride?.trim() || (existsSync7(nativeSymlink) ? nativeSymlink : null) || findClaudeBinary();
+  if (!source) return { ok: false, reason: "binary-not-found" };
   let resolved;
   try {
     resolved = realpathSync(source);
   } catch {
-    return null;
+    return { ok: false, reason: "binary-not-found" };
   }
   try {
-    if (!statSync3(resolved).isFile()) return null;
+    if (!statSync4(resolved).isFile()) return { ok: false, reason: "binary-not-found" };
   } catch {
-    return null;
+    return { ok: false, reason: "binary-not-found" };
   }
-  return { binaryPath: resolved, version: getInstalledClaudeVersion() };
+  const version = getClaudeVersionForBinary(resolved);
+  if (!version) return { ok: false, reason: "version-unknown", binaryPath: resolved };
+  return { ok: true, binaryPath: resolved, version };
 }
-function backupDir() {
-  return process.env["TWEAKCC_CONFIG_DIR"]?.trim() || join7(homedir2(), ".tweakcc");
-}
-function pristineBackupPath(version, binaryPath) {
-  const tag = version.replace(/[^\w.-]+/g, "_") || basename(binaryPath);
-  return join7(backupDir(), `claude-${tag}.orig`);
+function describePatchTargetFailure(target) {
+  return target.reason === "binary-not-found" ? "claude binary not found. Install Claude Code or set TWEAKCC_CC_INSTALLATION_PATH." : `Could not determine the version of ${target.binaryPath} (\`claude --version\` failed). clodex will not patch a binary whose version it cannot read, because the version selects the pristine backup it patches from. If a previous patch left the install broken, \`clodex patch --restore\` still works \u2014 it reads the version from the patch manifest.`;
 }
 function summarizePatchResults(results) {
   const lines = results.map(formatPatchSiteLine);
@@ -13773,26 +14334,112 @@ function summarizePatchResults(results) {
   }
   return lines;
 }
+function verifyPristineSource(plan, version) {
+  if (!plan.probeVersion) return { ok: true };
+  const backupVersion = getClaudeVersionForBinary(plan.backupPath);
+  if (backupVersion === version) return { ok: true };
+  return {
+    ok: false,
+    message: `Refusing to use ${plan.backupPath} as the pristine source for claude ${version}: it reports ${backupVersion ? `version ${backupVersion}` : "no version at all"}. That backup predates content-addressed backup names and does not hold this version's bytes. Remove it (or reinstall Claude Code), then run \`clodex patch\`.`
+  };
+}
+function publishBackupFile(from, to) {
+  const temp = `${to}.tmp-${process.pid}-${Date.now().toString(36)}`;
+  try {
+    copyFileSync(from, temp);
+    renameSync3(temp, to);
+  } catch (err) {
+    try {
+      rmSync(temp, { force: true });
+    } catch {
+    }
+    throw err;
+  }
+}
+function describePoisonedPristineSource(backupPath, version) {
+  return `Refusing to patch from ${backupPath}: those bytes already carry a clodex patch, so they are not pristine and patching them would stack a patch on a patch. That backup was recorded as pristine for claude ${version} by an older clodex, which snapshotted whatever binary was live when no backup existed. Delete ${backupPath}, reinstall Claude Code, then run \`clodex patch\`.`;
+}
+function requiredEffortPatchFailures(results) {
+  return results.filter(
+    (result) => result.status === "FAIL" && (result.name.startsWith("PATCH 8a:") || result.name.startsWith("PATCH 8b:") || result.name.startsWith("PATCH 8c:") || result.name.startsWith("PATCH 9:"))
+  );
+}
 async function applyPatch(binaryPath, version, desired, configHash, opts) {
-  const backup = pristineBackupPath(version, binaryPath);
-  mkdirSync7(backupDir(), { recursive: true });
-  if (opts.restoreFirst) {
-    if (!existsSync6(backup)) {
-      return { ok: false, message: `Cannot re-patch: pristine backup missing at ${backup}. Reinstall claude, then run clodex patch.` };
-    }
-    copyFileSync(backup, binaryPath);
-  } else if (!existsSync6(backup)) {
-    copyFileSync(binaryPath, backup);
-  }
-  copyFileSync(backup, join7(backupDir(), "native-binary.backup"));
-  const { tryDetectInstallation, readContent, writeContent } = await import("tweakcc");
+  let candidateDir;
   let results;
+  let patchedSize;
+  let patchedSha256;
+  let backup;
+  let pristineSha256;
   try {
-    const installation = await tryDetectInstallation({ path: binaryPath });
-    const source = await readContent(installation);
-    const patched = applyClodexPatches(source, desired.config);
+    mkdirSync7(backupDir(), { recursive: true });
+    const { tryDetectInstallation, readContent, writeContent } = await import("tweakcc");
+    candidateDir = mkdtempSync(join8(dirname5(binaryPath), ".clodex-patch-"));
+    const candidatePath = join8(candidateDir, basename(binaryPath));
+    const seedCandidate = async (from) => {
+      copyFileSync(from, candidatePath);
+      const installation = await tryDetectInstallation({ path: candidatePath });
+      return { installation, source: await readContent(installation) };
+    };
+    const facts = collectPristineFacts({
+      version,
+      binaryPath,
+      manifest: opts.manifest
+    });
+    const initial = planPristineSource(facts);
+    let loaded = null;
+    let plan;
+    if (initial.action === "inspect") {
+      loaded = await seedCandidate(binaryPath);
+      if (looksLikeLegacyClodexPatch(loaded.source)) {
+        p11.log.warn(
+          `${binaryPath} carries no clodex patch marker but does look like a patch from a clodex older than the effort patch sites. Treating it as pristine; if \`/model\` shows stale entries afterwards, reinstall Claude Code and run \`clodex patch\` again.`
+        );
+      }
+      plan = planInspectedPristineSource(facts, { patched: isPatchedClaudeSource(loaded.source) });
+      if (plan.action !== "snapshot") loaded = null;
+    } else {
+      plan = initial;
+    }
+    if (plan.action === "error") return { ok: false, message: plan.message };
+    for (const note of plan.notes) p11.log.warn(note);
+    if (plan.action === "restore") {
+      const verified = verifyPristineSource(plan, version);
+      if (!verified.ok) return { ok: false, message: verified.message };
+      p11.log.info(`Binary differs from its pristine backup \u2014 building a fresh patch candidate from ${plan.backupPath}.`);
+    }
+    pristineSha256 = plan.pristineSha256;
+    backup = plan.backupPath;
+    if (!loaded) {
+      loaded = await seedCandidate(backup);
+      if (isPatchedClaudeSource(loaded.source)) {
+        return { ok: false, message: describePoisonedPristineSource(backup, version) };
+      }
+    } else if (plan.action === "snapshot") {
+      publishBackupFile(candidatePath, plan.backupPath);
+    }
+    const canonical = contentAddressedBackupPath(version, pristineSha256);
+    if (canonical !== backup) {
+      const alreadyStored = facts.backups.some(
+        (candidate) => candidate.path === canonical && candidate.sha256 === pristineSha256
+      );
+      if (!alreadyStored) publishBackupFile(backup, canonical);
+      backup = canonical;
+    }
+    publishBackupFile(backup, tweakccMirrorBackupPath());
+    const patched = applyClodexPatches(loaded.source, desired.config);
     results = patched.results;
-    await writeContent(installation, patched.content);
+    const failedEffortPatches = requiredEffortPatchFailures(results);
+    if (failedEffortPatches.length > 0) {
+      throw new PatchApplyError(
+        `clodex patch: required effort patches failed: ${failedEffortPatches.map((result) => result.name).join("; ")}`,
+        results
+      );
+    }
+    await writeContent(loaded.installation, patched.content);
+    patchedSize = statSync4(candidatePath).size;
+    patchedSha256 = sha256File(candidatePath);
+    renameSync3(candidatePath, binaryPath);
   } catch (err) {
     const detailLines = err instanceof PatchApplyError ? summarizePatchResults(err.results) : [];
     if (opts.trace && detailLines.length) {
@@ -13804,6 +14451,19 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
       message: `Patch failed: ${err instanceof Error ? err.message : String(err)}`,
       detailLines
     };
+  } finally {
+    if (candidateDir !== void 0) {
+      try {
+        rmSync(candidateDir, { recursive: true, force: true });
+      } catch (err) {
+        if (opts.trace) {
+          process.stderr.write(
+            `clodex patch: could not remove temporary candidate directory: ${err instanceof Error ? err.message : String(err)}
+`
+          );
+        }
+      }
+    }
   }
   if (opts.trace) {
     process.stderr.write(`${summarizePatchResults(results).join("\n")}
@@ -13813,9 +14473,10 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
     binaryPath,
     claudeVersion: version,
     configHash,
-    patchedSize: statSync3(binaryPath).size,
-    patchedSha256: sha256File(binaryPath),
+    patchedSize,
+    patchedSha256,
     backupPath: backup,
+    pristineSha256,
     patchedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   writePatchManifest(manifest);
@@ -13828,28 +14489,54 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
     detailLines: summarizePatchResults(results)
   };
 }
-async function runPatchCommand(opts = {}) {
-  const resolved = resolveClaudeBinaryForPatch();
-  if (!resolved) {
-    p11.log.error("claude binary not found. Install Claude Code or set TWEAKCC_CC_INSTALLATION_PATH.");
+function runRestoreCommand(target) {
+  if (!target.ok && target.reason === "binary-not-found") {
+    p11.log.error(describePatchTargetFailure(target));
     return 1;
   }
-  const { binaryPath, version } = resolved;
-  if (opts.restore) {
-    const manifest2 = readPatchManifest();
-    const backup = manifest2?.backupPath && existsSync6(manifest2.backupPath) ? manifest2.backupPath : pristineBackupPath(version, binaryPath);
-    if (!existsSync6(backup)) {
-      p11.log.error(`No pristine backup found for claude ${version} (${backup}).`);
-      return 1;
-    }
-    copyFileSync(backup, binaryPath);
-    try {
-      unlinkSync4(getPatchManifestPath());
-    } catch {
-    }
-    p11.log.success(`Restored pristine claude ${version} from ${backup}.`);
-    return 0;
+  const binaryPath = target.binaryPath;
+  const manifest = readPatchManifest();
+  let version;
+  if (target.ok) {
+    version = target.version;
+  } else if (manifest?.binaryPath === binaryPath && manifest.claudeVersion) {
+    version = manifest.claudeVersion;
+    p11.log.warn(
+      `Could not read the version of ${binaryPath} (\`claude --version\` failed) \u2014 using claude ${version} from the patch manifest, which recorded it when this binary was patched. This is expected when a bad patch left the install unable to run.`
+    );
+  } else {
+    p11.log.error(
+      `Could not determine the version of ${binaryPath} (\`claude --version\` failed), and no patch manifest records a pristine backup for it, so clodex cannot tell which backup belongs to this install. Restore it by hand from ${backupDir()} (or reinstall Claude Code).`
+    );
+    return 1;
+  }
+  const plan = planRestoreOnly(collectPristineFacts({ version, binaryPath, manifest }));
+  if (plan.action === "error") {
+    p11.log.error(plan.message);
+    return 1;
+  }
+  for (const note of plan.notes) p11.log.warn(note);
+  const verified = verifyPristineSource(plan, version);
+  if (!verified.ok) {
+    p11.log.error(verified.message);
+    return 1;
+  }
+  copyFileSync(plan.backupPath, binaryPath);
+  try {
+    unlinkSync4(getPatchManifestPath());
+  } catch {
+  }
+  p11.log.success(`Restored pristine claude ${version} from ${plan.backupPath}.`);
+  return 0;
+}
+async function runPatchCommand(opts = {}) {
+  const target = resolveClaudeBinaryForPatch();
+  if (opts.restore) return runRestoreCommand(target);
+  if (!target.ok) {
+    p11.log.error(describePatchTargetFailure(target));
+    return 1;
   }
+  const { binaryPath, version } = target;
   const desired = buildDesiredPatchConfig();
   if (Object.keys(desired.config).length === 0) {
     p11.log.error("No favorite models to patch. Save favorites with `clodex models` first.");
@@ -13858,13 +14545,14 @@ async function runPatchCommand(opts = {}) {
   for (const id of desired.unknownWindows) {
     p11.log.warn(`No context window metadata for ${id} \u2014 Claude Code will assume the 200k default.`);
   }
+  reportRejectedModelAliases(desired.rejectedAliasRejections);
   const configHash = computePatchConfigHash(desired.config);
   const manifest = readPatchManifest();
   const state = evaluatePatchState(manifest, {
     binaryPath,
     claudeVersion: version,
     configHash,
-    binarySize: statSync3(binaryPath).size
+    binarySize: statSync4(binaryPath).size
   });
   if (state === "current") {
     p11.log.success(`claude ${version} is already patched with the current model config \u2014 nothing to do.`);
@@ -13876,14 +14564,9 @@ async function runPatchCommand(opts = {}) {
     return 1;
   }
   try {
-    const backup = pristineBackupPath(version, binaryPath);
-    const restoreFirst = existsSync6(backup) && sha256File(backup) !== sha256File(binaryPath);
-    if (restoreFirst) {
-      p11.log.info("Binary differs from its pristine backup \u2014 restoring it before patching fresh.");
-    }
     const outcome = await applyPatch(binaryPath, version, desired, configHash, {
       trace: opts.trace ?? false,
-      restoreFirst
+      manifest
     });
     if (!outcome.ok) {
       p11.log.error(outcome.message);
@@ -13903,15 +14586,21 @@ async function runLaunchPatchCheck(opts = {}) {
   try {
     const desired = buildDesiredPatchConfig();
     if (Object.keys(desired.config).length === 0) return;
-    const resolved = resolveClaudeBinaryForPatch();
-    if (!resolved) return;
+    const target = resolveClaudeBinaryForPatch();
+    if (!target.ok) {
+      if (target.reason === "version-unknown" && !opts.agentStdout) {
+        console.error(pc12.dim(`clodex: ${describePatchTargetFailure(target)}`));
+      }
+      return;
+    }
+    const resolved = target;
     const configHash = computePatchConfigHash(desired.config);
     const manifest = readPatchManifest();
     const state = evaluatePatchState(manifest, {
       binaryPath: resolved.binaryPath,
       claudeVersion: resolved.version,
       configHash,
-      binarySize: statSync3(resolved.binaryPath).size
+      binarySize: statSync4(resolved.binaryPath).size
     });
     if (state === "current") return;
     const interactive = !opts.dryRun && !opts.agentStdout && process.stdin.isTTY === true && process.stdout.isTTY === true;
@@ -14351,6 +15040,7 @@ ${pc13.bold("Behavior:")}
   proxy mode, without opening the interactive manager.
   --alias <name=target> saves a short name for a proxy-mode favorite. The
   target is clodex:<provider-id>:<model-id> (the clodex: prefix is optional).
+  Alias names are stored lowercase and cannot use client-reserved model names.
   --unalias <name> removes a saved short name.
 
 ${pc13.bold("How it works:")}
@@ -14392,7 +15082,19 @@ function printHelp(text4) {
 ${text4}
 `);
 }
+function reportInactiveCatalogAliases(modelAliases) {
+  const unavailableAliases = modelAliases.filter((alias) => alias.unavailableReason !== void 0);
+  if (unavailableAliases.length === 0) return;
+  const warningLines = unavailableAliases.flatMap((alias) => alias.sourceNames?.length ? alias.sourceNames.map((name) => `  ${JSON.stringify(name)} \u2014 ${alias.unavailableReason}`) : [
+    `  ${JSON.stringify(alias.savedName ?? alias.name)} \u2014 ${alias.unavailableReason}`
+  ]);
+  p12.log.warn(
+    `${warningLines.length} saved model alias${warningLines.length === 1 ? "" : "es"} inactive. Saved entries were preserved.
+` + warningLines.join("\n")
+  );
+}
 async function launchClaudeViaCatalog(catalogRoutes, startingRoute, modelAliases, contextWindow, trace, claudeArgs) {
+  reportInactiveCatalogAliases(modelAliases);
   let proxyHandle;
   try {
     proxyHandle = await startProxyCatalog(
@@ -14452,27 +15154,36 @@ async function runModelsCommand(opts = {}) {
       p12.log.info("Add it with `clodex models`, then save the alias.");
       return 1;
     }
-    const modelAliases = (prefs2.modelAliases ?? []).filter((alias) => alias.name !== parsed.name);
+    if (prefs2.modelAliases !== void 0 && !Array.isArray(prefs2.modelAliases)) {
+      p12.log.error('Saved model aliases are malformed: "modelAliases" must be an array.');
+      return 1;
+    }
+    const aliases = prefs2.modelAliases ?? [];
+    const modelAliases = aliases.filter((alias) => !modelAliasMatchesName(alias, parsed.name));
     modelAliases.push(parsed);
     savePreferences({ modelAliases });
     p12.log.success(`Saved model alias ${parsed.name} \u2192 ${modelAliasTarget(parsed)}.`);
     return 0;
   }
   if (opts.unalias !== void 0) {
-    const name = opts.unalias.trim();
-    if (!isValidModelAlias(name)) {
-      p12.log.error("Alias names must be 1-64 letters, numbers, dots, underscores, or hyphens.");
+    const requestedName = opts.unalias.trim();
+    const name = canonicalModelAliasName(requestedName);
+    const prefs2 = loadPreferences();
+    if (prefs2.modelAliases !== void 0 && !Array.isArray(prefs2.modelAliases)) {
+      p12.log.error('Saved model aliases are malformed: "modelAliases" must be an array.');
       return 1;
     }
-    const prefs2 = loadPreferences();
     const aliases = prefs2.modelAliases ?? [];
-    const modelAliases = aliases.filter((alias) => alias.name !== name);
-    if (modelAliases.length === aliases.length) {
-      p12.log.error(`No model alias named ${name} is saved.`);
+    const modelAliases = aliases.filter((alias) => !modelAliasMatchesStoredName(alias, requestedName));
+    const removedCount = aliases.length - modelAliases.length;
+    if (removedCount === 0) {
+      p12.log.error(`No model alias named ${JSON.stringify(requestedName)} is saved.`);
       return 1;
     }
     savePreferences({ modelAliases });
-    p12.log.success(`Removed model alias ${name}.`);
+    p12.log.success(
+      removedCount === 1 ? `Removed model alias ${name || JSON.stringify(requestedName)}.` : `Removed ${removedCount} model aliases named ${name || JSON.stringify(requestedName)}.`
+    );
     return 0;
   }
   if (opts.list) {
@@ -14956,7 +15667,11 @@ Error: ${launchPlan.error}
     return launchClaudeViaCatalog(
       catalogRoutes,
       startingRoute,
-      resolveCatalogModelAliases(prefs.modelAliases ?? [], resolveRoute),
+      resolveCatalogModelAliases(
+        prefs.modelAliases,
+        resolveRoute,
+        catalogRoutes
+      ),
       selectedModel.contextWindow,
       trace,
       claudeArgs
@@ -15203,6 +15918,7 @@ export {
   modelsHelpText,
   parseArgs,
   patchHelpText,
+  reportInactiveCatalogAliases,
   rootHelpText,
   runClaudeCommand,
   runModelsCommand,